From bfe27fdc08346cc6a135f2c5880068f888703414 Mon Sep 17 00:00:00 2001 From: shuiyu1123 Date: Wed, 24 Jun 2026 11:16:16 +0000 Subject: [PATCH] =?UTF-8?q?feat:=20Android-pyApi=20v1.0=20-=20=E5=85=A8?= =?UTF-8?q?=E9=9D=A2=E7=BF=BB=E8=AF=91=20Android=20SDK=20API=20=E4=B8=BA?= =?UTF-8?q?=20Python?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 52 个模块覆盖 Android + Java + org.json 标准库 --- android_pyapi/__init__.py | 258 + .../__pycache__/__init__.cpython-310.pyc | Bin 0 -> 8740 bytes .../__pycache__/_core.cpython-310.pyc | Bin 0 -> 5865 bytes android_pyapi/_core.py | 186 + android_pyapi/android/__init__.py | 0 .../__pycache__/__init__.cpython-310.pyc | Bin 0 -> 158 bytes .../android/__pycache__/app.cpython-310.pyc | Bin 0 -> 79315 bytes .../__pycache__/bluetooth.cpython-310.pyc | Bin 0 -> 30307 bytes .../__pycache__/bluetooth_le.cpython-310.pyc | Bin 0 -> 18796 bytes .../__pycache__/content.cpython-310.pyc | Bin 0 -> 66728 bytes .../__pycache__/content_pm.cpython-310.pyc | Bin 0 -> 29847 bytes .../__pycache__/database.cpython-310.pyc | Bin 0 -> 41465 bytes .../database_sqlite.cpython-310.pyc | Bin 0 -> 31722 bytes .../__pycache__/graphics.cpython-310.pyc | Bin 0 -> 97139 bytes .../graphics_drawable.cpython-310.pyc | Bin 0 -> 44545 bytes .../__pycache__/graphics_pdf.cpython-310.pyc | Bin 0 -> 11360 bytes .../__pycache__/hardware.cpython-310.pyc | Bin 0 -> 18247 bytes .../hardware_biometrics.cpython-310.pyc | Bin 0 -> 10981 bytes .../hardware_camera2.cpython-310.pyc | Bin 0 -> 28474 bytes .../__pycache__/inputmethod.cpython-310.pyc | Bin 0 -> 32155 bytes .../__pycache__/location.cpython-310.pyc | Bin 0 -> 40345 bytes .../android/__pycache__/media.cpython-310.pyc | Bin 0 -> 73367 bytes .../android/__pycache__/net.cpython-310.pyc | Bin 0 -> 54438 bytes .../__pycache__/net_wifi.cpython-310.pyc | Bin 0 -> 37517 bytes .../android/__pycache__/nfc.cpython-310.pyc | Bin 0 -> 14885 bytes .../android/__pycache__/os.cpython-310.pyc | Bin 0 -> 61593 bytes .../__pycache__/preference.cpython-310.pyc | Bin 0 -> 24587 bytes .../__pycache__/provider.cpython-310.pyc | Bin 0 -> 19798 bytes .../__pycache__/speech_tts.cpython-310.pyc | Bin 0 -> 15010 bytes .../__pycache__/telephony.cpython-310.pyc | Bin 0 -> 33335 bytes .../android/__pycache__/text.cpython-310.pyc | Bin 0 -> 41815 bytes .../android/__pycache__/util.cpython-310.pyc | Bin 0 -> 35298 bytes .../android/__pycache__/view.cpython-310.pyc | Bin 0 -> 150712 bytes .../view_accessibility.cpython-310.pyc | Bin 0 -> 61829 bytes .../view_animation.cpython-310.pyc | Bin 0 -> 32588 bytes .../view_inputmethod.cpython-310.pyc | Bin 0 -> 33993 bytes .../__pycache__/webkit.cpython-310.pyc | Bin 0 -> 41455 bytes .../__pycache__/widget.cpython-310.pyc | Bin 0 -> 204200 bytes android_pyapi/android/app.py | 2001 +++++++ android_pyapi/android/bluetooth.py | 791 +++ android_pyapi/android/bluetooth_le.py | 512 ++ android_pyapi/android/content.py | 1671 ++++++ android_pyapi/android/content_pm.py | 801 +++ android_pyapi/android/database.py | 1076 ++++ android_pyapi/android/database_sqlite.py | 965 ++++ android_pyapi/android/graphics.py | 2792 ++++++++++ android_pyapi/android/graphics_drawable.py | 1128 ++++ android_pyapi/android/graphics_pdf.py | 335 ++ android_pyapi/android/hardware.py | 533 ++ android_pyapi/android/hardware_biometrics.py | 291 + android_pyapi/android/hardware_camera2.py | 761 +++ android_pyapi/android/inputmethod.py | 804 +++ android_pyapi/android/location.py | 1055 ++++ android_pyapi/android/media.py | 2049 +++++++ android_pyapi/android/net.py | 1397 +++++ android_pyapi/android/net_wifi.py | 1020 ++++ android_pyapi/android/nfc.py | 390 ++ android_pyapi/android/os.py | 1660 ++++++ android_pyapi/android/preference.py | 654 +++ android_pyapi/android/provider.py | 550 ++ android_pyapi/android/speech_tts.py | 401 ++ android_pyapi/android/telephony.py | 676 +++ android_pyapi/android/text.py | 1106 ++++ android_pyapi/android/util.py | 1055 ++++ android_pyapi/android/view.py | 3801 +++++++++++++ android_pyapi/android/view_accessibility.py | 1488 +++++ android_pyapi/android/view_animation.py | 935 ++++ android_pyapi/android/view_inputmethod.py | 859 +++ android_pyapi/android/webkit.py | 992 ++++ android_pyapi/android/widget.py | 4777 +++++++++++++++++ android_pyapi/java/__init__.py | 0 .../java/__pycache__/__init__.cpython-310.pyc | Bin 0 -> 155 bytes .../java/__pycache__/crypto.cpython-310.pyc | Bin 0 -> 22496 bytes .../java/__pycache__/io.cpython-310.pyc | Bin 0 -> 59302 bytes .../java/__pycache__/lang.cpython-310.pyc | Bin 0 -> 52365 bytes .../java/__pycache__/math.cpython-310.pyc | Bin 0 -> 21044 bytes .../java/__pycache__/net.cpython-310.pyc | Bin 0 -> 55432 bytes .../java/__pycache__/nio.cpython-310.pyc | Bin 0 -> 15790 bytes .../java/__pycache__/nio_file.cpython-310.pyc | Bin 0 -> 26930 bytes .../java/__pycache__/security.cpython-310.pyc | Bin 0 -> 42901 bytes .../java/__pycache__/text.cpython-310.pyc | Bin 0 -> 43574 bytes .../java/__pycache__/time.cpython-310.pyc | Bin 0 -> 56017 bytes .../java/__pycache__/util.cpython-310.pyc | Bin 0 -> 125169 bytes .../util_concurrent.cpython-310.pyc | Bin 0 -> 74607 bytes .../__pycache__/util_regex.cpython-310.pyc | Bin 0 -> 10046 bytes .../java/__pycache__/util_zip.cpython-310.pyc | Bin 0 -> 22263 bytes android_pyapi/java/crypto.py | 628 +++ android_pyapi/java/io.py | 1933 +++++++ android_pyapi/java/lang.py | 1452 +++++ android_pyapi/java/math.py | 683 +++ android_pyapi/java/net.py | 1582 ++++++ android_pyapi/java/nio.py | 622 +++ android_pyapi/java/nio_file.py | 703 +++ android_pyapi/java/security.py | 1145 ++++ android_pyapi/java/text.py | 1041 ++++ android_pyapi/java/time.py | 1619 ++++++ android_pyapi/java/util.py | 3693 +++++++++++++ android_pyapi/java/util_concurrent.py | 2037 +++++++ android_pyapi/java/util_regex.py | 287 + android_pyapi/java/util_zip.py | 697 +++ android_pyapi/org/__init__.py | 0 .../org/__pycache__/__init__.cpython-310.pyc | Bin 0 -> 154 bytes .../org/__pycache__/json.cpython-310.pyc | Bin 0 -> 24789 bytes android_pyapi/org/json.py | 858 +++ 104 files changed, 58750 insertions(+) create mode 100644 android_pyapi/__init__.py create mode 100644 android_pyapi/__pycache__/__init__.cpython-310.pyc create mode 100644 android_pyapi/__pycache__/_core.cpython-310.pyc create mode 100644 android_pyapi/_core.py create mode 100644 android_pyapi/android/__init__.py create mode 100644 android_pyapi/android/__pycache__/__init__.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/app.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/bluetooth.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/bluetooth_le.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/content.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/content_pm.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/database.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/database_sqlite.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/graphics.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/graphics_drawable.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/graphics_pdf.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/hardware.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/hardware_biometrics.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/hardware_camera2.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/inputmethod.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/location.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/media.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/net.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/net_wifi.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/nfc.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/os.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/preference.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/provider.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/speech_tts.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/telephony.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/text.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/util.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/view.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/view_accessibility.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/view_animation.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/view_inputmethod.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/webkit.cpython-310.pyc create mode 100644 android_pyapi/android/__pycache__/widget.cpython-310.pyc create mode 100644 android_pyapi/android/app.py create mode 100644 android_pyapi/android/bluetooth.py create mode 100644 android_pyapi/android/bluetooth_le.py create mode 100644 android_pyapi/android/content.py create mode 100644 android_pyapi/android/content_pm.py create mode 100644 android_pyapi/android/database.py create mode 100644 android_pyapi/android/database_sqlite.py create mode 100644 android_pyapi/android/graphics.py create mode 100644 android_pyapi/android/graphics_drawable.py create mode 100644 android_pyapi/android/graphics_pdf.py create mode 100644 android_pyapi/android/hardware.py create mode 100644 android_pyapi/android/hardware_biometrics.py create mode 100644 android_pyapi/android/hardware_camera2.py create mode 100644 android_pyapi/android/inputmethod.py create mode 100644 android_pyapi/android/location.py create mode 100644 android_pyapi/android/media.py create mode 100644 android_pyapi/android/net.py create mode 100644 android_pyapi/android/net_wifi.py create mode 100644 android_pyapi/android/nfc.py create mode 100644 android_pyapi/android/os.py create mode 100644 android_pyapi/android/preference.py create mode 100644 android_pyapi/android/provider.py create mode 100644 android_pyapi/android/speech_tts.py create mode 100644 android_pyapi/android/telephony.py create mode 100644 android_pyapi/android/text.py create mode 100644 android_pyapi/android/util.py create mode 100644 android_pyapi/android/view.py create mode 100644 android_pyapi/android/view_accessibility.py create mode 100644 android_pyapi/android/view_animation.py create mode 100644 android_pyapi/android/view_inputmethod.py create mode 100644 android_pyapi/android/webkit.py create mode 100644 android_pyapi/android/widget.py create mode 100644 android_pyapi/java/__init__.py create mode 100644 android_pyapi/java/__pycache__/__init__.cpython-310.pyc create mode 100644 android_pyapi/java/__pycache__/crypto.cpython-310.pyc create mode 100644 android_pyapi/java/__pycache__/io.cpython-310.pyc create mode 100644 android_pyapi/java/__pycache__/lang.cpython-310.pyc create mode 100644 android_pyapi/java/__pycache__/math.cpython-310.pyc create mode 100644 android_pyapi/java/__pycache__/net.cpython-310.pyc create mode 100644 android_pyapi/java/__pycache__/nio.cpython-310.pyc create mode 100644 android_pyapi/java/__pycache__/nio_file.cpython-310.pyc create mode 100644 android_pyapi/java/__pycache__/security.cpython-310.pyc create mode 100644 android_pyapi/java/__pycache__/text.cpython-310.pyc create mode 100644 android_pyapi/java/__pycache__/time.cpython-310.pyc create mode 100644 android_pyapi/java/__pycache__/util.cpython-310.pyc create mode 100644 android_pyapi/java/__pycache__/util_concurrent.cpython-310.pyc create mode 100644 android_pyapi/java/__pycache__/util_regex.cpython-310.pyc create mode 100644 android_pyapi/java/__pycache__/util_zip.cpython-310.pyc create mode 100644 android_pyapi/java/crypto.py create mode 100644 android_pyapi/java/io.py create mode 100644 android_pyapi/java/lang.py create mode 100644 android_pyapi/java/math.py create mode 100644 android_pyapi/java/net.py create mode 100644 android_pyapi/java/nio.py create mode 100644 android_pyapi/java/nio_file.py create mode 100644 android_pyapi/java/security.py create mode 100644 android_pyapi/java/text.py create mode 100644 android_pyapi/java/time.py create mode 100644 android_pyapi/java/util.py create mode 100644 android_pyapi/java/util_concurrent.py create mode 100644 android_pyapi/java/util_regex.py create mode 100644 android_pyapi/java/util_zip.py create mode 100644 android_pyapi/org/__init__.py create mode 100644 android_pyapi/org/__pycache__/__init__.cpython-310.pyc create mode 100644 android_pyapi/org/__pycache__/json.cpython-310.pyc create mode 100644 android_pyapi/org/json.py diff --git a/android_pyapi/__init__.py b/android_pyapi/__init__.py new file mode 100644 index 0000000..7101a52 --- /dev/null +++ b/android_pyapi/__init__.py @@ -0,0 +1,258 @@ +""" +Android-pyApi — Android API 全面 Python 翻译 +============================================== +方法签名完全对齐 Android SDK，跨平台运行于 Windows/macOS/Linux。 + +用法: + from android_pyapi import Intent, Context, Uri, Bitmap, View + from android_pyapi.java.io import File, FileInputStream + from android_pyapi.java.util import ArrayList, HashMap + from android_pyapi.org.json import JSONObject, JSONArray + +设计原则: + 1. 方法名、参数名、返回类型完全对齐 Android SDK + 2. 能桌面实现的 → 真实实现 (基于 PIL/sqlite3/socket 等) + 3. 无法桌面实现的 → 返回合理默认值或抛出 AndroidOnlyError + 4. 所有常量值与 Android SDK 一致 +""" + +from ._core import ( + AndroidOnlyError, + Stub, + android_context, + get_context, + _sdcard_root, + _app_data_dir, + _package_name, +) + +# android.* 包 +from .android.app import * +from .android.content import * +from .android.content_pm import * +from .android.os import * +from .android.view import * +from .android.view_accessibility import * +from .android.view_animation import * +from .android.view_inputmethod import * +from .android.widget import * +from .android.graphics import * +from .android.graphics_drawable import * +from .android.graphics_pdf import * +from .android.net import * +from .android.net_wifi import * +from .android.media import * +from .android.hardware import * +from .android.hardware_camera2 import * +from .android.hardware_biometrics import * +from .android.location import * +from .android.database import * +from .android.database_sqlite import * +from .android.provider import * +from .android.telephony import * +from .android.bluetooth import * +from .android.bluetooth_le import * +from .android.text import * +from .android.util import * +from .android.preference import * +from .android.webkit import * +from .android.nfc import * +from .android.speech_tts import * +from .android.inputmethod import * + +# java.* 包 +from .java.io import * +from .java.net import * +from .java.util import * +from .java.util_regex import * +from .java.util_zip import * +from .java.util_concurrent import * +from .java.lang import * +from .java.math import * +from .java.text import * +from .java.time import * +from .java.nio import * +from .java.nio_file import * +from .java.security import * +from .java.crypto import * + +# org.* 包 +from .org.json import * + +# Base64 (标准 Android API) +import base64 as _base64 + +class Base64: + DEFAULT = 0 + NO_PADDING = 1 + NO_WRAP = 2 + CRLF = 4 + URL_SAFE = 8 + NO_CLOSE = 16 + + @staticmethod + def encodeToString(input_data, flags=0): + if isinstance(input_data, str): + input_data = input_data.encode('utf-8') + return _base64.b64encode(input_data).decode('ascii') + + @staticmethod + def decode(str_val, flags=0): + return _base64.b64decode(str_val) + + @staticmethod + def encode(input_data, flags=0): + if isinstance(input_data, str): + input_data = input_data.encode('utf-8') + return _base64.b64encode(input_data) + +# Scanner (java.util) +class Scanner: + def __init__(self, source): + if isinstance(source, str): + self._source = source + else: + self._source = str(source) + self._pos = 0 + + def next(self): + while self._pos < len(self._source) and self._source[self._pos].isspace(): + self._pos += 1 + start = self._pos + while self._pos < len(self._source) and not self._source[self._pos].isspace(): + self._pos += 1 + if start == self._pos: + raise Exception("NoSuchElementException") + return self._source[start:self._pos] + + def hasNext(self): + pos = self._pos + while pos < len(self._source) and self._source[pos].isspace(): + pos += 1 + return pos < len(self._source) + + def nextInt(self): + return int(self.next()) + + def close(self): + pass + +# Timer (java.util) +class Timer: + def __init__(self, name=None, daemon=False): + import threading + self._thread = None + self._tasks = [] + + def schedule(self, task, delay=None, period=None): + import threading + if delay is None: + self._run_once(task) + elif period is None: + self._run_delayed(task, delay) + else: + self._run_periodic(task, delay, period) + + def _run_once(self, task): + t = threading.Thread(target=task.run) + t.daemon = True + self._tasks.append(t) + t.start() + + def _run_delayed(self, task, delay_ms): + import threading + def _run(): + import time + time.sleep(delay_ms / 1000.0) + task.run() + t = threading.Thread(target=_run) + t.daemon = True + self._tasks.append(t) + t.start() + + def _run_periodic(self, task, delay_ms, period_ms): + import threading + def _run(): + import time + time.sleep(delay_ms / 1000.0) + while True: + task.run() + time.sleep(period_ms / 1000.0) + t = threading.Thread(target=_run) + t.daemon = True + self._tasks.append(t) + t.start() + + def cancel(self): + pass + + def purge(self): + return 0 + + +class TimerTask: + def __init__(self): + self._cancelled = False + + def run(self): + pass + + def cancel(self): + self._cancelled = True + + def scheduledExecutionTime(self): + return 0 + +__version__ = "1.0.0" +__all__ = [ + # android + "Intent", "Context", "Uri", "ContentValues", "ContentResolver", + "BroadcastReceiver", "IntentFilter", "SharedPreferences", + "PackageManager", "PackageInfo", "ActivityManager", + "Build", "Environment", "PowerManager", "BatteryManager", + "Bundle", "Handler", "Looper", "Message", + "View", "ViewGroup", "TextView", "EditText", "Button", + "ImageView", "ScrollView", "ListView", "Spinner", + "CheckBox", "Switch", "ProgressBar", "Toast", + "Bitmap", "BitmapFactory", "Canvas", "Color", "Paint", + "Rect", "RectF", "Matrix", "Typeface", + "PdfRenderer", "Drawable", "BitmapDrawable", + "ConnectivityManager", "NetworkInfo", "WifiManager", + "MediaPlayer", "AudioManager", "MediaRecorder", + "SensorManager", "CameraManager", "BiometricPrompt", + "LocationManager", "Location", "Geocoder", + "SQLiteDatabase", "SQLiteOpenHelper", "Cursor", + "Settings", "MediaStore", "ContactsContract", "CalendarContract", + "TelephonyManager", "SmsManager", + "BluetoothAdapter", "BluetoothDevice", + "TextUtils", "Html", "SpannableString", + "Log", "Base64", "TypedValue", + "AccessibilityNodeInfo", "AccessibilityService", + "Animation", "AlphaAnimation", "TranslateAnimation", + "InputMethodManager", + "WebView", + "TextToSpeech", + # java + "File", "FileInputStream", "FileOutputStream", + "BufferedReader", "BufferedWriter", + "InputStreamReader", "OutputStreamWriter", + "URL", "HttpURLConnection", "Socket", "ServerSocket", + "ArrayList", "HashMap", "HashSet", "LinkedList", + "Collections", "Arrays", "Calendar", "Date", "Random", + "UUID", "Scanner", "Timer", "TimerTask", + "Pattern", "Matcher", + "ZipFile", "GZIPInputStream", "GZIPOutputStream", + "ExecutorService", "Executors", "Future", "Callable", + "String", "StringBuilder", "StringBuffer", + "Integer", "Math", "System", "Thread", + "BigInteger", "BigDecimal", + "SimpleDateFormat", "DecimalFormat", + "LocalDateTime", "LocalDate", "LocalTime", "Instant", "Duration", "Period", + "ChronoUnit", "ChronoField", "DayOfWeek", "Month", "ZoneId", "ZoneOffset", + "DateTimeFormatter", + "ByteBuffer", "Files", "Path", "Paths", + "MessageDigest", "SecureRandom", + "Cipher", "Mac", "KeyGenerator", + # org + "JSONObject", "JSONArray", "JSONException", +] diff --git a/android_pyapi/__pycache__/__init__.cpython-310.pyc b/android_pyapi/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d8d2749bb5da5c88d68d873e7cd3a879cb08a13a GIT binary patch literal 8740 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/__pycache__/_core.cpython-310.pyc b/android_pyapi/__pycache__/_core.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..61eda8f48613397d8a466f4778eef9d726d64a86 GIT binary patch literal 5865 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 E0PU;V?*IS* literal 0 HcmV?d00001 diff --git a/android_pyapi/_core.py b/android_pyapi/_core.py new file mode 100644 index 0000000..d8b2990 --- /dev/null +++ b/android_pyapi/_core.py @@ -0,0 +1,186 @@ +""" +Android-pyApi 核心基础设施 +""" + +import os +import sys +import platform +import tempfile +import json +import hashlib +import random +import time +from typing import Any, Dict, List, Optional, Callable + + +class AndroidOnlyError(Exception): + """当调用仅 Android 可用的 API 时抛出""" + pass + + +class Stub: + """ + 通用 Android API 存根基类。 + 子类可以覆盖具体方法实现真实逻辑； + 未覆盖的方法调用会返回合理默认值。 + """ + + _android_only = False + + def __init__(self, *args, **kwargs): + pass + + def __getattr__(self, name: str): + if name.startswith("_"): + raise AttributeError(name) + + def _stub_method(*args, **kwargs): + if self._android_only: + raise AndroidOnlyError( + f"{self.__class__.__name__}.{name}() 仅在 Android 设备上可用" + ) + return None + + return _stub_method + + def toString(self) -> str: + return f"{self.__class__.__name__}@{hex(id(self))}" + + def equals(self, other) -> bool: + return self is other + + def hashCode(self) -> int: + return hash(self) & 0x7FFFFFFF + + def getClass(self) -> type: + return self.__class__ + + +# ═══════════════════════════════════════════════════════════════ +# 全局路径和环境 +# ═══════════════════════════════════════════════════════════════ + +_package_name = "com.ai.assistance.operit" +_sdcard_root = os.path.join(os.path.expanduser("~"), "Android-compat", "sdcard") +_app_data_dir = os.path.join(os.path.expanduser("~"), "Android-compat", "app-data") + + +def _ensure_dirs(): + dirs = [ + _sdcard_root, + os.path.join(_sdcard_root, "Download"), + os.path.join(_sdcard_root, "DCIM"), + os.path.join(_sdcard_root, "DCIM", "Screenshots"), + os.path.join(_sdcard_root, "Documents"), + os.path.join(_sdcard_root, "Music"), + os.path.join(_sdcard_root, "Movies"), + os.path.join(_sdcard_root, "Pictures"), + os.path.join(_sdcard_root, "Android", "data"), + os.path.join(_sdcard_root, "Android", "data", _package_name, "files"), + os.path.join(_sdcard_root, "Android", "data", _package_name, "cache"), + _app_data_dir, + os.path.join(_app_data_dir, "files"), + os.path.join(_app_data_dir, "cache"), + os.path.join(_app_data_dir, "shared_prefs"), + ] + for d in dirs: + os.makedirs(d, exist_ok=True) + + +_ensure_dirs() + + +def resolve_android_path(path: str) -> str: + """将 Android 路径解析为桌面路径""" + if path.startswith("/sdcard"): + return os.path.join(_sdcard_root, path[7:].lstrip("/")) + if path.startswith("/data/data/"): + return os.path.join(_app_data_dir, path[11:].lstrip("/")) + if path.startswith("content://"): + # 简单解析 content URI + from urllib.parse import urlparse + parsed = urlparse(path) + return parsed.path or path + if path.startswith("file://"): + from urllib.parse import unquote + return unquote(path[7:]) + return path + + +def to_android_path(desktop_path: str) -> str: + """将桌面路径映射回 Android 路径""" + if desktop_path.startswith(_sdcard_root): + rel = os.path.relpath(desktop_path, _sdcard_root) + return f"/sdcard/{rel}" + if desktop_path.startswith(_app_data_dir): + rel = os.path.relpath(desktop_path, _app_data_dir) + return f"/data/data/{_package_name}/{rel}" + return desktop_path + + +# ═══════════════════════════════════════════════════════════════ +# 全局 Context 单例 +# ═══════════════════════════════════════════════════════════════ + +class _GlobalContext: + """全局应用上下文占位符，在 android.content 模块中被替换为真实 Context""" + + @property + def packageName(self): + return _package_name + + def getPackageName(self): + return _package_name + + def getFilesDir(self): + return os.path.join(_app_data_dir, "files") + + def getCacheDir(self): + return os.path.join(_app_data_dir, "cache") + + def getExternalFilesDir(self, type_=None): + base = os.path.join(_sdcard_root, "Android", "data", _package_name, "files") + if type_: + base = os.path.join(base, type_) + os.makedirs(base, exist_ok=True) + return base + + def getExternalStorageDirectory(self): + return _sdcard_root + + def getSystemService(self, name): + return None # 由具体模块填充 + + +android_context = _GlobalContext() + + +def get_context(): + """获取全局 Android Context""" + return android_context + + +# ═══════════════════════════════════════════════════════════════ +# 可选依赖检测 +# ═══════════════════════════════════════════════════════════════ + +def _check_optional(name: str) -> bool: + """检查可选依赖是否可用""" + try: + __import__(name) + return True + except ImportError: + return False + + +HAS_PIL = _check_optional("PIL") +HAS_REQUESTS = _check_optional("requests") +HAS_HTTPX = _check_optional("httpx") +HAS_PYAUTOGUI = _check_optional("pyautogui") +HAS_SCREENINFO = _check_optional("screeninfo") +HAS_PSUTIL = _check_optional("psutil") +HAS_PYMUPDF = _check_optional("fitz") +HAS_PDF2IMAGE = _check_optional("pdf2image") +HAS_CRYPTOGRAPHY = _check_optional("cryptography") +HAS_PYPERCLIP = _check_optional("pyperclip") +HAS_JPYPE = _check_optional("jpype") diff --git a/android_pyapi/android/__init__.py b/android_pyapi/android/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/android_pyapi/android/__pycache__/__init__.cpython-310.pyc b/android_pyapi/android/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a68c8d9b382be25563d608ba7ea65f3627575b8 GIT binary patch literal 158 zcmd1j<>g`k0;8qYSs?l`h(HF6K#l_t7qb9~6oz01O-8?!3`HPe1o6vJKP9mwQNOe} zwMf4_zbISZF)yVkKQl$Qpwh7*Q(sR%5yFozs7wU%p*;Qg_{_Y_lK6PNg34PQHo5sJ Qr8%i~Aftb%7 literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/app.cpython-310.pyc b/android_pyapi/android/__pycache__/app.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6a63f0a133c993ba563c4bdeabb7ce45843c84cf GIT binary patch literal 79315 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/bluetooth.cpython-310.pyc b/android_pyapi/android/__pycache__/bluetooth.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fa39f0d430d6bc036b2fb1a0cff9c4715bde7a80 GIT binary patch literal 30307 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/bluetooth_le.cpython-310.pyc b/android_pyapi/android/__pycache__/bluetooth_le.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5a808d519a1dcb15ca39d0f2780b195243b80a52 GIT binary patch literal 18796 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 a>%YDKmi|rsTLxd$uk|17=cVyqA^X3k^j1Fr literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/content.cpython-310.pyc b/android_pyapi/android/__pycache__/content.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..926dfb8813be54a87ae1536cf16478809acff4bc GIT binary patch literal 66728 zcmb@v34C2gbwB=gJw2_KWZ9NCd5L3Xv9m!!R?D)Sh}e>`-9Tjwa=QYBVMP)1ztmpBc^Ie|j=Il^e}X)s5Col^rdmf^rH_LlB-dl`TytkU&_qj}}RRmK(O>p+RC&2IDRL(7WS+?tp!WD@4J4=0bVOeXkuTVgtSByk{Nyyo%b z=ygVFIMMUk*}Kr53cb^YDwmAzzVdX%oUU{~|LncbJ^PjJf4Jv^I_U1oMQ+?)(<)Ei zWvYw1_o>oF-NOgRlxgfy=6+L|(-WrE{rnT}E}Z`GGpB$3L(f0)%~KCQcg;sy^ieyrqcl;mGrLMw#m*1SR7&OPu}M2UY*y^- z$n4CdX=nFMBd{lD=V#UA%$TxFy8z$pwD#A-4-CqNY3C)Rc&BA&@0=}HOuKG&T0AeJ z-z0kSc4oLTJ8ri+*bGfi9_?4Etn8LCO^D(I32}GD?ohh8MK@w*ta8w9sg#2OjYZ3t z7*j@3mCF^osW>(>Q#8gZV@0E+@H#U#ad_;2S)3l5GACGS|F7M7v2sApOrSF-*pWxm z^{IM1#?3~?%otfbIXrcE@_6d;6wIvAfd7qVW`EoLiTz3GP)(ybv(9Kic&m}vpOH?K zIi4KNBa}Ju3+BMsymTqX)+2VQkuW-)n4Gc9Sbi^K3W!<3P(aB@H)3c*Ae5bnp^e5a zW3ADBZ)UU!>6^{Wip2huvCdeJ5Oi)YWP`C0A+5fU^NdXhS>g*h-`I?hHeX1OaREZw zeIXYb7a^nrAz8q=*w})%rFcUr1oBqn5`--CeQ~LA8A6u(LM}J1K*$P&bRmz|7_Y_K zO6ToL<0`zZa^7BNT#dKYzHhHFu0_ZiW4CdgaXox%5tl(OHyGRS)@}3}+wV<`t~2_K z9r(ZA=r?xa{|4hm<0kyyh;BV#ydK^9_2zjP1~%QF$RtM3N4Ffb)978Z=b>r1JqGX6 zAD@5r6VE+;&kJ9^_w?5uKD}`N3s1fC`7eChPP}*)KRahl95km)yMAo8aO}PGgDR-J8fArcKxhns$yw+e|bVCA*WT+&rXxZV~xP6 zB#tK*k|!{n%qQm)#ngNXZhAfqH#47so1M?X&CTcF*3H+!&CloI*3Z|&EmRuj^T+vR zqmh8yWF&?YCzFFc&34wBoiUZ2F9M5FrC7A%C2b>Bhe>{0CIiEa~oXH!>V=4GjGfhV7Sh|viKZ7TWCx@pFPad_* z@cNmxWGNoZqm5<;)e7XLy5RKW7eh8utf!#r@z2h)t~efQin6qlg`Jx=E0g7k5b-hQ zgQiU1lTlYOgPe@0@aFBq=86(;!89uqUkvAT5KfWuzyiq)?aQ1vpEq@?z~Y zs!ZcrMYw*yDo^bhQx)qPd}HO{G^cVvcdm&Dda-tXe9SV7$iZ%8Unp9p^yvxqQ}@S$ zkkEoWVaz8Eq2C(G6L^-P7|RmJQWf;wL+H7vZ~D-0QR4~Jc;ZmrNIh65MYEGzd+Id) z=j;_d^{NMO&;r?^W_0P#M~K=?=K?yc4RsNni{XH1z4UK~W9O&MBht0QWNAH8svPW{ znK7pgFd8T?zp*;tbfk23Rx364-*X+LRrnJ-X$5)&dk3pmsM81!tCsB4gJg=*gL9o% zZ@po|n{MB>ZsVr&H}_m{;YHV6ck!0uTYHiiB*yleJxSGsuTCb_jrbSFIH%c=K}4Nl zoiwKA3dBkWM-X8WB65c8z3!UB3AGU~0Mm?rYJg6tdFKq1yv|-kS~|~&7)7ce{R$FQUyxFO5`K7Inm@^fWJ~COAd1yFjFQb7~BOXhcT6?nFG! z1T5uTE33vIwKyO47$cz2L^dLy(JE4oqTzY3*=6PiE2J#LEz1(H;af26^z4ZII z>>H5JPKPHs>_KR8DCEX00tmW_j4N?KNT8cI-FN_80x`5^=4UtpvrW0}Jt?D>ss&;X z*p55#iL|9$a?S<9@CXoZ^yzkhsAi5o_qyYB`b2UE=ICK8*JQ2@WWfHL#xsmZM#2O5 z?DiZdbcH_r%c(mtj8$7>Ps&bhxg>U|DqK5>1=mD*YUcV`X2zU55_9J}6~JaStY;T% z%e9!6$0n`o;c>rF?0e|mGVo`unaNTmmOL$}0e@Z1XC8?iX2&LS7ABHW!EN(yOazEaf-@ZII87W%vVG`@ zBBd^2PBH?=wa-Gy>K(_zeYRr0)dShg;#DIe5Z%F5-N8>dAz>^fKNDN5e90OT&id_4 zF%Czwscvx1>@CiF>}QRrLjj|vY5{33SvQqTHKryGme3gQMLKCm`Q%)iE{#9BCdfcV zZK(xpDJn`&5yLa)L}`C%g525tOfFTn!f77SG!ejVm`gU2S(N@1N)y0`BZoKq{HcSFk(f;?EYmpJ z!A+_Sa8u%@9|3E`w?`6>riD+)sP*V~P1#%1W-J_`! zNh}q?JE-dzZji6Y@hd01PVIEk*Eu11wO3M-^T_*BX4Ef9xCfW%jqF1GJo4gbAe2Ox z=*bPfl)U<-vuK|0h8C8#Wu``FtrD-s! zGKyefWz9}P7=?vGB{G!cE9GHXMm~i6EY79{tlS!tZE#zYse3YD-A`Q>qDNNul{C=^n;}Rl!n9k7gMg z<5g+es*FLRs236}sNFnRt_(~;7Dy3>X`FQU%4`|Tj|z|Oxnj}0vsnBB0dpoVpd!#c zgcH|M5gK@ix=RA~Pv0O5smYji@SH?vf@1MYfG6WpqqkPq5fg|A{D>KU);Hn!rGFyN zOBv~V^AO`_AnD7BG%sh=L9&#C1kVkjkUcY62f3ab(r7dxBoD#58$!W)X0+Z|;)S#s z?FcDAn4UG3I-xm=&k@>SEceo_FuD-Z2*J6Vm&p1c-&^NM`kF;*)q-xfUJarUG5~c8 z%WkUfnXyU*3-<`A-F9JJk58&HB@Q%2EU@8X69X=`FyLmz&52vbfv1=!%TuhEX+Q0k zL=+UIW@-~1>EXhjd!0J81cms<;|`>yU%~HQONT6iWb;*ctTs68uKqu)7i6{RtbaU# zj9x6i4qrsNg4dZji8~{fJN7HGb55JqSqL6gWL6^nxAC0e=q)3M%y}+&OI9-?x~d6R zy&IqE-hC^4&dN-SyF$>o*#9 z?5Q{{s)yl-+-__tGJ$qzqRLVeTowd<7&g9#4=iT53L=5lWFghe5u6)O)ut#jcknY2 z*Dj`3Zb#N`a}W`4usKLRe}^=>Rswz9lR7tOaWX_#Smm)bxi_;bEf?&Mm2yVU5_tNtdF)X>f5A z2O3E<25@~RC>Bhj5xBxY48B?%csz>%9s@12)clkd_vwDMgQ0iR5t(Oo+$ATZhujC~ z3)0ulj#K<|8Zoj4;Mlr8xjZ=+X#bK1V+Y4m$-bwRdjymPV~?OvEKZe;*-82vi`Wzx zn{;Bpq!{H1utA&fA@(>bDlEi&A9Ix6_#yhF1$>0QkMWBpN3cI(PEI11D(W&t$m}qL zbiaW|g!TDECfS&3YiP^pzs^isJ$z}!R1l7eu)L;25p^{Q8iy2@^Qn4--)~kQr~gqp zkJ0%Aodq~{x-?zUg=_@JR4GlM?;I=}iZiR)Mu$y6y`Ii)I&Yvu$+p@@=Z$nm>AacF zFVQK|8Kc7?P?poGMBgDgm(ZD{Gfk&V=T15n9kOcbt#sZ-=UzJRq|-`=)KDkr#8H&Z zhmU2zAw^S=@urfkFT*_>cv7jCQ>o^cQ>`7zRLiPlD!V+HYJ@-Cku0P^`Lz4jtbLj0 zH2>Ptg>-W^zbv1|Uv_y~cOC!>{Bq8l^#XdZpDQ!2H_|4!F%x^N`%^0t++`F_4Lh{= zHi75Lnc&b6hdoxKUU)8qU`McEGzh=NcgiQwLwc670$>ZWa%w3@@~@IseL=t^T1a_DqI+kxw9V+}%< z0sG}9@k}}V-wI!d-s$Z^NE71qF7Habwc}0i@UAkrubaRwDzHGP-qT%!9aAbqa0gYV zraA<7P<2jJhR9$awNbvIDntgmsXB)%jMw08gJ7yD|61cpglzQTewFb$gq-K(cC~R0 z-ZmN68rK1n^M!xijNxsY-Q*}h+`@U*nq@l=gy+|2UIVFLMWBjdUjGB(!p0Pmt1yEEN>gQ6AL7>!!wK*fX$0`$n17}jj_eYF zZM{~+ZGsurpr1y}Nxe$0&hx(B&7smx&&*bS!hA@AW(@H`Ob{EHJYCSTEx^s-5MZaWPbk@^Aw z1c9rk5cV>|?}rmEE;DBg?I0z`23jDQTC+`ZO zWK;0iYiT(J_&&XkXiRn_=T-#i;!77nvmOwoL0lV$CRk6RH<#7O-U@#P3;PO`B95+h zwUC(Nh_lqs`ik&4a&K zge$G!CsJqUx?&3Fd=x01+c~9l1u5METHFaw$eL7NB^EKYZPyFQc9o|OGy@MU9$Xd! zmni~3S@SMQ6?qBW-+g4Uv->B@V-@vfMt+4(94!ihz)q%ILJXcp!nx%!7)X);3jT7d zXFL>=>g)8!l~y;T9p%~aNwdo<(5oARWbbD4=+;^d$CoCsszLhTbfh;yC_eOLbSKl`^f4mK*qp(d z*@_il=4JAPZsBD_LZ*h$)aWLtiGlikprecX2lS252@Oy=AOIk*@qly$X{@6oAY9t2 z!!C%EDLW12M%|j@AZ0A<2VCV*v@HmSku{;n^y=;>8A(cFPhumD)K=fARkFI0)ju^; zIeLv(w9wS*#Gf0g?h4c;tIlaDU3b|DbiddQ5cORkb-f3-Jy=xvEYe!Jh+%6LF`nB2 zjl>D43P&KPXUa3NjTburQ{}tNUVs)ZrVZl1AaI>P9S5Wc3LN$X1+MhK@HMz-97@PO z20Bj!mE7zM^vO*14tx@6TVQT_Cnt9R8!LzS4E7c>XTuojMCV4vlgJY#aG{4%Yy$?S zJ+y#eks|b$G#XmWLdliD8vpo-tG_kzWbw}51Wnb`Vu@PcdtCo z7K<42Nt0r6m@sca7GW;Wm!>A$uRenheS`W*zJ^A*2JHK|z;5vh7~%$eX(FxBEu;E& z5Lg`R0U6JPGlvw5w|PYi&Bp#jkvjFjdBf{D#<^k<<8HC|W)D(moO9x91DW^Abd0{Z zmO)ubkpO1kiLTM~hMndMQ!=T6$y!4hs{>=1T3rwht%ijdx8#^ChFJdJWfZL z+ON^~EFIzczCqt5bbg!8@6!2SbbgNxd${^zI)6gvPwD(Q9S+UvFX{Xh9h=VI(h-@^ zKhpOcol|s9(-Aq*3Hqw7>I%MINr!{Z|HWfn4Ts{O?o=BDIi38=bk@V=Q)tUm*hBG7 z9uEXOndYn(_AskNd9!{D+6RO@DQvl=N3)(_CqJ62&ly)!u!D`ayjgD+ zDEfgCex5!k;#b2OoUlf-!DuoY_BR{NM$5ffY@zY%RUnm!cfnX*=@JQVn~*k_qpz!qM;*#O*{^nXCpf}S=9TD=Le5@K5rqlG=~60;iL zu5rq+7XNiB`42pJDuxR8*GSq8DC0(RDRQ82Ckt^A@xvJyoReulD9^x9WW=|W!4oi4 zy=NNI0F;ARNsE0}xS_@t3Dt`GU7=8|yuVUHF9)8?#i;^Q8P?(5)w4CRK&wTRqV-G{l^CB8eLa`0S_I>t1QO&AK zc|@jzwY)1qNLOV#5M!6ep%R31HO?d^eL%W|bc9XFZVC|3WZ)4MaCdFz;_V4@2GtEn zV;5#r`H(rmb2N566x$tdv*#_2sRNc>u%Mk*EGwvq+U*nEZ=alm47ogAv`PnX0!Pb6 z>X4)Rqo0FJAD%Om)mE@^!0m+jq@Eguo#6zTnd_8|nQo5QJXQph?kWM&-0C-lD13Xj zY;#@RJ*!IB*~!A7F!Dz&oM@=v17&BA;535?MdZr?QA((ONZ&ux`4>7rqVunGsw0We zZVkfj1nn%+t|J4s#2v#u+6izwr$uU!$L z7^R?2Ap76kb%SOZ+rIUSHvv)8L=)H?Z35WYoIJXHtTJ)%>TYl6{JLsm0EaD&dKEBK zFVhK9S$3tJ9Nx*I{5Ol@ay(vRsDi1D{YHEl+kjK5)fJ@}(sc*t)<;V+K0A4MAkv`O zaKM+JA?E)<=RfKEZ#w@)CtR9pF7Lsox>rJ07cEgWp`FuvT6P+PmYu`NJT+!T+C34G zQHc%A8)pSR_Nc1^2W6iMOTUCl(+T01fnMR{`xx<2WaBMiJUTOar=54lYrDldIz3Uu zi9j4&;hCR6Qzxh7iubHRyl}CFqc?I?>JUU&Y6E0I7(nN7VC{HvN82jsC|ESLEmyuj%v^?ZRZ4j_F%Nj3rHuE#| zdslkok;(t5-KpP-`^&0mnAQZ8?Z&1nR)AC-5jbnI1}(ClAyQ$FggQSY)wRxl=rG_A zj=Ox;9CEr!4Xy6sulW|1TMCbZ&ykv6rpyB%pQ)V5X~>z9KgN>hfe}kypuGJ2(Db#X z#+QMm4hzSYDFwVq7f_~7E_6}zT|9;*1;oZ8TE=qMkG*+m3+}tMPW!G)+*#)}bM(M^ zmWj+;Qmb(C-;TO^&U9q~?(wr2wJFD+;xQxEZ5}1w%5=4YmAo`TL zjX4|{_Odz%rj1Srk5yw6cg~iS=@dQ)<8%CA26@h16eiBOKC6kETFMNCKAp7?+UVrG zk7|;T!^a}_gooG_H4r=J=XUE<30f8v(7(99G>M)OnOXoKwo08jO{#PSu?W$VB5CYI znPXF|UF(ZXBGtPljA$@ngl07mh^@pH%<$6#(-4Yj(7*0MT^oiPO8Kh5wlcG!*@_4E zD<0hNsroJ9q|ypbCU^F9$F275&cUIPft|M%hi@C~D~=2m2m42E9ol=dz1|JKd0m>1@;q`rfE3m)c(~-xfURsyrE;rY#_`Rw z+|h$h2y{ORFL%|oWf+FNzO&6)*S99ymAN3Z9HN2dTxT6c1#2K2=t?W*Jb@?hd1%enLuaFaC4B?*U>mW3Z-NF!GnVHqJi!hPizPUv z-iBpzJ5Hl_U|GBri{MTyeV5^!`SQ^&V+Br_cj8?6GU!39!1?hm=sm22w!~iM#D(U0 zSl;uyjF^_lj$WiqN{n8tO-YPykp**NbgPrQUMyeYyy=DVrN-6fWq_>DxnGW)uQRVO zFGJ4P0|Nddcb;|6j=si8$rJAxn5KA)??#`-1F3cx{YZ7ClWM1NBT`*u+@y0c29S20 zlVi?!y>T;QUx!%2-ev5@+trfaprpG7i~S*E4??fSSJxrU8;repyWU&|8wkVZdB%u& z1N4*kA>A#;t$@4Dc%yL}Xwz$q8gIh??Z%sp+ws58_$8x=|2vF3j4}N0m#^0WZpIil zCXnY&f$QRyF$}{*=#5V3HAuJLIDn9wB;+9QD-pJN4QwkMG7ckVz(6Q)oHVBJ_IhJl z;#n_cV+J8N8+S^`4G2+&g^*oF#k>Ju%o=y$ZMSj6xEr_)B3FhUHRcdHA#Z<826egD>PBx2;JcNoVJGAtqY0{VS;-s#j;-nid*7h*?@cOy?J z4K&Yl#(RwSB6OdWEoD4lJczejoVWKG58>@rhkAtYu<^?Xc_ZSlU`qtv?>9bxklUCB zZyz*1gtt*&{D+NSLCBkYd3?n9C_>&WAyT9GGG~0ucm$!h<4flAapO_E{gMcDidcnz z!mg8{{O*bfa$M^PPM8+teC>nJfAF)<9xTca_Gm)I?C@M0t9evKax8If7G005fZp%65GPtJj%> zWf(_kEOF8*I*Xv(1kcTn*>&ThTz^#W)xCgGOyp6e#65|`iyY2hB-8q0E1hmS+vwZ_ zr?$vy3u3DxE3Qq7DXokoZbsDZvz6R&u;4`>_nEH>v(z%=A&T|tt`bNCO-f6w#1v;> zCdRUt;$({EvtfKenGxmj`8aLS>eRF+ z4$}fGr1gIE^C1(c?x3>~4wygU9Vei-$*k$$1^iHTo z#*M9siQ+b%AUl~?`C)TyujoJWtR+QUyZni)1 zfNIWP7to*Ll>ygJmy6@5z}cDFaN7ZQu)JMTx#at)2YaR4u3}Q50)<5mFo|F%5)_rP z+GYEqTJ8GeoRL0}<%&;r=ol#1p+UeX19h)c1{6wZ$%=X*IL~I+IU^ag>|tRVy!o8Go7NoSz)w^nvOiFX@qCGhSlJkd#8h5SdeG%2RWLiaWMykj_px zBWj4=H^6aMjIy^GYOwwyxNRs4G-Q{&vo`u}+6elT;Yck~2p>lOLrrV!&~iR2|@@{cWh{U9Q~`{qS>L*)Jl@N!Rr(Ok#&Q}KwkGjg)W@?cFHfy#iT zMVK0BDABort5K4%k51f>)ma5fA;GMg5Wq`4z*IYaXN9Bw)pWVnbu0; z${v%abnxt)H)e;@1!zm$8t_OjyB8ka%Ys`va?>WrP3w+AQ|MSa39B1Up4oYxONIuAmag6gS?aO$Thn*K5EcI)frUK! zWdI7)BV?A_Re20{-Yo3rNIlxQ{UQ~y^DY}Rx3XIE<8JD1Y+#ku)!nd?6cUnO2eR6o z#VKwMm=;)0HakbuBHQ$KeR+DX!y+~KDn+WooQn{#EytGb zWd0tkn}3c9sx~P9S9ZHwq9Qg$rb^&%%hM6z59c`6nP|sITM{{?CzAwERU*=kFi4O- zgn;k}*g=ekxCd!g5#J2N^*Etr%WU&8$pQ_Doy0{-9VVoW2vL*tiH1dJ=xt|?!#FZ? z_^4O67kY5LNiHUpBJq_0Cqfl>YfH>d`8B<0IqKtb!|(&rT}EO<7&CD-og$I9IS7=ir4CP`0H2Ai_p#?dbvg>0ao!Gm!o7*(>Ek?*nS!N-6*zi{|A*6Rg@IFcObO;^MC+8x z20jTE_#J>`ynNruDII;y+A`R-u&!GD3P7vAwoNYqlKouBx2(!@GzmbQl`pO zmVkwvo~mZ1)H{GK$|Af1{bAIX0GnV20|0-9J%yGq9IZt3v`D%D%E-A|`JrYXSM^lm zcbPhCHz4}Ab2T(C`c(naM?ateY3=c#_!;+Ji*W%E0rGdCU_tUzqg_T^w*qpz%GeiB zm`7!e_b$-FZbJEXLzUi%aw>pPp$bs%M%XYw$`V1&E_ic(Addiw0doHeP}DQ2G|M=0 z(^gI|6dfF?m@~ZG>QQ916T(`KrVGqUlvjBj>VrT821BqUqD#AV6t&0}{jn z+WC4ft`l)@MO1t?Gp9os3 z0nJe3fpFxg8`7iJp?$)Tbl=FpEdwLihwI;a%Rpa0^i*bM)O#7%)Vr&9?`}6jJ;1OI z*^wLQ>m3;w8uX$bl&o$U*uJ-S1Y31ZR=UemAH{CkGjwZzHR2&jziTLz%>@Wn4>PWL zxPNfCniFiULM(j*_PP~yIqZ(Up~1oa2vWn}!BGa;QrYu0F)bj)B2F`$mep`$ujX+TnfPdRGbd zJw(Xu9A5u06F2wu?(W~)TTSK`05U{Mz%Nt3!elMmdq+n4_g2Augy7_8%2OCidRq15 zB$F%aL@Gg%+=_HnB&1MG=pu!eLP~K2ZAEkhn3B9hvvVs3wc(@C9GM!14ku*Zqa1E; z0c@Uw$YE~&pL8MR*2{5xg1ysdJ zeLu%_QA5)wJb;NmI)VjY>xCj`eKNQT1EVuh#jVR4uu(GOzRU#y)0D>BV9 zl4A#g`b2(K+|z_yRxSNFwtIqwAJMv*ex~-Vrvp3#Jsya zlzgHuT7^CNJsvWjVOj3ON7cn{e8SlNO03oI5F~L_zf0%abV8k_UGf};1^X)G&wG$P zQC3W<09XWe$5~?$pTTxS$$-UlICWFlX~!D0rs{8aOm&n$1?4{^)&7XiAIH#di3xM8+$r$z z{xuI>eU=UAM$*s%`$Y9_4>mRT$N7iUWCh9*a&D_@8(i9KybQn~Dp^R`sB^_B-(dhJ z9XmZyxjS6Z9TU)+t6)b%;5xnI%Ybx-@;};8f>^~91;iyjckfkRg~twD%S+Y{lROSo zAS+N@Fd;t`rG~G0rC#=&gEe(9mewY-T@gI>@j4k_v`RZog-wkMs`BqdI#%qH8Rqs zvHJN+rChsiXjrUTxFd>irjjt!tqS^l0(WA66D4!hacSE^n-PU|3vcJHnlwUQuT{WFr2<3a~FIkQd$*F$89Z=>ab^uut_N>+<_rI$fTA_3SqT`!t zQ@R!})xw||!8AD0zZaq0$U1?|xZ`d`WL+~U)r#Ov8-EQ%`KE*ok$aoQ)cGU^J`o*b6M0b^8y>fSGCZa6rtLT49t#L<^dWVpKV-whk=GyGX{RcDjvI<{ zZ0{xY55%6`!BGU!C*U>5i0D8Y1yMXfp85e^xcXh(l>&)$JsfRWuUZ&2RewWGMVzjsIP_FesUhcEEfy#pit651f4 zy?gdRliO~Sm)-kzjSL{KA!2X0Zb#{hz5AdL-iN%9`w|J+(Z7A)jm3R~e6ial2$HBG z6vO*(+&i=nfjV99_Muz)i+#HW`mqhQLT9#X7sxp@w7a;wcMzrB%_yD4t-S+CjdBbD z!`tj;Nk6cA&(Pix@XhY`J6^wUc%*piz{pKSS6Zevp-ss8Q*9$vWNx{Uz5zNn)8QDW zM(DeR&Kv2-vHv&G_hve1CfE+5k6lBWplmy zy>#A5=YBeroU8ZHd6LdkbiPFA%XCDG|7-Mpoz6Gue2dO+()leqzenfy>HGnmKcVxd zbpD*qcjQIWD%)!090}I?0)j+WKFv+FSNyA{ zs`})s##D1&EFxub{q=k*k&WqbJ zT}Yvi;qwr_SY3oA%r(%z=V5%rjgh*^W%8DXfm&WfPFK>pWJ1;yK<|7G}%Xe4Rtp*Y@MExfr-%w^85yP^_O)l*ROL|k+M-U?rU4J5f;Hqg<%(j>>qh|(;7`R`#iZ=(|; zI3wzakmzD=h$0lxH>geZCxK7^D(B0S&YrXsBm|uC1p>bxU(V^%ciuopYMgslg9PX! z%m`qaqvP5aBbq#jt~@Nzx}4nrKNM!d%zqdg3w{s|Nr%!;_4iG>%gx>(nFxeT= zN<5_5g}b#+%3oCtt6BHz=LF!dZDDlEF<=?dPOwtjVS+D8OH2qJ>0iQCSuqe9(diX5 z+~A{XRXts??7T?Fgi-u&0$D&Ugthae z!?n<44{q#5Shs}Hesfj~_V6p7Go-;D{ zCs3E}Z-#Lu+H~IF!4zSA z;agwq*5Tc!9(d-(`yPDZGxwf)*GEej7-0B0(M@L?oqOmcaCHM%H#(UYe-0yfFaC_q zPvMkaf-|V**yPv=+#mhudGc6$;0g13a*8W0u5+SG{5f&!#KpC+;0o)Zzq$#sLfo_F znpu!3o%?q^4Zbs9M}Y&(@@w@!%Wl99JcTJ@@L-F!$aTo?xNYv%g+E zUNx48eJJV~+7R;e`fzhmki+qFIcX5zx&MN`>VP8H@r1|Kz)ocKawE~%xy}GCULmoU zs!4bbZl{qTobf;70(Pm>9EEQ;Ap1Ti+v|acYC@v9q!bzvgadHElJgFBZ8pTw0_bKW;bU7IS9ylZ)#{Y1 z*S+R*C(sgGAzhH|LC5v%-0HX@dg(QE3f$x}U!J@YdkcZ$vZ!ux14OU$&~*fnBDw2e zXt3c)#gn!aY2S>zYE-c`6-Dj!cDVi;UbJbBhNn*r|L;76(oG zQ*2j4R@Gi|n+Gr0l>&)suU`(kltkMXi%mk#nDq+}D$h>KK_=M8db0<0MWA*2)7V)k z*qC?MF6}?Ku+=iq+a0x5MXOTXg%(xxKnBN4tQB-E+j)1Us0mW9`@J&_ZWF2pNR(eR znAb$X+YM0Q-Q&zc;~pBp`t>D=P#f6mc6*0c;%)+6#RC3g8xyX#a7;^|vRej+AnP6J)AHJ(K?tMe z4eEydHx5DDu7CHQk=tC0d@>bF&tC~x`q1VE7IGt

0FNfv1Bgp598p<%m!OhYlu> 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/content_pm.cpython-310.pyc b/android_pyapi/android/__pycache__/content_pm.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1f22a492e583c073686bdff57694bce6abb723d4 GIT binary patch literal 29847 zcmb__3vis*b>2SyT`U%h_k$!zQ4mE+gdU*er(Tw{1Qz64zyihslDU4Ym$*N`C4pV& z{tHTkK}$BN*l{dbwq?f;$tL|stfaP+bf!(LNjja$OeSeMlS$gN`I~8HQd1O@Y14#m z(=bik?>qlv-z4K?F?;ae_qq3;d(OG%p8IdPyE`7h=P!Tx;giNk1A+g}K+yqU#;Gj`dhBw%(cR3tt&ZXg&iLnj9>44M5ZdNGt6MrgzwRvjw# zV#rS$HV3{IP@S)ZkYk66n^AM88CePK3ao@wmr9&Ba=VTMRJZCmA5cAJ*STeNBB0i58-_h-jDF@YCppJC468tpbmU9 zn7c!TvVrkCHqT)6QH4xlk#VON(a|FUi$uLF1_&GOF#IHE5G^j znAcWz>WTOjG#HnJ2tn$>I!RiIBQm}gphAMW*gbc=5f2v ztzxdUb|$5DS=+q@rvv%ra;aiITd{|e4bh zRr}e2z$Cub4*@Dd;>CapR{~!MDnnqT5&+pnUkf1y1PR!w;(%S1;K|U1aK%uGi%jdT z7=S&h7qCzA^$Q#jI4E#P;IP0EsU75n{2(g8QT*+GHT0d}YQXzbd(-(Cst zRkyyHP-Cxlfmm+a97YG;dg)(Z`s|mkyz%9?zW?n@pLyX&|K{SGAOFF%$o&)dP26_{ zt2kgAGG1Nocx5C!3LB^F4o(E3><+V3IKF18MLV*xR#>&{NaciyMq_J*w3c;INQz-&t-M;cqsI%SlBw;k4P9O~9rWz*W>H<~zY~q_SeIpxML*2sa;12> zSUDq|35U__T10qjw@Y#p)wqdtW-+ypNiA;O*&;DHIho34 z^GJSbZsCc1b}_k_njTMF+u`Ls0SbMlpv{S8jGr!C8*WN?rnpkPHrf<@d~MULfU-|q z+trk|R(2NbwF6B_mRYjOdZMtrY_6HQylz%ZeeJe(*;dc!vb9{^Ft6=t%2FwBE}y{2 zn`Y^nKQ4ZE){D!!ym6vjGOrCa6)mkSx9Cv?7_r2et=qj4R(Yi&qq70-v8l~`v6Oco zTXcKVIzDltY*og)G?%5_b=sjbnOH9{Sym=^Na zDf|;~ZSoK){?I1cKJ-jkpE{IuxZb@RXObJmLlcMGA<1u?DIn~I4hc^zRq`9_6B}pj zU3sjpyfRk`n`?-3Ib0EJdk-42J_Zm9hl2bwf}x)nq0m3X!=b-7jL`oxBB8(QiH5Ej z9ihK9Vxj+QbcX)Mh==}<(G~jNMk4fMqdRof=n4I`(Hr_Jqc8NojQ-GHh6X~x=>G@} zJ2e7^@coBS#1BhLUdZ@y^uOw9pwPraqlo0k`ZRzUfPxU9asb6(P=!syj6hU(P*77; ze=@KF&Z;8kyK^xWB}X-*D+YNg1bC+#(}5UAq{nMwDB6u&S4|9syOB#s9U&3zMy~sl z0V9y>0Z$yVd*_`oOjpcxO25r&DSno{@V8)mU-zLKfL^_Z)9wPle$a+ z=Y9BW;2Xx*dKRD(I2X7Oych@uwu2k7V&H6WJ9t4$L)xrC`N z0g}%<%OS-gPXN3hUuys$9*hNhYW@a-TRR&jVZz5Ew6SjYxT&tLqX$t*(=2cXCfURo zz;@tdK=%L!H@f-E8Mp{_br(iTg|mUzjf@?fxbhQxWWdJ5PEXlCj09Aq%IhJWK}f%k zz+c#!-LX5@$^~Z}ml3o`1Y^OiU5%Zn=4vDv&I*yeO4{M{y&lXsjXZ^j#^z$IC=K4Q z!XiR)Er!g?)HE_)WBM5D&iM_rZE6M*x5#WC1ZbWc=@zp5lNyS%mct^{*ZihNTaBQT zX_>w7K71yZk@?<>2hQ=yAoQ{zoTJYet;6vAf&M*-4# z2_hO)D%8!T^Lo&k@rKEcRm$0lE|yly$Rl&Tx5emtnPhy&d-ZWP63^$?%W88C&De>2 z{^`xan$xJ=kJ0V6mT8t57b^KT@qnM%5?`}jP9fobj5pvjf zm$2RhCLm#VPnOp=pgxo;!g%+imAV*VyUr%2j^_$nX`(a(#W`r!M*tj_yNv}dOt-Vj zbV&p?j5g%5R)^7sl~KcJBiw0%B|D6^!wtoRwZ<~~0NR0SOU6L;LzCzhxvkhJYbXoT zb}zOe=5pmQRJbHnobgWmUgUA+a)wVrXRJq`B47<#NPnGAvjj4OGM6%q7@G0Kz3$^L$McA;TaKZep~AU{ zGICKB$$?OzH+4W$>d3`a4BAj9^q+XHTXp4nV65mid(A$x-yEpZx3DXPzBPz_Da;?p z(GN|`5YvZ|8$wJ!mM{$;Ms8S^@CayQr`=n#5tKzd2HYCr9PR0cuUvlRyUsEeg3=wx zd4)5N(Rn;@CGb3gfj}QY5CBt)gt5StF=WZyV9CdkyZw@PHLI3-7Kp~tv>e?k;^uXh zJakWC0FG{jF_loKt7$o*xP;;)idL`8Bru9h( zb0M|#OK3n1N@zerLvGGN31Ma=ZAh5Yj*Pwwqvq&+ck@Yj%uYV-BjCExV+6MnaO+_A zZfqWh87S**)%7im?JL19blRLL9@hnZhTHWRHk5@aD82e1%aVQQ-2`_K+zDX!9*0i7 zxshB2Yp=4#@!>}HCrAo@RYq7va*Xx)_~~s1iIYA{@G*ia2GTg0iL>zAvCgj|hsC^P zom4nI_SyK%FqO~-TCOrx(E%6OU`y4LBRt8}n^3TNsrO7(O&mX9InlFjZEU_FXA?st zOJcKEsl15hL(3GoIW?j1YZ1|Ww)z_CJ-C&)XUwEJ(gWe&Dy;Zm`WX9I&vg=cqV0cOT^J+Ha|Hxm9j@A zn4FoJdn!LUlS(e+m$Ipa{8Vx=Y4_Kp9ZpU@u{3WFOH}IpG~OgKOQ^|R^=j1ay}e`BGMVJK|O-CjccAyRKjLc|~; zIw2wAkPuyv5D7?#?p&|x$@Qt;T)*ne4XA!dg%D&wI5(^YawCv3JJeuqC*pS@eiZS$ z5x)oVx2U1qUNxM%RgL7vAc<~MJ97Kf&fM*4S8l%=%^gs?VYuFtyHo9l`TL+bZr)|y zT_=TT3h&O{qi!?rg1p(MZil?NSLDqEDEEM!@GN;EY`BnXBSg}85w7{WQRHZ9Pgi0D z)PyyTH3C;2CwLw}Z}BMriY{^wUxZLb5E+YsF@ndDg-iQN7(i2>zQQGUB}yO?t&>j_ z=U2K25(M1@RM>7L$H<=A%Q39tI@Ps7c6rLHBfFpth(vH?SJVwTvI~m2q&c#y(+xSY z3mSu@Ig+c(4RwoLNo4H!T4A%ad}5X+wtmMnIH!x?^KyJ(cXLNtT%9~oD6N`uDum4m zO?>In#%6`3MC{lD8_qLYNQ|TNTBHHxg5BfrBQMK%PlNQZduNhMnaQJhXW`DI z^fy>+Z+3DamCEGj7SgE67;wsMi+n*?J7-y-l^*578Zodo$2 z5-oC9NBORmA0jb^J%mMr^=uZ+IykAwZo;8yoNW7XmIxiTAd z`LCGc698NF*wi!RLoFF{d~z-`oj#JEot(7&=gcIue8Yty#_o6HGs!2@M`Vip`f8@l9&)p}GdhzzHn+5B_qef3 z>HI8(f`^HlE1S-x?A>0;SqKX<@!CYM0$`F&FCMdZxS5^$^Hb@C)FjEqM{{y+W^O?m z)8E0M+Wju!Wz(4>GpRg;f<4d>mCQb2kJQJdGY}V<$&`I->-hXUMA;$=>R(_Zdt8)j z1|&a|%uHn`lk@0ci`4nKg~f$rdePp|B9Vg9-qj-EaO!9}Gu1LFivgNjXxUa~&P}|% zMU_rc4YvE*XY!HW-y+XK>dDkXHdRwotLD61epRhl!1U4#GytbVx3y?W6p8Bij;8Gjg|8R7!VhI%U$F3)q|H%?1%VT^8oGD17BgNDi77CCS`)Tp-^;d*4|#7 zcoL~MR4001V(&ELW|x_$6X~@3;7nh2nOzX+3Dpge-XkKt7b3ma?#eo6F(T3Tqota# z2y{1mJ$X*0>T&&9z#B=}!^qQK!n%7ZZ>Q);P{$(g?F=I#38NWjXF@LSNDfLbdw8X+ z%~f6AEGZZ3#WNe`c(g%uIb}uQ{2nW4Cu`u?;Ft!y-3oRjLp8%w-Hpf|gvfXwK2t}T z#P=#ykLqUNH5j{L*4awb)O65M`GbzhyPaHtvxcMX!&Fm;N4;R_YbjU;eHA+YRC@8K zusT;oPiN<5aB4c0_tfu3%{{g7WEz~a&#A&;yRy!l9RnWo$@%&G-26|wx_%cU^tbrR zVMP7v!usgYOmDwFNK|#}qw|LL(J0n}Yaf-h5XYRv?Zmu$1SyN*UQ}BfA**4ME)u1R z7hkt3ZbbZ4Zf~0S>yM+HkYgqF?4sUrRIQaXraEiXPHZkDAa;g!>u`wcZ~)o7b?6;cVLc9eGx1aDd$omS6Yh^s zy}BpJw_BFC0zFsVtF3RMepPn0T9rTTdf^7MpQFN!lw-IY>C%jCze;Gpsaqwj%$8vu z@M2TiflX-)o6;e8adn$LG+EY36(0R|V}ptVU)75oy<)C}!3@%605QE-Uoe;Mt^Qntm+FYv7)-h7qh^j50Ru7USbY>=VGSX(;NK<8aI6_@^jn57kV^R5EiUwJ^7o zt&7d3k7SaIOA9G`Z%tl57Mowsq&8TS?zk}}XIwctIhS3`Vq23*9kX|eWIc*a+f&Jf zRGy}-h4dsuvb{@E(zCNmi!jL@t4(r@WU{ZpF6%m)Ehp>-)~`Q7mODvNd+<;%fIT}H z1aSly$SA~kgA=Ge1ZxlXq&aouUOw1TqhT~BJ z7DTsEaTGOjabY0zpzE`{;C@EOMByF>&{j=YSjStx_^mg;{_>mWKYQtGzjgVm=P$qU zg*U(cYLl5Zgpy&RdmO-F4RjAtIK#^0M3PP+0u6x?>Tda{zz%^insoD>@*I~uUGkhz zVZ?VU1F%Q(^a`tpWP~$JJDh@MtMR@nJFpW4*FTQkvb(IRLJqgd8jZw`t`yhcO=ib7 zbWxyCLt45U-Q*g3|20#8qnPIy)t4@TSm#i63sOwLU+B2LRBzScVcz<&ce zL3mO;c07L(#Dw)u!uojnk?1T6!lmF%{BzW4ZlCmJf~N?iGu0lEVn4_p(P$V259QZ@ zVo{4dnVLB1G#z`RGHK2^;^kb)DB9s-siMWsrWnT!Xw6tut@@Xca1;$)4hOXx94-!JiJNSPizS3_b%Sqp+g+X)4L#g; zq2`*f@GajJ*ioT}kws2u^|N?l?}AqVLQON}bFxn%xrURGV}*n#!Lbd`E+<z(@KrzN52MHb`c$nZ3g7*+SO7Iwfy{nb?=d}1KCoK5FnraFBGOg_1YDiY9-M3QI77X83 zrLeZPSOlNzffsdUX#*aEri6{vqO$B^SAyngS`~YBa%pkS?kzec>7++h&hB??>+`~C z%@Vy=yIm*LBUA$|-^ZOyHQ$zfew5@$6Z`epr^8rd!d}TrYv`rQN(WI%6GiY8WD?)2 zAJc6Ac-uh1qmA%fkmo z!lXQ9?`fHggF|?iPuaU$rou+eLyIa0x<0qLijF+Zff&L=gBAtOGqOW7M-$JXNs=F{ z1W?Cw`f13h^T?$Jg&1Fh62Dzni-NbV+3E8i_~i;Wa(r?VZaK#vx9WjAV0UJVtMD>_ zFZJe5wC{(6FD2)nz|MDa>R43_>8fQ7KChfSIRg#)0X30_)TUL;kl#QTwRW) z#TRy)lM^Z~J>5xo0T;3^2I1%GcywKhY*tq8eSoyUV}7DzN5N5eJl6`Xu1fjvnTnaz zx^U(@MCubLxHVjhl%L)-Ej~)4C{%$9bR~E$r0F6P+Q#*mQ$R@pwbw(L>G7}~FIvL) zz}|F}O%XYFZtMu|LO{tB-AO#>x7`ua%^Hu=8c2z5nItSYKX&2Y--ydm3_{rxNV;@ z92aGUF?m5;lZln!qd$k7z$d(BmfE5t8qcqAB-puqb%g3MLHM*%IJyq0jZSSRkmT?i zT6^utaZJ3WyVsK3$(5aR$GJukUm^6zVa0!uX3o|6%GfYO4GAyy#ts zuH!{wRJ|TA5`Bkag@#net3Qi#X=`%~Rn9`*2In)VN)9>f;i}_KrrYbtQdc9n8$B(nv>#q0aPR?$N&DR^8 zPIB00?E!poxOSLtz#2V8LDScdsz7&b;e%Tp_c)3GA2+f6_cYTyY%mcK(x zxv7eS9T-0mt)L!1Z$;=~Vi0So8&ucB^+|mPs`z!b=vhRELL&*y*d`KZ$N91T+-M;2 zHYz?Wp>ep=bSYkB3F9oS6K*aO#F+#z+hd7rw+ydTDud({N& zu5WW=-j0|<>ORE0!;N_-V(wROL(IF}n0F)Q?dlzfc|g6>d{Dj1dO+WmpZc)WzJQp#`UqmOHF*l^IARuSVwROc%#y^IXvm$$A5fO`jxiOriI@+fuM6n?Y4r?3A7Z-*J*&3NZP!`Z>g|O39G=jCv8F6Y3=yf9Wq;_^f&vu|>BhpHrVl=%kAQ=jaRS z6~vsX!Rd?YONd#Mn4cFczpTE3n02>~ud1&hR8p^EW-z9R_1bz(eH|&~7AfCQ7m%{y zw(>B`q3w(6n}~fHHE>+NrM``j7O`wWEPqGyBxF+#T^#Z3-Bjllbyy%SfB)j;mw)Ec zSH4?w-coaE9O+09Y)Z59l8=NNcBK)VK#vTg?|?ool%h zIC(3tl$STHty{diss2@0Hw&&OTPLoQtZ_E053!ZzD!dE36RR6m3ncvHl3C&9Q2lnI z{SJcrTBGe=^F3a0ulR1=+Jv^7Wf|9OaD7|f-x@PF*IIG)M5P60ZZhn^&lcBtaQjXo z^)>>kXquUUO*3N$)}^Me<| zpWSsfSczP~q4&k$+0b_ALI->*gL-TmT{#)s4k=?-;E}*n0TnUeI(jY~43xU=hoR*e z+^ON;F?^Ytbz!CRT;ObY8wUH6u}b_A4A99gX* z`Xt^Vap}_+-ulho^lgN8P-|Yfz@?y=Y#VVCPSn=SqV7j&JNS$k52vwRi56kgFIDUW zZlz<3pD$R;#Uf50lE|kIGjmj4#9-N@`Ki=&5?(c+@sZ_b zHu)TOt}3!xyQ5H)H(@k%0gH)4BrnQf4|lRRY>j8Q&G^>kt-})K=p-#zUZuv%jXg2* zP6%E?oa5It#U}x>TOV{Wa8I0Yvlv&`QI*^x022Ee2hBmEHhWu4^aG>^_l)9q+hH)^ zVBnr|2?DnQ0sRmPZ{60i`P#fU*ZLo}Yu)X?cdRDO@AI2)-TS)CT6Sg>qRXTe@56mF zzl^iS(3S1rr(pRx9n|72z~}AYE^r)}Ujk>1?J(~@ld852+(2gtJVruJnsWo)$VWaE z0M7$QLcWge5bB9N4kNj20l=fq$D}OG_!mP{fpg5&DY@dvH7~hv56#U51HYfEOL8TU zYgux2`MDA`xw<7+4|1KBT-|=Io|;^}lB*B7K8X|Ej`IP*2}cEfYyA?_&lq4hux&sc z8OYSwmbucLGXWlb)X50aIY*XDRqoaBxZy(`XEDAPFs2uSp9?(=BbLxOY%339?7{a! z6ZhG{Le1thh2nPnku|(@h64G~`#ho_32fcpKy^4Db7OcSJMjp$gEi|>Jb0z$)S@k# zTHGVJ=x|u~upp!#!#_J{HDIKZh<+RC?=T+Z8002u)sI%|)CX8_8EsWpxzzd&zgC{B z+(fOw^%2ws3xtE~Myp!i<=4uCnx{QLkrEg8Bn! zL@a1SHAg|?gO0qp%96r%ckrotn)GhgMz(DC97!$alkg&cGQF5iWo5GL1S8>wO;^UO zjI`a&D7c%a(sXo|^Cu?`UK>xQrx?dx+P%zIJyXb5&!_PA5el#>Q?SFj@QfYWC_4R; zc@fg6^l}1j5^!=6acJv&y)*uM>>3s;Hyo$Z*2>8y7T{B@k(Bn+jeK1Z!>dp%z zFpMyvJI9_?impBh4a6Qc<)rsUsJ3|N zMXrY>f+`x-CnBVuL~07S=%<)XPGUz84;H|G!k>B39PJe?3czMmzk2Ai$L2*#1?cHGx!~n_~@VXcP;g4V;B%rzc5{r?>8&w1@TXXG+3$Jjwb=kTv)PN;D; z&58a1Gtt3Ce~4g`pkY!-=`}r>VT*a>YsGSE^3`c#T(JJ4oj_nUfL$7xjx0UwvcPh% zZ-N$WY#VwA`!{F;d_Ba|k!?zE(Hg@}Z!&1xjutks=TIJl75c&};w*R`!~f~js=O;i z&$j5!5W3?Y`{SKa?mqTO5?YTCnsY!E$F>1n_4ejTZ7SQgqq@N6Yf+zP#BqRHyfww7 zRseRW;0gwr0$~a}YtgM?s@8`&4=X6Ob?0@EtS!Oa9=+4+mIn9N-pp7l&diXV;;4-} zr^imoGB1QKa=yks7&;pfb{STN%RYzCc2o?o-B=~E-2pu_28Xx^Al`-qNG-H;J0|lv z`gGqmuQ)_E??hv7e&aiD{otFIKJyz_UU+dVE!d60F>lOc0%Mmx_499C{I1=JQD7Wg zpirvrgAou$+jy6|O2z(Q3PUS;D`x9m4daIQi0Ly95^no=8(E8mD~yoM!j0WuWOf9u z@#~hu|1Kd>ZtXaJX5s<$7mSm+?{pZWxIPKtb~uDTyGM^at{z1I3ztR_d1V%eVHCt*oQ-Tp zxM8Wv(h6lTNP;qSyCWX~0YtYUTd|<~pY9L>fH;s;}m-B5$?o?uT6YNIM!gfR+^TnjHB{iTUTd55O_OTVX1zt`8~1`5Zkt}n zF8ZyT?nR2z)2bJ{YY=O=Kx4h&_vWrv^Wv=5#zJ+yGC0ZjPU3r&woV8eu(xg8nW2FX z4y4c==UAV#zfK(usDZ$Gv3BV(>v61?NLXx-2B;<_r6F@$MD->I z%SFa&iH!KfH6VivJA#Z$3!mrUJ%iFsqPjkx+>vXGi$#7Xc2vCENDp)IZ^QY4UMpPi z7(~c!HwChKJE%vI2Rt4SVJ?NoPy>cj7CP6sJy6{)P9Bnp6w#eRuXS)&G*P{K#Z7fFX z7yQv`G)2}o&XKh{T>sBHBq&VzmBFH$YmG1+f-n`PL}6Ow+QRMDZ3Am-7dEe8QtoyX zw_UNW;70p6%EK?KL4tb9aftii0+khi{%PlhsjqW<6UaFLogpTBEhDsb zYXfOCma6L^7fl#n>EYY(KuvOu?=K7Sb#LSf=+O>vln~xxhRr*a1N4r{0Tlz!MVOX8 z9AQKq7SGpML*>^muutS8b{8!;@Zg+Hrt#tn%eTpSOhc>_l3f^h1E<`D`I?cJWjOUu zm$lo+U-3o&#uoWAV6oUb*f0WZi`NYW3DqA8I=eWsr)pIR>YrtYT2bF^Y{D#*__n6j znEpC3WfO4iX<;U~eqlRSK5k)u3ZFt^=zaJMj9PIOkGILd{v6S67*nnncbMp_MCSGe z&~vy;i}liww`t@&JVczXQaW=l<+R#r#A-}3N8q~sTYlS(M?FTiw%4GHwjA={rzo+aAlQPsQso%+|fg4YP}|N|tOKdg4Gc6v!Br z|MvB8sAg;5JPmb~z^Z5b(=W5zpKH-~5ohim+G+cD*tUi8EyY<~*0$|8h%-+{h$X3k z=60at3+{Cm3mAB!?f3j4Xw>K16tH7pFLK`Vk45W?EyiWEv6brUuK&G{*?2R7)ODp= zroG@7D_)O}!Ey`QfYWZauwwG{K7Zi1?Y;We(>1DjZnpa^nbvSYc{Y{BvU3*#cQF3Q zZ?8>u9y7_Y}0VR@X`2VAC1P5Z(pW8E-!M>eTL-GXe*tM7AGGGch0Rp z@sVj^V`|E6cb3d&^0=#lo5Pf^-iOb?qb0j`w=cr3zeZ$R;kE~Yvqr~q-@S=ng{Z)5 z;7@%V?`|N~>y>IhWJ0Xm)U@Z}doWgQ@%e9U@wr|pyT?CB5Ub$z@uQiZs)wNH%_^@K zG_qVS@k#H5qJG@|%*V5l(At;z$4;xD)OK1&F+pvRyVMrB_GQ}hpJN;5>$tO)mp2TwC+OBZ>O1~ORVRsuMzg3< z?yCKjkI?Rhbzht7`Xi#RFO(8RtJNZUQ^~J)-l2mN7`jERU2{a=cae2jxQ{Gdoy<05fm6jJ+j-Xz9fDRLBE$EO>mSg?POh9 zyh#MNU}w^Y7m^FdSUiPy>Pm|D=8~+Fb1CCqtL3Fx$L%v~?`F=Wg>;R}3*A8Z9^b6p zIh$O>TR-t)M|+p^IF-)wZNXFM;OsnJXOdaW+WQ-lmNJX!8NM#KF4usY%k?{zSN--o zan37=ovXj2PE;#g^%i@6hCT0@PRTo2@{`Hg)It*PRH+N+d8>PRZj!HZX-L5elM8e6M=?Tp?Xp{IW_r@z;|1Io zH}V&)X7JJ(Of+5^=~wKg9!`2GBMs#^{7Jk#xv|8NV+(WH$vM2X((kzUipcblql-=X z;r#Ue^ekV^+3&Tm2!x3FF?-ODs(JIMKS)d2!}+6luMJ+<>~`=ey!N$P&*7P+)Z*OS z;!)>{<9<#aSFpTKS&IYLOAJ291UW;a_nf@gN_^9t*FgL=v(UsU*Qs@eS>)iIOk97M z!H*Dd@1#vWoglcxAkTgD(*!(p(G`Nz1kVy|6Nqct$N2Od!N&(2)<453k1JN!27lO zb%I|a_+^4$A^25-Un5Y&uSg&gN`QFkQ%jf2AAf*s)^8&um(#;EeBR{WP3BF6Vv&J? z0fWD5G8!J;IT{&_kHkk}qp{KM(N6g@MvPIsfW!IilYx$b7;}!`Z&c#sda8t--$se? zx+=n6i5}J~>Cz*-Gh~6i6R$w}VLPYtLOXJNDYGe4e}t(g38EaW9RTBZIzJ_GFC&sj z!cV@O!6|*^%m#hxg`R{y4HgrUqvgzw;HMI`sd;v;I|*p|)m;QMt?Ot94lxS0+OhT3oA7gO3Nr4(*pzeVvBA~5X zzU{7AyV0Fk`0s1M!Sjj|6lcekaXz5 z*M+X5>%DsQ>eZ`PSF@|DJ%iu-zIMZ*dp?lKyg*Ozr@?az9_tUXnT(zp&*)h_*T{}% z<$rEGhyVFTeo7nHrV8VQsp5EXsx)4jDvy_^+Q!?a+Q-|cI>tM)8C}y0jn1jA@vf=v z@$RXf@tcx7tQ_@b%a@!qM$wcU`eOJOi+=_Defkpk zmxzBQ{Qde;_?H?hk^d_A2lPSs2PJ+r{LA#^@GlpC75)|aO88eARis}7|0;bo{Hu*M z@UMlxs;_~6jl{2mf33a_{&nJC5C3|71N<9|bx6Mf{*C%3_&3S-8{yxq55Yeq{!Q>- zpkE08g#v#w{1@pL!+){(hu|O9FM)@j{rPU_X|6RnB;6P8gu`RpSwRwst{x9mRCu$qngjG7xUGts)+ z?rAl{0i88VuTPkI&1^PXc2{j;W~Qct95sE?gm-45e$T`~qc%M;Wz<=O;IH6#tnGL) zGH4qawu|w+-l69W?LhAF%z-TV|BmrlEL z-)na7xW8@)C1y7w<6wZ)%!?m-`o;G=weal^EPUsog=d~w`1H3=e(hO1W0$53%L1}> zlFI$@J?}iH`|;AsJe)a}ozEW6W;65I`AjXRXZB@IWJibccEOsRF-*H$t4&T%wrVxI zyJnEOH7Dm2Ia{-g#sPB)GCGm9+iJCXW5Tj(wG)|_w_ZZJT`~*Kxa4rtyyp_9jxL@# zvUO(ilHp6dia0U>zvGjS$a}*xN6bNFJAmgjrB7$JJv+A~So&cPucB$RX3gn3WRv&f zJD(9er;BjrGlx(zb17a=WX)yj-wOOQS9?wsZ+81ZqjkHY9ivZ^X2tB>(hzJvO$;j2 z6ROn-M+Z$0Wj>zyB->eTbgny?%k@=rJ<^yP=tQt6x0?IV)TR$ITyW@&mfuZ*;`AZW zP#dd?tcj{>uhpiS`fP*moweG%vl9&`rc|rx%{qefR?8F`o8&8VGaRtEs=~U_Xw+%} zoK`YPmCj-~tZ<7xMmeKp`*Ph{e_p~<+r(++9%>WCc$*NuFM>`bd$p1c+zUOe{rsc*dV%r}Dw!8Dmy76JOlO$RC3M&hOcpq?J}yVZ zIy}PUtdA8rlVPcKVa+2pR2Pfmb%EZnWE3Hx*y|R?OZsB^^>#=t4f0HdbxMjZy&F=i ztSeuSUV*PIlzx%ki#*z;emhXVOYELV&oRpqM8c&079M+a;i+$(`ocpCU;Xr{2Ob@@ zOLs$5Gz>FVg|29`*tAs@9)|>Qgc?O#UPN1Nbmx%f*CpDFlcT+~Hr;GZ9yn4v02!wn zR^6D^C#G8#s$S&8)yO!h)-OZ2P`^D}q?8(n6vV6PF}s8EvQ`Jg1i|cyE6O{M@ubpE zI4Ime6rz%%IXxm75^g?uOlK{em^gH^7AdZ0(YfSC$5cK^a&JI48k5i^_JL5Ntd7b01l0gbFe4bWtgzZK zoc2j7F6K6(J3>bal!VA)h!LU$q>fRU^-7?pDP`s}$H<(y<2h)> zo|MT7NzJVuYJy)CUb|bLw4k-r?^YN|5w1YQ+^Q%p;e<+jWygj(6GaT$jffaq+uv+9 z6#VTB+(GA7I;q0vD#TJyiQH73L8Z`_@5bMXyvf))p3sl*Zoy+!;e^CcPR~D*8P`Nb z%1}j;uAqnNC=@_f$rLRp5*AQ|Ui$cBp0r4>|1g^;cED|Ji_vcfqQc;FgAusHUYhd) z)zzHdHGSViV-hNpq2J+wTNwuzNH;oEOsvpX@%vZP5#I5gD#LccVG64Zhc#Btb><~B zR#OF};Lmz9oM26fBFow;v$l)^x(U>lD6-0@)Y=k;Tm^OyeNNPloBXm>NQz{;87HUYT1P$2j^) zBECXO_O4R@FaSJKCcfJ<53_d_T!-?bp;}-KkWy3{Pg8#)?cY>BiV?@#GqYJUH=q60 z+`Z6^{X$?=ksH3$&NiXe`o*i_Tf2Qr0|l!$r)F-_nIUr@$jn_EFVF0Bv_!*O8qNAd z!@3DCZYF?0qMCQok#_PXzE$Daz40vS2p5>kvUBUt1?H&fb)2ETfD~clA_IsRY;kmw zeK@eM78c|m`Q!Yb~5yixV5+Ilqr;0=(!4D7;M?u}$Zn8i% zj()h)2r&RFo;VA>WY_?{rK7p|9P#A{GK8&3dMRY7CJY623BO`JJnc@UeW~8<5Wa8_ z?j*wDK9161IG9}Zab1b>P}FC3MdoYiOwhTF4%tWbZ{()*PHs11Ux&x)hC`9ri4jk? z)|cH&$3$t(R5S-4FR$QsSFo+=4>ETpOxoEt zSI6-TrB6lCq*zi-Hy@A|qPrxau}Ebb(19Lh26w}mTbG7JAoWm3x`3cw6c7*x>7AsL zs{0yddXCIdNp$?12M@IXi^#NSM-gzVhoQ zzx;U^`e2Yf`JE3eJoXz4@BX&QffWpJlXGzspWDtNV_`je5IoT5sXs7CDa%n%1JZQp z+wPF}9>7Ry|G$cGi(Nu{7N(AY2-2PeKnF`KlZ_j8esa2X7UKrHf%oDuucSj?jH=}K zTkwb`6%@95PE4$MU4y1s&&(+orMz?n0M_!u5(#q7~~a}t(HT(gPPAm8%s#(|01Mk@)gS@!a0 zh!Atc`fmB%G;RX18j9Yd`uEIm~_+YZ$#ZymAhqSex2;PGYAjM= zhk-z()`Y%K5HYrda&`blzcZ9STyG{tM<7GLa%K^6oRKX$^u?;Bgh2kRw}aP0Jbz_^ zDX%DII(JOgCO%G{(P-C(u~|;WW*Ww3-4drvcpW;;cA4=`q@f{jvEGL-x-daTA1BAO z@op!MQ)AkAkG{;%mfZ5=|Rl z9*Ai}dQPQj<15q@+W1O9<>bxf`V|OWCCb@qaNbpRr?UCpH94&}56@C>3I-@?A_nP` zU;Ooj_kGqb%}&!QuiKi;D6!GHKfd!}1F&cn_Q$UwlO~5=8fO`51sT^C*$7}_a|N$w zw6+T}H(>YFtk#6ts?9X5NgCELZ8JSPg$b|27G?_gT5mRHr=~4@pa;5wdEk)L6+BG@ zJK@m!ss1=q6D+vbAJ}<74YhB#m~7vt+u=yz0^{DS`8I^Qvh!iQ2O3QkUb|w!P{$(O z;gskZgvvM#c&rTJ5lwk!i>0}a&_qLhly4j8NIUf!t6ibpF9`fuCfWoi0y>&5q!h8o zpbQ}uto3k|9YD{Zzs?-W^<^mCT6u=bSQ{0NAv04C70ie5&m5!kARIg2Fs981=uN`6 zjG5MEeQ)#dZzF{au==tXU_~p;O=ai77qJS<<6A-Xdc1)5vKrX*9+)p&b@QH#xqLdW z1hQWUj&bL+TcmPjRC^SkL&&}Z|5Pbh0Jo~&#n1?~O9xED0P??sI6=Oe?WYFX7pi3^ zQH;XmH9^~@uvt-brcT_-dDNA80)N=832tQF8HMTt#4L%p9fZ7l!fFA<9}`8|*f=Es zv&+9iOOiQsB^-tWNn?nT9f+vUfJ52zD&>6T=FOQH*kiz4ptZ)-KP;nFd5pMEQSZj2}UkI7c1-Qv%jh%38ZmE2uN;*2*X#6iE zPpv&B2$htjY{SELW8DI0ZZXB@ykIeyp$$`~eRoj{t>WSAU1G|nt3lAV@&|H9R%an} zvzgatC}AR}gpFFHo;4P`LYZlBO2N{2VfYhIkVHNLb)10mb6PZYMfgI}!-vklp$m3ugco;go;5q}>3 zp3nozDt+}lr9|ExKQ;eHe^eogH#)O%wjhMfQOjeO8q7pw1RO`k$yr7G>ZhSdA1jX{L$WUSWAm0*{30d{D zmXsqERz=ldcZC(yuU|p@P&LthcnLF?Sq5p?bVKDFl6(b^H4KN=9<10Z zbBeyZP}aH&eCyBmm-yFPS|Tm4^8!Q^G1IWVNKz#IT@^ zR|DykabZm$(?M;eIVpo{W^qf2z+(Degi@_Iw7l#O~6ajx9B$_ z6vh$3-3`4-zZs!J`Yrla7=A8rXt7NnLFk2!Z@az&zKiso`mIQFv3{E|jB@VMUxm<1 z9N(+;-SAxs-(`rqT_1(-a>utvzXQH2oZMcc?}hJ5_^v|Aefk)DSL=5gS4oJbzgE8s zA=l`yL&)oqM$^ajHz4F%=ZiP$Z-VbS{mm#x&A1-%Z_y_Za)Xp?zp(`&bzMiujZRs+ z5Mt;D5OR|kZf=HDIcOJ^oSIz<&Q`AhW6g{2{Tz%nVo-Srq9S8b%D$AR!wxMb&?rh6 z8?(O4vI7VB3ILAF^WP_#Fl$LFhm}uC?X{ z0+9inBiV-okuf-=E8$2_$0bzM31ABm-70H$Pc`o|#+q*4$-q^bos*{3x{1IaM}BU% zG8~AE0cULs@Ls&g`Yq`z_3QvfddliX+Y@^1AK;%!6H6in?FtAj1zUlD*s6N7bBmms z^kdU8sCXD0!XAvJ0^j@{1fFn!r_$a5K8jWG+gbW6@KFRbIH6O94(*lsPdoCn440S9s%e+;JjdkSVJ_fd%H68m7(Bm@nCJIBBa!Un7k z7pAWA`DR2Uf;t(3eJzP^G&HQ_aOyt7Sq$O=& zABiDtpxYsa6A@zpj|z(aG2Zj|U*I|XC#;vs{7_fP_^&0@e+S&=x;&^1j{!|89CZD& z6s~L1+Gb#O$B-hv-YcS`uMdZ!V=%pfb^}4t)}^5LU=C54L&VCJDA^{htp~97ibZ)N zpi0~B&U)e{5N&rrRfVBl?IvL{-5ZZBMrmEgFtSS}(RE_(w z5DIPUPg#J0U5$ouaH6r*JUBar?MU7(flx8?lluM9LM{m-zQ-K98{>!rEGy~Xo-NaK zo1I(XuxMg(yVI#hp>M449xq+$6#h77F9SyN#Tet}9ws6B=P{c(2;Rov3nY-OS$Q>) zqo(O|CT)9SC3K7SGY0$#ors*Hl~j?AwclWosJ4`0Fh>=>QqH+US9Z64!dO#aC5+&a z1&;^W@I=fCw1ftrFvLenZ-_C7uwsZtWPBHhuRRQ9?Vg>xcI@6>8+-j7J8GkM?%wT+ zPbqSww6u@VMl?&vqD;85%!x<`xdre8WqOX@aPBhry5B2P#b*X(WlGO`8#D8jt%SVo zA`sj)-TDz2ZeNzY&E`Wj}PCXMWpY1}(& zm`6U$>~BWWIk!HXi1geeHJu>q>~`IlsJABX!>av{dH`H4-j7RO2kDV10_aY!KvJqI zy!KLeonvU(u3>({gSyHQN+}7?nW2-Q5Bkd*Bk(`%!FM(Y52q$QFATi$b4kxWe=o>q zJowS_M-rYF^g#I|*?!K0A1{9-X*#2w0~_~4WZlKBXj>bNJ=3>i1j8NE){`E1XPE>0 z@`QBhup_*e#N@Q~@3_BZPFP>^zy$=din5CsG9t;j(%J3H|2~1)(Ppig=CuBl2hMM^ z5@F}+rg;m#3{7!Rkm3s^dcx&8;Y@@5BckQQNC$8Ca&|hf+3Zep@@pRSL8ocO)0`Jw zdqLL-%-@W`jHfXlMj`CtVJMqenZZK4zjGh}zcv4vPFTaS+Yd}O8fs<2H$5a=N#@7d z#r?8UH3XO1JzXtf*PQ`JCEy<1ekqE4y}`7&YLy8ybGbfd2=_&ST;} zifnJaIdep*USmzQboSdo+EdwOhl5*d@w71>^^o_h3h074{UC!{s=F9z{3TKP3p&ry z3DZwZ@!uoi#G2x&aB9M3=$6D;1LkG-26WtAqhmX6-LcoM1j2Ui-m`VgUK9w~H@0`z z=&d2;c-!th+XC|sGV=aDk(Bv|AM))-bbd_dcj^2GIzOQEpXmGnoj;`WM|5O9gCi^R z&*=O)odTUdrXz&#=OmtI*ca%?1jY+|lPQXy^X+LmqQkt%w^MXpqVrdD{s*0_==?RE z|4C;Toxh>;w{-rFPL7UDQ2ztp{)rB!c4cB2j|#CuiJPS2D^nr=S*c{@dqLdW{NBJ*mJB?#`fS@VQGmd-VZhF?@si zGT6xbu)UAI<@yTvmcYl9EA>_I_2X=liiBu#wuv^rR9|ZpaH0w4Le}Fn6U>*0jeQx$ z^Be8%t@|zX5%rdmr?c#A!a+fs`#Zmj9ewIBio#MnN#+6`^oMdd$BqsWV+>S{o|e*S-@}isk1*I_ybY)BDGE2*_T|yc4{1q zA^W=B-F`}m7N!#(tO8AGpubPf<1n0-g)(e>SfRKyOoLyZ9bXKOe+Y<5@r}Yk*CIy# z7O}uL(WdxQEh#}c5Q*?p55&qyQ3Ql%fJ#<_UEzDW0zfpi1-Cy6bO>LKAYMyM z?)1>{DNEt;Crly2cVh&JbJd7lM9ea?a-_Zho=5{sfn|GuH%9=UyDFRry1n4K_s8}mzIbapo{GE&B#!RlEBN-=^jeYE26U5DU zncEN{B+B+n9#TkG{*WMkR73vJgEbg|fBlH)Zv{dSMNE{gGb>4KK>@8u)IRc!(w=<9 ziHkXux|FIPX6pSU3yIMce?}YMD1GR=^sc1O^&~mD_$7E_WW$2E! zb1{hF@m^k!lZAJGeCNYX!(XXxb^aC!!aGk3=D?${Kx(~bU?g>l5Za*t*FKG-m za!(X}2}0fOmc@27Igd=#?>4#!HZ0#2J}!g8n2U9NUV0IVF?r}x-5LNURMt#c%jhf^ z#N?2#X6FimIR0xtnvV@N^iJ{ z(@Vb?2~bfd+_}#$0&a*DVqZwY@CBq?=V6#8(m)ECyGkd<5|W^w&eAku5Qohks55Xx z%8Zpu4s#J9knkaX6q`v>5gBo@2lot>kT~1qL1hWC08JLPjfEhK{Uix8BQEzKr}3F% z^BPQ7a>RBdstA`>o85FoW$EEth0ZiUDMdw8peN{ko{ltvh@t6eMhLwG^;FfS9XbCC z9%~goP^wL@M#ZKKlTE+YTTp-f1(pQqUT2(dxMM(s2g;|+J4cXGG6>=5M< zwz3q~D8X#Pqx7iS6vU@gn>P5kBvvhg?Qnc*5p1X9Q;T4`9G_Bgy7fMzBq5rz42}$B5IX`ys3KD)L!^BWjsXzkI35F|{=9s8D{X zOgjUC5ViMq&vZM2M!y!m_3&*#+;#f(@NIN_H|Sg7+vMbOqka>7n?+q4g1UCI?U-us zGI_3&IlBfGt`s&WBw&(Sc=w~HKKrO_{IAQ-wwU}t<4|^~KD_uEnyd>;(a?HohXu4= zQ+c`*BZFYEq}{eRvjN_L?7jUK3iDrBPs7~uGQvpG9k{7gmEX}`M+kKjp*r(y4s~R{ zN#U=k7E@VB66u<0^-|`Yt4~1z`Os4HhHzc(B~fat_Cw zVVNmDQHo}agg;IL#fZIU29>z1G#!-8R3xzlBkuG-Icu}r+ES%*SCYyS&{#XoJH?Zo zRKCs8U3KAbi%gRIKFb?XxES#|!XLtmyRt6`-~0(8QlXl%JtoMPKOm6*NGAe`5pVDy zC71MUi$de9DHeq!!ZPB`X@r&b<{NW=inPB#5jmaY$~Jx)Eh*zC(n{)qjxR67C*I^^ zoUk%~g`I{maE#DBaO*-M-(L_X;G9K)$s-S!lj5L7XL$}_q9tX-K@YUMPuppeC~3+F zA|2B61d;@a5r;fT?oKryQqp)J9n2Tfz%XLU1LGe2;DbpV4Wz?)Aq@^AW;{6Veq0|; zvQD24D0LLU2<`_{?K@sWDH?q`q@Sl1i4pgCkm5y3UW}Fw=!~O=BOai59m!w;?Zo@> z9qFYPkOQvVzFQsY5b9P>Azfm(%7}SF{V#Z#b2lS8HI}@1%!L`3S~6{%B()gvHbQxv zP$EQhSCO50@+oAG7oFsDYGve(YX*6@vRukAp9NRaTcyKo##=xe>w5S&itgoM znBD||TKM2DkZ_kuaN$I7kp!*_U_NzZ5&E%Ex8Si}1t&Vf#>rL%j4XM92FKJzqhu6h zY^xST@GL8h2h<~mXEyQZOrB}gg>hcD-8*77E$a@mS;x%|szT);>3Fb=_)dNE$y49^ z_{k^VrEKxP#3`bWlCN$?@o+v+45i_KrE@LP#Kr(*?h!nZqvaC0nAVj~c+gfPKqD*5 zIx@Sn+0gwHp*p9H!=5i@1om*)MnnV~G72noVtQYLc#~VI1ME{pJT`U7%EeE6C=Di{ zq|%J0oYW}o$DhTLHXueMX-VtDK!tk=*{mYs!vHHbd&RT8c}!n1Jdp?SQO0@;oG1@E zm$>*=9^pf9rO$(HMoGBRo4Ug3XI*&Oj1F+6W7!c41Ua)}Cs4r|OUzyk4B|9$Vw3pP zGf|kdA0!IlJn}UA=_Je+)y1x1E+-+S$@?^<5c@o>I5A*^r44V`(t_7OT1I@{Rsul{3=qL8;Kh$PT2?3rWU@)>L!15W_x);)cSOU z&(`KhF~N3O7~2koEzKEcz*5*Vsgq&EQ$ChBNi{pSE*(p+t(sl~i?vLTuC#Cl=*nZo zJ-Py0&M&Y;SZ*1isWhQ=q^{JwU;T{ux{ocESY~mEbSe|5W<1n=mQL{;+H-10v;i1> zmKb%SBu=B&dbL#rlQDG!hJNG){;b`I4K{1sj3pNj@Zdz;yj8%S{epqcWe_)z;i!7e zJHMby&MzpVi{U18RHoSDijzw2P^gkLfo?qRGNOIQRf*fbc6HY&Jtx18qW<+@5Y9=pdOuR^+Dc0W2fSM$Ae+S^yR{zlL zYk^XE#$RtMq8xW-t_7a4PQViqG*YWk9b6vZj*CdC9d`R}q-5{&GfT%J-D!$>*QmM9=ZEQr=jN}CrGPMRFB+x_bNJ^`2U3B^Hw z4)Zv}{1i{dql|2JwJW^QY;vMet54ugx5?I#)H=2{<7?lRk7ELHPCr+f%4wTgtKj(M z+)dS|mI5nGDTi>Yma{`t0WZj5o9eK)2NCab!6i~oIthL6Pu#Nc(h1I&&n*cN*6VhK zjXsEMV@1j%kYZmNn0L?}k0$Gr4kC9ja9|w@DMykqhPzU6#DC5`W7kz3-hs@_%Zcz9 z-rQn%2t;_pya*}($Sp=U_7Hc!(wCbH^GBH7?4od;H7u+=8scS^hNB}X5j7>02vy@8 z)|XWkHIV7cEahpznL{`~3LB2e@!3Zqpu=S;sN=^UL^i5kVx_u*#e5gzBOG4@AA<$| zgasqhugKzhh{d70Q7J;oJW~7HqSwOX)(1{$XJ_r!1+nIqK+K0Lsuv>oiLeqrcblcq zKZ+zYdLa2{M3OyWyX@hPpsCV?&_tm^=vmYA79MS*SE; znZdc5M0YIZb>w7T#(*R^e~j1{JUC&V5;(r)`e#TQ<0MZi?nf+YfJZ1~EV+*bn^zzo zu|vCH_E4-l$3Lu`&#D-v=7D{PUoG*JrV_?>Bir106y7B`zZJOz7oceBgcQFSaiH&x zqll*YSvujml%*;!vLdPYEQ2Dp0#5~pe$DlVxDLfmuqCtEwBeCva}!=d`|&fg8MA}> z;asW3CIp1l>3ukB0PE^;ZXYHuLPwOz%7ubjKO=HmX6HYTjMedR*RaMSC3qgOf5Q?~ z@WQ3=8V(icMj7NtwQ$=(Db8r8ULYi4k*r!G@Eijo0BNHBCjeAj*cT;J%t9R^()IW_ zg-8XpcRzHnAq+hs0-eC;P_&;QTIWEU7m)7dC~bIxtk5RbfX-s{4pN6Xo6pgSQ0L1C z%cIDS0X0gU1amj(E%60JLXgu+k;ok~>o8xbXe;53?bP+D@*-{IQx}vlaGv!|ZZ#5p2cKiyx!m!|H zXD1i%hB^f&v{CP~OqtL%%2u&nl9o!YmaU@GS>bJb;pP|h;BwU%iFueqNJyhe_#~#> zaGPW+dno5`)XNJ{*>-j2-Fj<*m$Ko9Vi3LEE+NH|xA5!SnDi13BByX6|a6nfPdbe8W@ z$gM{*D(jWpiq78R#sW;q1=(d+?rnqdxDEU5I(sWH7jsBfN8-?rh2zh9Kb-K0(ZHH; zj>H3tvT!1yj9=BFEH1;s8gnt#sfAg*nvM&fIxwPCqkAmMl8`P*hpP?b(zmUJD!pel;q7|JxV7^^JumKKAoxzNkjUc1hXb z;ybB9E@=Q(6)*mP#93S6QnOR^}gY&8d?yMXjPlW!3S6NdBgh++~zGo_Q@~)4l%EDl9%H`=SVMz&|@%k92i*+m?gIv~mB8 zdDAs42IY3{f&R?greG0Vy)wwvh&FDDA^yu|VBxEyK_`6Asl=riwKBBvhV4wq*Ed8Z8Bagr~oYPT6Uy52Bx*oGp392~fX z74ZW^BNclYS$ZR@e(da|$>aU(LY-$BMmRyfxrub5K&J-ETM#gth5m_$TNUvpoqvdS z&f+3x$<3LUgh)H3USxKY!DTTz-#C(%BVPP=nm45wqQE@CLOe$&qNOq7b|CC5L|2zK zL@G8x-*+33RA&`=oDn6oKzA*&kJ9tR<~ceMlo+uWD4E+qXY_l%wBs5Ys_h8(el8~X zKw18Y37AG*Oa?YbQ|95%jx|ll6pGG`8^mF>MhB^~W3v%F+G80~duQ6ird*?Q{PoBVaJPvC6aUBnElj8x2SkSj0 z$*@nThQ6$Yt%yyX?J3JStgwy&W=N4 zm6%S0+G>wG@r;;CEJk!##4L)%$W{Zy^u}W3Obm8HZtJbwMccH2S-luM(DawsGQ)9 z(Dewt3D9pw`ddK9t-zwJ%bDGX-Jq|Bq}^e6ah245TzhzDYqDX@t^tFELX=ql(97yRdcJp1otXwsY&Q-F9);t)qMP?yyUHcigdi>&Onfym!y;-P^W~ zyjsnfJ&Y`qH&Ii`9%1ZGI?{l%GI@`&uuOb;pGHMTMM=V)-q}Qt<)QzuO;>Vrt3m}B zjwZ!z7L!IpH)*$z&4eIKp|r(CNkGH&DhRy^@$z95q2&sSQnSXI&S_|`mUf^QB1z*fld3bC} z!Xx2}^FqX_9%ZnMpz>i4mBh+P{3bLmVqd^#1dq(1(ExRv3hYwOFX7k{SSE4g74>`E zMtM|&-4a?qEO5(l?=I$^<~7c+-YesC9Mg*n#b()ei(2`oYvECZ zIEv|zL%CylsyWBB;~AL5a_U-6CmiJP!>HZUSXKlu>-wsBAM%-N8&P+NU0-$Sa+rm@ zpUx3F&fuOjvD;j7#Evd**Jr0@Mnq}-49iVTy__51{hR|~HuMvo#avNA7E&jNBXDtYiE`SOkUWUiWqo14@w&6v%D=ERiw zUrCG)!a3LG0#SPpVE7+KIcM>HEOpqk{}8T4#qs$H%$JFpND=QITIoK96Vis73OU4; z`ZCAUV)Kw`%<%H@JBial(ktgPdK9%KO1wlk`e~1Da`Us-w>cd_B=xAB)A!p2ISbU* zCd`9YI_0*JxU{thBIpyQiDi?{44p`wb~YgQb~eq|@SM@#^hhT6qWf3{6QzR=cSq*E z3E;Y|mO1GIe8vN~BFsMFWakC4b3aZIa7*|d4`8H(!9*c>fkOD)z<~$l1ucJ^)J7wE zIlE~tw`mhje8$O-GmVM5f!0Ijj#9eEy0@{z!io(;HJ$GR718iJb8{;rr4OgHbJqS4 zhvG|LhE?Ga4ppa;^R6`rb2Rg8;96mvt3Hd8pdks<9%j{y;X?$-(a=QLE*XNJ9>u($ zyGy5ag}lD+HM>;-e#8Q>p|t1vvvYFYyU#JnpM**glEgE}2OW;g;3^8cOB`UJ!(1*p zqE!r^hiKv?nrexP9Bz9B<%S0h>-Q?l6jK zfYHzFo~Ai@aB>=}eAFruyPfNr)q9MN4SoIP5bTkfXR;7bntNKSj<;z(=HLLRxbk0Ah`Y)hwvdjKPXI?xSQE8qLFo3Bxx( zjpEZI7UxD|g2=quIP#~!MU9DLEhdsOh6KJ;NYH|%kT?eQ<~WwB2s&RuFxtXHqzdO+ z?fl)iY~bMpBJtqU+l>3s*L!&V%*6}WR7SeNcw$VEG^bk_;oBu#z|JLAIEZp}t`TY#aOGI`c>ZVs{-T7H z<_pKO+;{LEu>HJttUQmS1&`;B7I7zCn_fJQ$%{7)9xct6jzFUG z@!XZUcRiL*bRL04RjmxTcl}|6%@-m5N~2=yg7E8xSiq&@t{k)5bZ5wBjUl!yHy+fQ z_q?3FVW`XQaU*LeExt0}1wz|7+#ICMOtkK{wL>u9nTt?DyF4{oL646?Ed>^Wv2%I-JnK*?_NuTvRCn^S1kxHj3Tqvu%tD}Zb#?keqvZrbgw389%g_e$^pYPzOk)iJ8s`GI#yGI+ipKVhPf5r?+kbs`62Gmw>J>v41(=WvfN~S%4pr) z)Rhrggx?&BWxj!Q5<3#xvRR{dg3f+AY-^$gnUj1wM5jS#ijLTs3;c|xQPZOHG`%gp zNk2r1YQB}ugLEFD^BA2^(D7xIyjA%v1@Tc*{mt-+Wi&_YDF1TMlymv$)0fSaD%o5C z|0Rz9H{!X#dFaQZ;b~v5-s#U*vjVFQFrlB@Dy;_)95-{}7*W`?LkoVR2ZWVE2ZSk~ zdx}Okj3Qie?M~40&@kR}F9t2#VNdf_X1rUh-aTlA{q~^S3`E1-HEkItgj9oPLJR}L zQ0#CpT3Jrs_iGD}e(uz7Kf3VF6DPm+tTJCyZM55Ac4-*uiWkt^`|+K;!2jkDt4Rza zfyKghz6O=GqvmG-@ybS`^wB5yO@ev%pOK?lExa~_bP(sWOwuA}k&q$#?&k?_1Ht?J zRE5{>goGYrAx9yJ|CP`;AviL!3_%Zm5bI|=;M)kxQ^ONMS7x9vPT-E8rl|mA!B%Q> z)dlH=kA8GsC@k`G+pCmU&BNisbHTy+${(4XtE%pDgEtn8R*c4BTFJvEY%dE{2os(c z6{NG6Z5izzw6Lxdg2s*oY1092Va>BSs1hYGog5_H91tQm<V&{&k>nrHKD-G5E!XcHIn84gD|wSC>c}JXLs;e(JffI}B_)SX=6^%nEHO;G1xX~- zOP~DIi(miH!uuY2@k389eCMHsXPz0w8mc(34w8Xcn@Its^rS39BjsT{9*ybWSRlPP0TWRX$ngWEU`-W*VkU@o*SwcG2mk z(?h31hbogv71!?E3zN>|lyft)kBpQ{u#{p-38hF+5WxUc=Syq{;T!|EiD{DI2{y)3~Sk(Xk literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/database_sqlite.cpython-310.pyc b/android_pyapi/android/__pycache__/database_sqlite.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8fcf089d257f1629307d4deb79fa8b82a2b3da0d GIT binary patch literal 31722 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 Cro%u0 literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/graphics.cpython-310.pyc b/android_pyapi/android/__pycache__/graphics.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..461bd7469319d3966349982e0614e02f3be56975 GIT binary patch literal 97139 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/graphics_drawable.cpython-310.pyc b/android_pyapi/android/__pycache__/graphics_drawable.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f9910b8ec4d008f19840842d9bc5a88b800ff2ca GIT binary patch literal 44545 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

L2a6HBg299j&^vGwp_)wq;~Dx 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/graphics_pdf.cpython-310.pyc b/android_pyapi/android/__pycache__/graphics_pdf.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8b88a40530ac8dcbe558a59e8d1de03112cbf441 GIT binary patch literal 11360 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 Bwvqq< literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/hardware.cpython-310.pyc b/android_pyapi/android/__pycache__/hardware.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b19a992b76fec1a4f8505023f29122cbe7bf7f8b GIT binary patch literal 18247 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/hardware_biometrics.cpython-310.pyc b/android_pyapi/android/__pycache__/hardware_biometrics.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4a6d4099996ef2f75152196568163c09a0e3f3f1 GIT binary patch literal 10981 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/hardware_camera2.cpython-310.pyc b/android_pyapi/android/__pycache__/hardware_camera2.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..356cf7709848fadd2db16609e15bbef516dcefdb GIT binary patch literal 28474 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

$wAT+KX_flx-kpUdbP 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/location.cpython-310.pyc b/android_pyapi/android/__pycache__/location.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0d2c6293eda9b6a291610cf39c82768fa6a071d9 GIT binary patch literal 40345 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 sc6@OF+LlDK~FMVWicr!4L}@ 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/net_wifi.cpython-310.pyc b/android_pyapi/android/__pycache__/net_wifi.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9d09da7617b9c73cc8cda271e09621b97c749173 GIT binary patch literal 37517 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 DdC$-p literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/nfc.cpython-310.pyc b/android_pyapi/android/__pycache__/nfc.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..05c2339c4acae15ae02f106dbcc1a910d6a37d1c GIT binary patch literal 14885 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/os.cpython-310.pyc b/android_pyapi/android/__pycache__/os.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..320a595226b791970b580a4911ad600bc64f2f73 GIT binary patch literal 61593 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 Rs}OT-=K9PPnKdn2{tp%rP4NH# literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/preference.cpython-310.pyc b/android_pyapi/android/__pycache__/preference.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d2b640fe34e40800c228fd52f8c8b048afe937bc GIT binary patch literal 24587 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 CoJ#5d literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/provider.cpython-310.pyc b/android_pyapi/android/__pycache__/provider.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9d79ed6f8448ead9a4e2b4c119be5aafd2922b3a GIT binary patch literal 19798 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/speech_tts.cpython-310.pyc b/android_pyapi/android/__pycache__/speech_tts.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..29aaf0ca68267a7576a478f1e20ea5f45f8aa624 GIT binary patch literal 15010 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/telephony.cpython-310.pyc b/android_pyapi/android/__pycache__/telephony.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6803018ad38f710bc949ed927dd34c4f35118598 GIT binary patch literal 33335 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 RJBRiU9Upoi^q#(L{}*tORX6|u literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/text.cpython-310.pyc b/android_pyapi/android/__pycache__/text.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b2c4c5c955accf041083181ef6083bf2c1f56944 GIT binary patch literal 41815 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 AqyPW_ literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/util.cpython-310.pyc b/android_pyapi/android/__pycache__/util.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ba70168649b0d627257a8b7ada296f46e85adfb1 GIT binary patch literal 35298 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/view.cpython-310.pyc b/android_pyapi/android/__pycache__/view.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c71cbc0bc048a2071081abe1cfb7ba317e5ccaeb GIT binary patch literal 150712 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 SDuG;&E30Eb^(6Y!$^QVK@_nlS literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/view_accessibility.cpython-310.pyc b/android_pyapi/android/__pycache__/view_accessibility.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5a0ca4f43908236c79ac6388264af5d499f75899 GIT binary patch literal 61829 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 VU-RwFP0e-9YnmIIuc+Vt{{ut+KA8Xj literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/view_animation.cpython-310.pyc b/android_pyapi/android/__pycache__/view_animation.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..68fd2ed7f6080ea805330acba33514fab4260310 GIT binary patch literal 32588 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 HIn({`)o(`Y literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/view_inputmethod.cpython-310.pyc b/android_pyapi/android/__pycache__/view_inputmethod.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..288ce256210f7aff19508701fc84c462ea1932be GIT binary patch literal 33993 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/android/__pycache__/webkit.cpython-310.pyc b/android_pyapi/android/__pycache__/webkit.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fad0fbed74c08c37c0bb9260a14fdc87d5514c63 GIT binary patch literal 41455 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

FKBw9J=3#^@&* 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 o@a=`gt;Of!i)+I;c<0v>k1S^xk5 literal 0 HcmV?d00001 diff --git a/android_pyapi/android/app.py b/android_pyapi/android/app.py new file mode 100644 index 0000000..801a800 --- /dev/null +++ b/android_pyapi/android/app.py @@ -0,0 +1,2001 @@ +""" +Android App 组件 — Activity, Service, Intent, Notification 等 +方法签名完全对齐 Android SDK +""" + +import json +import os +import time +import re +import sys +import threading +from datetime import datetime +from typing import Any, Dict, List, Optional, Tuple, Callable, Union +from urllib.parse import urlparse, urlunparse + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, + _sdcard_root, _app_data_dir, _package_name, +) + + +# ═══════════════════════════════════════════════════════════════ +# Intent +# ═══════════════════════════════════════════════════════════════ + +class Intent(Stub): + """Android Intent — 组件间消息传递""" + + # Action 常量 + ACTION_MAIN = "android.intent.action.MAIN" + ACTION_VIEW = "android.intent.action.VIEW" + ACTION_EDIT = "android.intent.action.EDIT" + ACTION_SEND = "android.intent.action.SEND" + ACTION_CALL = "android.intent.action.CALL" + ACTION_DIAL = "android.intent.action.DIAL" + ACTION_WEB_SEARCH = "android.intent.action.WEB_SEARCH" + ACTION_PICK = "android.intent.action.PICK" + ACTION_GET_CONTENT = "android.intent.action.GET_CONTENT" + ACTION_INSTALL_PACKAGE = "android.intent.action.INSTALL_PACKAGE" + ACTION_BOOT_COMPLETED = "android.intent.action.BOOT_COMPLETED" + ACTION_POWER_CONNECTED = "android.intent.action.ACTION_POWER_CONNECTED" + ACTION_POWER_DISCONNECTED = "android.intent.action.ACTION_POWER_DISCONNECTED" + ACTION_BATTERY_LOW = "android.intent.action.BATTERY_LOW" + ACTION_BATTERY_OKAY = "android.intent.action.BATTERY_OKAY" + ACTION_TIME_TICK = "android.intent.action.TIME_TICK" + ACTION_DATE_CHANGED = "android.intent.action.DATE_CHANGED" + ACTION_SCREEN_ON = "android.intent.action.SCREEN_ON" + ACTION_SCREEN_OFF = "android.intent.action.SCREEN_OFF" + ACTION_AIRPLANE_MODE_CHANGED = "android.intent.action.AIRPLANE_MODE_CHANGED" + + # Flag 常量 + FLAG_ACTIVITY_NEW_TASK = 0x10000000 + FLAG_ACTIVITY_CLEAR_TOP = 0x04000000 + FLAG_ACTIVITY_SINGLE_TOP = 0x20000000 + FLAG_ACTIVITY_NO_HISTORY = 0x40000000 + FLAG_FROM_BACKGROUND = 0x00004000 + FLAG_RECEIVER_FOREGROUND = 0x10000000 + FLAG_INCLUDE_STOPPED_PACKAGES = 0x00000020 + + # Category 常量 + CATEGORY_LAUNCHER = "android.intent.category.LAUNCHER" + CATEGORY_DEFAULT = "android.intent.category.DEFAULT" + CATEGORY_HOME = "android.intent.category.HOME" + CATEGORY_BROWSABLE = "android.intent.category.BROWSABLE" + CATEGORY_OPENABLE = "android.intent.category.OPENABLE" + + def __init__(self, action: Optional[str] = None, uri: Optional[str] = None): + super().__init__() + self._action = action + self._uri = uri + self._data_str = None + self._type = None + self._extras: Dict[str, Any] = {} + self._flags = 0 + self._categories: List[str] = [] + self._package = None + self._component: Optional[Tuple[str, str]] = None # (pkg, cls) + self._clip_data = None + + def setClass(self, package_context: Any, cls: type) -> "Intent": + self._package = package_context.packageName if hasattr(package_context, 'packageName') else _package_name + self._component = (self._package, cls.__name__ if isinstance(cls, type) else str(cls)) + return self + + def setAction(self, action: str) -> "Intent": + self._action = action + return self + + def getAction(self) -> Optional[str]: + return self._action + + def setData(self, uri: str) -> "Intent": + self._data_str = uri + return self + + def getData(self) -> Optional[str]: + return self._data_str + + def setType(self, type_: str) -> "Intent": + self._type = type_ + return self + + def getType(self) -> Optional[str]: + return self._type + + def setDataAndType(self, uri: str, type_: str) -> "Intent": + self._data_str = uri + self._type = type_ + return self + + def putExtra(self, name: str, value: Any) -> "Intent": + self._extras[name] = value + return self + + def getStringExtra(self, name: str) -> Optional[str]: + return self._extras.get(name) + + def getIntExtra(self, name: str, default: int = 0) -> int: + return self._extras.get(name, default) + + def getBooleanExtra(self, name: str, default: bool = False) -> bool: + return self._extras.get(name, default) + + def getLongExtra(self, name: str, default: int = 0) -> int: + return self._extras.get(name, default) + + def getFloatExtra(self, name: str, default: float = 0.0) -> float: + return self._extras.get(name, default) + + def getDoubleExtra(self, name: str, default: float = 0.0) -> float: + return self._extras.get(name, default) + + def getSerializableExtra(self, name: str): + return self._extras.get(name) + + def getIntegerArrayListExtra(self, name: str) -> Optional[List[int]]: + return self._extras.get(name) + + def getStringArrayListExtra(self, name: str) -> Optional[List[str]]: + return self._extras.get(name) + + def getExtras(self) -> Dict[str, Any]: + return self._extras + + def hasExtra(self, name: str) -> bool: + return name in self._extras + + def removeExtra(self, name: str): + self._extras.pop(name, None) + + def addCategory(self, category: str) -> "Intent": + if category not in self._categories: + self._categories.append(category) + return self + + def getCategories(self) -> Optional[List[str]]: + return self._categories if self._categories else None + + def hasCategory(self, category: str) -> bool: + return category in self._categories + + def setFlags(self, flags: int) -> "Intent": + self._flags = flags + return self + + def getFlags(self) -> int: + return self._flags + + def addFlags(self, flags: int) -> "Intent": + self._flags |= flags + return self + + def setPackage(self, package_name: str) -> "Intent": + self._package = package_name + return self + + def getPackage(self) -> Optional[str]: + return self._package + + def setClassName(self, package_name: str, class_name: str) -> "Intent": + self._component = (package_name, class_name) + return self + + def resolveActivity(self, pm) -> Optional["ComponentName"]: + from .content import ComponentName + if self._component: + return ComponentName(self._component[0], self._component[1]) + return None + + def createChooser(self, title: str) -> "Intent": + """Create a chooser intent""" + return self + + def toURI(self) -> str: + return str(self._uri or self._data_str or "") + + def toString(self) -> str: + return ( + f"Intent {{ act={self._action} " + f"pkg={self._package} " + f"cmp={self._component} " + f"hasExtras={bool(self._extras)} }}" + ) + + def clone(self) -> "Intent": + cloned = Intent(self._action, self._uri) + cloned._data_str = self._data_str + cloned._type = self._type + cloned._extras = dict(self._extras) + cloned._flags = self._flags + cloned._categories = list(self._categories) + cloned._package = self._package + cloned._component = self._component + return cloned + + def fillIn(self, other: "Intent", flags: int = 0) -> int: + filled = 0 + if other._action and not self._action: + self._action = other._action; filled |= 1 + if other._data_str and not self._data_str: + self._data_str = other._data_str; filled |= 2 + if other._type and not self._type: + self._type = other._type; filled |= 4 + if other._categories: + for c in other._categories: + if c not in self._categories: + self._categories.append(c) + filled |= 8 + return filled + + def filterEquals(self, other: "Intent") -> bool: + return ( + self._action == other._action + and self._data_str == other._data_str + and self._type == other._type + and self._package == other._package + and self._component == other._component + ) + + def filterHashCode(self) -> int: + return hash((self._action, self._data_str, self._type, self._package, self._component)) & 0x7FFFFFFF + + +# ═══════════════════════════════════════════════════════════════ +# ComponentName (forward reference) +# ═══════════════════════════════════════════════════════════════ + +class ComponentName(Stub): + """Identifies a specific component class within a package""" + + def __init__(self, pkg: str, cls: str): + super().__init__() + self._package = pkg + self._classname = cls + + def getPackageName(self) -> str: + return self._package + + def getClassName(self) -> str: + return self._classname + + def getShortClassName(self) -> str: + return self._classname.split(".")[-1] if "." in self._classname else self._classname + + def flattenToString(self) -> str: + return f"{self._package}/{self._classname}" + + def flattenToShortString(self) -> str: + return f"{self._package}/{self.getShortClassName()}" + + @staticmethod + def unflattenFromString(str_: str) -> Optional["ComponentName"]: + if "/" in str_: + parts = str_.split("/", 1) + return ComponentName(parts[0], parts[1]) + return None + + def toString(self) -> str: + return f"ComponentInfo{{{self._package}/{self._classname}}}" + + def __repr__(self): + return self.toString() + + +# ═══════════════════════════════════════════════════════════════ +# PendingIntent +# ═══════════════════════════════════════════════════════════════ + +class PendingIntent(Stub): + """A description of an Intent and target action to perform with it""" + + FLAG_ONE_SHOT = 1 << 30 + FLAG_NO_CREATE = 1 << 29 + FLAG_CANCEL_CURRENT = 1 << 28 + FLAG_UPDATE_CURRENT = 1 << 27 + FLAG_IMMUTABLE = 1 << 26 + + _pending_intents: Dict[int, "PendingIntent"] = {} + _next_id = 1000 + + def __init__(self, intent: Intent, request_code: int, flags: int): + super().__init__() + self._intent = intent + self._request_code = request_code + self._flags = flags + self._id = PendingIntent._next_id + PendingIntent._next_id += 1 + PendingIntent._pending_intents[self._id] = self + + @staticmethod + def getActivity(context, request_code: int, intent: Intent, flags: int) -> "PendingIntent": + pi = PendingIntent(intent, request_code, flags) + pi._type = "activity" + return pi + + @staticmethod + def getBroadcast(context, request_code: int, intent: Intent, flags: int) -> "PendingIntent": + pi = PendingIntent(intent, request_code, flags) + pi._type = "broadcast" + return pi + + @staticmethod + def getService(context, request_code: int, intent: Intent, flags: int) -> "PendingIntent": + pi = PendingIntent(intent, request_code, flags) + pi._type = "service" + return pi + + @staticmethod + def getActivities(context, request_code: int, intents: List[Intent], flags: int) -> "PendingIntent": + pi = PendingIntent(intents[0] if intents else Intent(), request_code, flags) + pi._type = "activities" + pi._intents = intents + return pi + + def send(self): + """Simulate sending the pending intent""" + pass + + def cancel(self): + PendingIntent._pending_intents.pop(self._id, None) + + def getIntent(self) -> Intent: + return self._intent + + def getTargetPackage(self) -> str: + return self._intent.getPackage() or "" + + def toString(self) -> str: + return f"PendingIntent{{{hex(id(self))}}}" + + +# ═══════════════════════════════════════════════════════════════ +# AlarmManager +# ═══════════════════════════════════════════════════════════════ + +class AlarmManager(Stub): + """AlarmManager — 调度定时操作""" + + RTC_WAKEUP = 0 + RTC = 1 + ELAPSED_REALTIME = 3 + ELAPSED_REALTIME_WAKEUP = 2 + INTERVAL_FIFTEEN_MINUTES = 900000 + INTERVAL_HALF_HOUR = 1800000 + INTERVAL_HOUR = 3600000 + INTERVAL_DAY = 86400000 + + def __init__(self): + super().__init__() + self._alarms: Dict[int, Dict] = {} + + def set(self, type_: int, trigger_at_ms: int, operation: PendingIntent): + self._alarms[id(operation)] = { + "type": type_, + "trigger_at": trigger_at_ms, + "operation": operation, + "repeating": False, + } + + def setRepeating(self, type_: int, trigger_at_ms: int, interval_ms: int, operation: PendingIntent): + self._alarms[id(operation)] = { + "type": type_, + "trigger_at": trigger_at_ms, + "interval": interval_ms, + "operation": operation, + "repeating": True, + } + + def setExact(self, type_: int, trigger_at_ms: int, operation: PendingIntent): + self.set(type_, trigger_at_ms, operation) + + def setAndAllowWhileIdle(self, type_: int, trigger_at_ms: int, operation: PendingIntent): + self.set(type_, trigger_at_ms, operation) + + def setExactAndAllowWhileIdle(self, type_: int, trigger_at_ms: int, operation: PendingIntent): + self.set(type_, trigger_at_ms, operation) + + def cancel(self, operation: PendingIntent): + self._alarms.pop(id(operation), None) + + def getNextAlarmClock(self): + return None + + +# ═══════════════════════════════════════════════════════════════ +# NotificationChannel +# ═══════════════════════════════════════════════════════════════ + +class NotificationChannel(Stub): + """Notification channel for Android O+""" + + IMPORTANCE_NONE = 0 + IMPORTANCE_MIN = 1 + IMPORTANCE_LOW = 2 + IMPORTANCE_DEFAULT = 3 + IMPORTANCE_HIGH = 4 + IMPORTANCE_MAX = 5 + IMPORTANCE_UNSPECIFIED = -1000 + + def __init__(self, channel_id: str, name: str, importance: int): + super().__init__() + self._id = channel_id + self._name = name + self._importance = importance + self._description = "" + self._enabled = True + self._show_badge = True + self._sound = None + self._lights = False + self._vibration = True + self._bypass_dnd = False + self._lockscreen_visibility = 0 + self._group = None + self._can_bubble = False + + def getId(self) -> str: + return self._id + + def getName(self) -> str: + return self._name + + def getImportance(self) -> int: + return self._importance + + def setDescription(self, description: str): + self._description = description + + def getDescription(self) -> str: + return self._description + + def setShowBadge(self, show_badge: bool): + self._show_badge = show_badge + + def canShowBadge(self) -> bool: + return self._show_badge + + def enableLights(self, lights: bool): + self._lights = lights + + def shouldShowLights(self) -> bool: + return self._lights + + def enableVibration(self, vibration: bool): + self._vibration = vibration + + def shouldVibrate(self) -> bool: + return self._vibration + + def setBypassDnd(self, bypass_dnd: bool): + self._bypass_dnd = bypass_dnd + + def canBypassDnd(self) -> bool: + return self._bypass_dnd + + def setSound(self, sound: Any, audio_attributes: Any = None): + self._sound = sound + + def getSound(self): + return self._sound + + def setGroup(self, group_id: str): + self._group = group_id + + def getGroup(self) -> Optional[str]: + return self._group + + def setLockScreenVisibility(self, visibility: int): + self._lockscreen_visibility = visibility + + def getLockScreenVisibility(self) -> int: + return self._lockscreen_visibility + + def toString(self) -> str: + return f"NotificationChannel(id={self._id}, name={self._name}, importance={self._importance})" + + +class NotificationChannelGroup(Stub): + """Group of notification channels""" + + def __init__(self, group_id: str, name: str): + super().__init__() + self._id = group_id + self._name = name + self._channels: List[NotificationChannel] = [] + + def getId(self) -> str: + return self._id + + def getName(self) -> str: + return self._name + + def getChannels(self) -> List[NotificationChannel]: + return list(self._channels) + + +# ═══════════════════════════════════════════════════════════════ +# Notification +# ═══════════════════════════════════════════════════════════════ + +class Notification(Stub): + """Android Notification""" + + DEFAULT_ALL = -1 + DEFAULT_SOUND = 1 + DEFAULT_VIBRATE = 2 + DEFAULT_LIGHTS = 4 + EXTRA_TITLE = "android.title" + EXTRA_TEXT = "android.text" + EXTRA_SUB_TEXT = "android.subText" + EXTRA_INFO_TEXT = "android.infoText" + EXTRA_SUMMARY_TEXT = "android.summaryText" + EXTRA_CHANNEL_ID = "android.intent.extra.CHANNEL_ID" + EXTRA_BIG_TEXT = "android.bigText" + EXTRA_PICTURE = "android.picture" + PRIORITY_MIN = -2 + PRIORITY_LOW = -1 + PRIORITY_DEFAULT = 0 + PRIORITY_HIGH = 1 + PRIORITY_MAX = 2 + VISIBILITY_PRIVATE = 0 + VISIBILITY_PUBLIC = 1 + VISIBILITY_SECRET = -1 + + class Builder(Stub): + """Notification builder pattern""" + + def __init__(self, context, channel_id: Optional[str] = None): + super().__init__() + self._context = context + self._channel_id = channel_id or "" + self._title = "" + self._text = "" + self._sub_text = "" + self._info_text = "" + self._summary_text = "" + self._big_text = "" + self._small_icon = 0 + self._large_icon = None + self._color = 0 + self._priority = Notification.PRIORITY_DEFAULT + self._defaults = 0 + self._auto_cancel = False + self._ongoing = False + self._when = 0 + self._number = 0 + self._content_intent = None + self._delete_intent = None + self._full_screen_intent = None + self._ticker = "" + self._visibility = Notification.VISIBILITY_PRIVATE + self._category = "" + self._group = "" + self._group_summary = False + self._public_version = None + self._extras: Dict[str, Any] = {} + self._actions: List[Dict] = [] + self._style = None + self._badge_icon_type = 0 + self._settings_text = None + self._uses_channel_defaults = False + + def setChannelId(self, channel_id: str) -> "Notification.Builder": + self._channel_id = channel_id + return self + + def setContentTitle(self, title: str) -> "Notification.Builder": + self._title = title + return self + + def setContentText(self, text: str) -> "Notification.Builder": + self._text = text + return self + + def setSubText(self, text: str) -> "Notification.Builder": + self._sub_text = text + return self + + def setContentInfo(self, info: str) -> "Notification.Builder": + self._info_text = info + return self + + def setSummaryText(self, text: str) -> "Notification.Builder": + self._summary_text = text + return self + + def setSmallIcon(self, icon: int) -> "Notification.Builder": + self._small_icon = icon + return self + + def setLargeIcon(self, icon: Any) -> "Notification.Builder": + self._large_icon = icon + return self + + def setColor(self, color: int) -> "Notification.Builder": + self._color = color + return self + + def setPriority(self, priority: int) -> "Notification.Builder": + self._priority = priority + return self + + def setDefaults(self, defaults: int) -> "Notification.Builder": + self._defaults = defaults + return self + + def setAutoCancel(self, auto_cancel: bool) -> "Notification.Builder": + self._auto_cancel = auto_cancel + return self + + def setOngoing(self, ongoing: bool) -> "Notification.Builder": + self._ongoing = ongoing + return self + + def setWhen(self, when: int) -> "Notification.Builder": + self._when = when + return self + + def setNumber(self, number: int) -> "Notification.Builder": + self._number = number + return self + + def setContentIntent(self, intent: PendingIntent) -> "Notification.Builder": + self._content_intent = intent + return self + + def setDeleteIntent(self, intent: PendingIntent) -> "Notification.Builder": + self._delete_intent = intent + return self + + def setFullScreenIntent(self, intent: PendingIntent, high_priority: bool) -> "Notification.Builder": + self._full_screen_intent = intent + return self + + def setTicker(self, ticker: str) -> "Notification.Builder": + self._ticker = ticker + return self + + def setVisibility(self, visibility: int) -> "Notification.Builder": + self._visibility = visibility + return self + + def setCategory(self, category: str) -> "Notification.Builder": + self._category = category + return self + + def setGroup(self, group: str) -> "Notification.Builder": + self._group = group + return self + + def setGroupSummary(self, is_group_summary: bool) -> "Notification.Builder": + self._group_summary = is_group_summary + return self + + def setPublicVersion(self, notification: "Notification") -> "Notification.Builder": + self._public_version = notification + return self + + def addAction(self, icon: int, title: str, intent: PendingIntent) -> "Notification.Builder": + self._actions.append({"icon": icon, "title": title, "intent": intent}) + return self + + def setStyle(self, style: Any) -> "Notification.Builder": + self._style = style + return self + + def setBadgeIconType(self, icon_type: int) -> "Notification.Builder": + self._badge_icon_type = icon_type + return self + + def setSettingsText(self, text: str) -> "Notification.Builder": + self._settings_text = text + return self + + def addExtras(self, extras: Dict[str, Any]) -> "Notification.Builder": + if extras: + self._extras.update(extras) + return self + + def extend(self, builder: Any) -> "Notification.Builder": + return self + + def build(self) -> "Notification": + n = Notification() + n._channel_id = self._channel_id + n._title = self._title + n._text = self._text + n._sub_text = self._sub_text + n._info_text = self._info_text + n._summary_text = self._summary_text + n._big_text = self._big_text + n._small_icon = self._small_icon + n._large_icon = self._large_icon + n._color = self._color + n._priority = self._priority + n._defaults = self._defaults + n._auto_cancel = self._auto_cancel + n._ongoing = self._ongoing + n._when = self._when or int(time.time() * 1000) + n._number = self._number + n._content_intent = self._content_intent + n._delete_intent = self._delete_intent + n._full_screen_intent = self._full_screen_intent + n._ticker = self._ticker + n._visibility = self._visibility + n._category = self._category + n._group = self._group + n._group_summary = self._group_summary + n._public_version = self._public_version + n._actions = list(self._actions) + n._style = self._style + n._extras = dict(self._extras) + return n + + def __init__(self): + super().__init__() + self._channel_id = "" + self._title = "" + self._text = "" + self._sub_text = "" + self._info_text = "" + self._summary_text = "" + self._big_text = "" + self._small_icon = 0 + self._large_icon = None + self._color = 0 + self._priority = self.PRIORITY_DEFAULT + self._defaults = 0 + self._auto_cancel = False + self._ongoing = False + self._when = 0 + self._number = 0 + self._content_intent = None + self._delete_intent = None + self._full_screen_intent = None + self._ticker = "" + self._visibility = self.VISIBILITY_PRIVATE + self._category = "" + self._group = "" + self._group_summary = False + self._public_version = None + self._extras: Dict[str, Any] = {} + self._actions: List[Dict] = [] + self._style = None + + def getChannelId(self) -> str: + return self._channel_id + + def toString(self) -> str: + return f"Notification(channel={self._channel_id}, title={self._title})" + + +class NotificationCompat(Stub): + """NotificationCompat — 兼容版本""" + + class Builder(Stub): + def __init__(self, context, channel_id: Optional[str] = None): + super().__init__() + self._builder = Notification.Builder(context, channel_id) + + def setContentTitle(self, title: str) -> "NotificationCompat.Builder": + self._builder.setContentTitle(title) + return self + + def setContentText(self, text: str) -> "NotificationCompat.Builder": + self._builder.setContentText(text) + return self + + def setSmallIcon(self, icon: int) -> "NotificationCompat.Builder": + self._builder.setSmallIcon(icon) + return self + + def setPriority(self, priority: int) -> "NotificationCompat.Builder": + self._builder.setPriority(priority) + return self + + def setAutoCancel(self, auto_cancel: bool) -> "NotificationCompat.Builder": + self._builder.setAutoCancel(auto_cancel) + return self + + def setContentIntent(self, intent: PendingIntent) -> "NotificationCompat.Builder": + self._builder.setContentIntent(intent) + return self + + def setDefaults(self, defaults: int) -> "NotificationCompat.Builder": + self._builder.setDefaults(defaults) + return self + + def build(self) -> Notification: + return self._builder.build() + + +# ═══════════════════════════════════════════════════════════════ +# NotificationManager +# ═══════════════════════════════════════════════════════════════ + +class NotificationManager(Stub): + """NotificationManager — 发送通知""" + + IMPORTANCE_NONE = 0 + IMPORTANCE_MIN = 1 + IMPORTANCE_LOW = 2 + IMPORTANCE_DEFAULT = 3 + IMPORTANCE_HIGH = 4 + IMPORTANCE_MAX = 5 + IMPORTANCE_UNSPECIFIED = -1000 + + def __init__(self): + super().__init__() + self._notifications: Dict[int, Notification] = {} + self._channels: Dict[str, NotificationChannel] = {} + self._groups: Dict[str, NotificationChannelGroup] = {} + self._notification_id_counter = 0 + + def notify(self, id_: int, notification: Notification): + self._notifications[id_] = notification + sys.stderr.write( + f"[NotificationManager] notify id={id_}: " + f"title={notification._title} text={notification._text}\n" + ) + + def notifyAsPackage(self, package_name: str, tag: Optional[str], id_: int, notification: Notification): + self.notify(id_, notification) + + def cancel(self, id_: int): + self._notifications.pop(id_, None) + + def cancelAll(self): + self._notifications.clear() + + def cancelAsPackage(self, package_name: str, tag: Optional[str], id_: int): + self.cancel(id_) + + def createNotificationChannel(self, channel: NotificationChannel): + self._channels[channel.getId()] = channel + sys.stderr.write( + f"[NotificationManager] create channel: {channel.getId()}\n" + ) + + def createNotificationChannels(self, channels: List[NotificationChannel]): + for c in channels: + self.createNotificationChannel(c) + + def getNotificationChannel(self, channel_id: str) -> Optional[NotificationChannel]: + return self._channels.get(channel_id) + + def getNotificationChannels(self) -> List[NotificationChannel]: + return list(self._channels.values()) + + def deleteNotificationChannel(self, channel_id: str): + self._channels.pop(channel_id, None) + + def createNotificationChannelGroup(self, group: NotificationChannelGroup): + self._groups[group.getId()] = group + + def getNotificationChannelGroups(self) -> List[NotificationChannelGroup]: + return list(self._groups.values()) + + def getActiveNotifications(self) -> List[Notification]: + return list(self._notifications.values()) + + def areNotificationsEnabled(self) -> bool: + return True + + def isNotificationPolicyAccessGranted(self) -> bool: + return True + + def matchesCallFilter(self, address: Any) -> bool: + return True + + def toString(self) -> str: + return f"NotificationManager(notifications={len(self._notifications)})" + + +# ═══════════════════════════════════════════════════════════════ +# Dialog / AlertDialog / ProgressDialog / DatePickerDialog / TimePickerDialog +# ═══════════════════════════════════════════════════════════════ + +class Dialog(Stub): + """Base dialog class""" + + def __init__(self, context, theme_res_id: int = 0): + super().__init__() + self._context = context + self._theme_res_id = theme_res_id + self._showing = False + self._cancelable = True + self._on_cancel_listener = None + self._on_dismiss_listener = None + self._on_show_listener = None + self._title = "" + self._window = None + + def show(self): + self._showing = True + sys.stderr.write(f"[Dialog] show: {self.__class__.__name__}\n") + + def dismiss(self): + self._showing = False + sys.stderr.write(f"[Dialog] dismiss: {self.__class__.__name__}\n") + + def isShowing(self) -> bool: + return self._showing + + def cancel(self): + self.dismiss() + if self._on_cancel_listener: + self._on_cancel_listener.onCancel(self) + + def setCancelable(self, flag: bool): + self._cancelable = flag + + def setCanceledOnTouchOutside(self, cancel: bool): + pass + + def setTitle(self, title: str): + self._title = title + + def getContext(self): + return self._context + + def setOnCancelListener(self, listener): + self._on_cancel_listener = listener + + def setOnDismissListener(self, listener): + self._on_dismiss_listener = listener + + def setOnShowListener(self, listener): + self._on_show_listener = listener + + def getWindow(self): + return self._window + + def findViewById(self, id_: int): + return None + + def onBackPressed(self): + if self._cancelable: + self.cancel() + + +class AlertDialog(Dialog): + """Alert dialog with builder pattern""" + + BUTTON_POSITIVE = -1 + BUTTON_NEGATIVE = -2 + BUTTON_NEUTRAL = -3 + + def __init__(self, context, theme_res_id: int = 0): + super().__init__(context, theme_res_id) + self._message = "" + self._buttons: Dict[int, Dict] = {} + self._items: List[str] = [] + self._single_choice_items = None + self._multi_choice_items = None + self._selected_index = -1 + self._selected_indices: List[int] = [] + self._view = None + self._icon = 0 + self._custom_title = None + + class Builder(Stub): + """AlertDialog builder""" + def __init__(self, context, theme_res_id: int = 0): + super().__init__() + self._context = context + self._theme_res_id = theme_res_id + self._title = "" + self._message = "" + self._positive_text = "" + self._positive_listener = None + self._negative_text = "" + self._negative_listener = None + self._neutral_text = "" + self._neutral_listener = None + self._cancelable = True + self._on_cancel_listener = None + self._items: List[str] = [] + self._on_item_click_listener = None + self._single_choice_items = None + self._single_choice_selected = -1 + self._single_choice_listener = None + self._multi_choice_items = None + self._multi_choice_selected = None + self._multi_choice_listener = None + self._icon = 0 + self._view = None + self._custom_title_view = None + + def setTitle(self, title: str) -> "AlertDialog.Builder": + self._title = title + return self + + def setMessage(self, message: str) -> "AlertDialog.Builder": + self._message = message + return self + + def setPositiveButton(self, text: str, listener=None) -> "AlertDialog.Builder": + self._positive_text = text + self._positive_listener = listener + return self + + def setNegativeButton(self, text: str, listener=None) -> "AlertDialog.Builder": + self._negative_text = text + self._negative_listener = listener + return self + + def setNeutralButton(self, text: str, listener=None) -> "AlertDialog.Builder": + self._neutral_text = text + self._neutral_listener = listener + return self + + def setCancelable(self, cancelable: bool) -> "AlertDialog.Builder": + self._cancelable = cancelable + return self + + def setOnCancelListener(self, listener) -> "AlertDialog.Builder": + self._on_cancel_listener = listener + return self + + def setItems(self, items: List[str], listener=None) -> "AlertDialog.Builder": + self._items = list(items) + self._on_item_click_listener = listener + return self + + def setSingleChoiceItems(self, items: List[str], checked_item: int, listener=None) -> "AlertDialog.Builder": + self._single_choice_items = list(items) + self._single_choice_selected = checked_item + self._single_choice_listener = listener + return self + + def setMultiChoiceItems(self, items: List[str], checked_items: List[bool], listener=None) -> "AlertDialog.Builder": + self._multi_choice_items = list(items) + self._multi_choice_selected = checked_items or [] + self._multi_choice_listener = listener + return self + + def setIcon(self, icon: int) -> "AlertDialog.Builder": + self._icon = icon + return self + + def setView(self, view: Any) -> "AlertDialog.Builder": + self._view = view + return self + + def setCustomTitle(self, view: Any) -> "AlertDialog.Builder": + self._custom_title_view = view + return self + + def create(self) -> "AlertDialog": + dialog = AlertDialog(self._context, self._theme_res_id) + dialog._title = self._title + dialog._message = self._message + dialog._cancelable = self._cancelable + dialog._icon = self._icon + dialog._view = self._view + if self._positive_text: + dialog._buttons[AlertDialog.BUTTON_POSITIVE] = { + "text": self._positive_text, + "listener": self._positive_listener, + } + if self._negative_text: + dialog._buttons[AlertDialog.BUTTON_NEGATIVE] = { + "text": self._negative_text, + "listener": self._negative_listener, + } + if self._neutral_text: + dialog._buttons[AlertDialog.BUTTON_NEUTRAL] = { + "text": self._neutral_text, + "listener": self._neutral_listener, + } + dialog._items = list(self._items) + dialog._single_choice_items = self._single_choice_items + dialog._multi_choice_items = self._multi_choice_items + return dialog + + def show(self) -> "AlertDialog": + dialog = self.create() + dialog.show() + return dialog + + +class ProgressDialog(AlertDialog): + """Progress dialog with a progress bar""" + + STYLE_SPINNER = 0 + STYLE_HORIZONTAL = 1 + + def __init__(self, context, theme_res_id: int = 0): + super().__init__(context, theme_res_id) + self._progress_style = ProgressDialog.STYLE_SPINNER + self._progress = 0 + self._max = 100 + self._indeterminate = True + self._progress_number_format = "%d/%d" + self._progress_percent_format = "%d%%" + + def setProgressStyle(self, style: int): + self._progress_style = style + + def setProgress(self, value: int): + self._progress = value + + def getProgress(self) -> int: + return self._progress + + def setMax(self, max_: int): + self._max = max_ + + def getMax(self) -> int: + return self._max + + def setIndeterminate(self, indeterminate: bool): + self._indeterminate = indeterminate + + def isIndeterminate(self) -> bool: + return self._indeterminate + + def incrementProgressBy(self, diff: int): + self._progress = min(self._max, max(0, self._progress + diff)) + + @staticmethod + def show(context, title: str, message: str, indeterminate: bool = True, cancelable: bool = False) -> "ProgressDialog": + dialog = ProgressDialog(context) + dialog.setTitle(title) + dialog._message = message + dialog._indeterminate = indeterminate + dialog.setCancelable(cancelable) + dialog.show() + return dialog + + +class DatePickerDialog(AlertDialog): + """Date picker dialog""" + + def __init__(self, context, listener=None, year: int = 2024, month: int = 0, day_of_month: int = 1, theme_res_id: int = 0): + super().__init__(context, theme_res_id) + self._listener = listener + self._year = year + self._month = month + self._day_of_month = day_of_month + self._date_picker = None + + def getDatePicker(self): + return self._date_picker + + def updateDate(self, year: int, month: int, day_of_month: int): + self._year = year + self._month = month + self._day_of_month = day_of_month + + def onDateChanged(self, view, year: int, month: int, day: int): + self._year = year + self._month = month + self._day_of_month = day + + class OnDateSetListener: + def onDateSet(self, view, year: int, month: int, day_of_month: int): + pass + + +class TimePickerDialog(AlertDialog): + """Time picker dialog""" + + def __init__(self, context, listener=None, hour_of_day: int = 12, minute: int = 0, is24_hour_view: bool = True, theme_res_id: int = 0): + super().__init__(context, theme_res_id) + self._listener = listener + self._hour_of_day = hour_of_day + self._minute = minute + self._is24_hour_view = is24_hour_view + + class OnTimeSetListener: + def onTimeSet(self, view, hour_of_day: int, minute: int): + pass + + +# ═══════════════════════════════════════════════════════════════ +# Fragment / FragmentManager / FragmentTransaction +# ═══════════════════════════════════════════════════════════════ + +class Fragment(Stub): + """Fragment — UI 片段""" + + def __init__(self): + super().__init__() + self._arguments: Optional[Bundle] = None + self._activity = None + self._view = None + self._fragment_manager = None + self._state = 0 + self._tag = None + self._id = -1 + self._container_id = -1 + self._menu = True + self._retain_instance = False + self._target_fragment = None + self._target_request_code = -1 + self._user_visible_hint = True + + def setArguments(self, args: "Bundle"): + self._arguments = args + + def getArguments(self) -> Optional["Bundle"]: + return self._arguments + + def getActivity(self): + return self._activity + + def getContext(self): + return self._activity + + def getFragmentManager(self) -> Optional["FragmentManager"]: + return self._fragment_manager + + def getView(self): + return self._view + + def getResources(self): + if self._activity: + return getattr(self._activity, 'getResources', lambda: None)() + return None + + def getString(self, res_id: int, *args) -> str: + return str(res_id) + + def getTag(self) -> Optional[str]: + return self._tag + + def setId(self, id_: int): + self._id = id_ + + def getId(self) -> int: + return self._id + + def onAttach(self, context): + pass + + def onCreate(self, savedInstanceState: Optional["Bundle"] = None): + pass + + def onCreateView(self, inflater, container, savedInstanceState): + return None + + def onViewCreated(self, view, savedInstanceState: Optional["Bundle"] = None): + pass + + def onStart(self): + pass + + def onResume(self): + pass + + def onPause(self): + pass + + def onStop(self): + pass + + def onDestroyView(self): + pass + + def onDestroy(self): + pass + + def onDetach(self): + pass + + def onActivityCreated(self, savedInstanceState: Optional["Bundle"] = None): + pass + + def onSaveInstanceState(self, out_state: "Bundle"): + pass + + def onViewStateRestored(self, savedInstanceState: Optional["Bundle"] = None): + pass + + def isAdded(self) -> bool: + return self._activity is not None + + def isDetached(self) -> bool: + return self._activity is None + + def isVisible(self) -> bool: + return False + + def isRemoving(self) -> bool: + return False + + def isInLayout(self) -> bool: + return False + + def isResumed(self) -> bool: + return self._state >= 7 + + def setHasOptionsMenu(self, has_menu: bool): + self._menu = has_menu + + def setRetainInstance(self, retain: bool): + self._retain_instance = retain + + def getRetainInstance(self) -> bool: + return self._retain_instance + + def setTargetFragment(self, fragment: "Fragment", request_code: int): + self._target_fragment = fragment + self._target_request_code = request_code + + def getTargetFragment(self) -> Optional["Fragment"]: + return self._target_fragment + + def getTargetRequestCode(self) -> int: + return self._target_request_code + + def setUserVisibleHint(self, is_visible_to_user: bool): + self._user_visible_hint = is_visible_to_user + + def getUserVisibleHint(self) -> bool: + return self._user_visible_hint + + def registerForContextMenu(self, view): + pass + + def unregisterForContextMenu(self, view): + pass + + +class FragmentTransaction(Stub): + """FragmentTransaction — 管理 Fragment 事务""" + + TRANSIT_ENTER_MASK = 0x1000 + TRANSIT_EXIT_MASK = 0x2000 + TRANSIT_FRAGMENT_FADE = 0x1001 + TRANSIT_FRAGMENT_OPEN = 0x1003 + TRANSIT_FRAGMENT_CLOSE = 0x1004 + TRANSIT_NONE = 0 + TRANSIT_UNSET = -1 + + def __init__(self): + super().__init__() + self._ops: List[Dict] = [] + self._transition = FragmentTransaction.TRANSIT_NONE + self._transition_style = 0 + self._allow_state_loss = False + self._commit_allowing_state_loss = False + + def add(self, container_view_id: int, fragment: Fragment, tag: Optional[str] = None) -> "FragmentTransaction": + self._ops.append({"type": "add", "id": container_view_id, "fragment": fragment, "tag": tag}) + return self + + def replace(self, container_view_id: int, fragment: Fragment, tag: Optional[str] = None) -> "FragmentTransaction": + self._ops.append({"type": "replace", "id": container_view_id, "fragment": fragment, "tag": tag}) + return self + + def remove(self, fragment: Fragment) -> "FragmentTransaction": + self._ops.append({"type": "remove", "fragment": fragment}) + return self + + def hide(self, fragment: Fragment) -> "FragmentTransaction": + self._ops.append({"type": "hide", "fragment": fragment}) + return self + + def show(self, fragment: Fragment) -> "FragmentTransaction": + self._ops.append({"type": "show", "fragment": fragment}) + return self + + def detach(self, fragment: Fragment) -> "FragmentTransaction": + self._ops.append({"type": "detach", "fragment": fragment}) + return self + + def attach(self, fragment: Fragment) -> "FragmentTransaction": + self._ops.append({"type": "attach", "fragment": fragment}) + return self + + def addToBackStack(self, name: Optional[str] = None) -> "FragmentTransaction": + self._ops.append({"type": "addToBackStack", "name": name}) + return self + + def setTransition(self, transit: int) -> "FragmentTransaction": + self._transition = transit + return self + + def setTransitionStyle(self, style: int) -> "FragmentTransaction": + self._transition_style = style + return self + + def setCustomAnimations(self, enter: int, exit: int, pop_enter: int = 0, pop_exit: int = 0) -> "FragmentTransaction": + return self + + def disallowAddToBackStack(self) -> "FragmentTransaction": + return self + + def setBreadCrumbShortTitle(self, title: str) -> "FragmentTransaction": + return self + + def setBreadCrumbTitle(self, title: str) -> "FragmentTransaction": + return self + + def commit(self) -> int: + return 0 + + def commitAllowingStateLoss(self) -> int: + return 0 + + def commitNow(self) -> int: + return 0 + + def commitNowAllowingStateLoss(self) -> int: + return 0 + + def isAddToBackStackAllowed(self) -> bool: + return True + + +class FragmentManager(Stub): + """FragmentManager — Fragment 管理器""" + + POP_BACK_STACK_INCLUSIVE = 1 + + def __init__(self): + super().__init__() + self._fragments: Dict[str, Fragment] = {} + self._back_stack: List[Dict] = [] + + def beginTransaction(self) -> FragmentTransaction: + return FragmentTransaction() + + def findFragmentById(self, id_: int) -> Optional[Fragment]: + for f in self._fragments.values(): + if f.getId() == id_: + return f + return None + + def findFragmentByTag(self, tag: str) -> Optional[Fragment]: + return self._fragments.get(tag) + + def popBackStack(self): + if self._back_stack: + self._back_stack.pop() + + def popBackStackImmediate(self, name: str, flags: int) -> bool: + return True + + def getBackStackEntryCount(self) -> int: + return len(self._back_stack) + + def getFragment(self, bundle: "Bundle", key: str) -> Optional[Fragment]: + return None + + def getFragments(self) -> List[Fragment]: + return list(self._fragments.values()) + + def saveFragmentInstanceState(self, fragment: Fragment): + return None + + def isDestroyed(self) -> bool: + return False + + def isStateSaved(self) -> bool: + return False + + def putFragment(self, bundle: "Bundle", key: str, fragment: Fragment): + pass + + def executePendingTransactions(self) -> bool: + return True + + def clearFragmentResult(self, request_key: str): + pass + + def setFragmentResult(self, request_key: str, result: "Bundle"): + pass + + def setFragmentResultListener(self, lifecycle: Any, listener: Any): + pass + + def registerFragmentLifecycleCallbacks(self, cb: Any, recursive: bool): + pass + + def unregisterFragmentLifecycleCallbacks(self, cb: Any): + pass + + +# ═══════════════════════════════════════════════════════════════ +# Activity +# ═══════════════════════════════════════════════════════════════ + +class Activity(Stub): + """Activity — 应用界面入口""" + + # 结果码 + RESULT_OK = -1 + RESULT_CANCELED = 0 + RESULT_FIRST_USER = 1 + + def __init__(self): + super().__init__() + self._created = False + self._started = False + self._resumed = False + self._destroyed = False + self._intent: Optional[Intent] = None + self._callbacks: Dict[int, Tuple[int, Intent]] = {} + self._fragment_manager = FragmentManager() + self._application = None + self._title = "" + self._request_code_counter = 0 + + def onCreate(self, savedInstanceState: Optional["Bundle"] = None): + self._created = True + sys.stderr.write(f"[Activity] onCreate: {self.__class__.__name__}\n") + + def onStart(self): + self._started = True + sys.stderr.write(f"[Activity] onStart: {self.__class__.__name__}\n") + + def onResume(self): + self._resumed = True + sys.stderr.write(f"[Activity] onResume: {self.__class__.__name__}\n") + + def onPause(self): + self._resumed = False + sys.stderr.write(f"[Activity] onPause: {self.__class__.__name__}\n") + + def onStop(self): + self._started = False + sys.stderr.write(f"[Activity] onStop: {self.__class__.__name__}\n") + + def onDestroy(self): + self._destroyed = True + self._created = False + sys.stderr.write(f"[Activity] onDestroy: {self.__class__.__name__}\n") + + def onRestart(self): + sys.stderr.write(f"[Activity] onRestart: {self.__class__.__name__}\n") + + def onBackPressed(self): + sys.stderr.write("[Activity] onBackPressed\n") + + def onSaveInstanceState(self, out_state: "Bundle"): + pass + + def onRestoreInstanceState(self, savedInstanceState: "Bundle"): + pass + + def onNewIntent(self, intent: Intent): + self._intent = intent + + def onActivityResult(self, request_code: int, result_code: int, data: Optional[Intent]): + pass + + def onRequestPermissionsResult(self, request_code: int, permissions: List[str], grant_results: List[int]): + pass + + def setContentView(self, layout_res_id: int): + sys.stderr.write(f"[Activity] setContentView: {layout_res_id}\n") + + def findViewById(self, id_: int) -> Any: + return None + + def startActivity(self, intent: Intent): + sys.stderr.write( + f"[Activity] startActivity: action={intent.getAction()} " + f"pkg={intent.getPackage()}\n" + ) + + def startActivityForResult(self, intent: Intent, request_code: int, options: Optional["Bundle"] = None): + sys.stderr.write( + f"[Activity] startActivityForResult: code={request_code} " + f"action={intent.getAction()}\n" + ) + + def setResult(self, result_code: int, data: Optional[Intent] = None): + sys.stderr.write(f"[Activity] setResult: code={result_code}\n") + + def finish(self): + sys.stderr.write(f"[Activity] finish: {self.__class__.__name__}\n") + self.onPause() + self.onStop() + self.onDestroy() + + def finishActivity(self, request_code: int): + pass + + def getIntent(self) -> Optional[Intent]: + return self._intent + + def setIntent(self, intent: Intent): + self._intent = intent + + def getString(self, res_id: int, *args) -> str: + return str(res_id) + + def getResources(self): + return None + + def getApplication(self): + return self._application + + def getFragmentManager(self) -> FragmentManager: + return self._fragment_manager + + def getSupportFragmentManager(self) -> FragmentManager: + return self._fragment_manager + + def getPackageManager(self): + from .content_pm import PackageManager + return PackageManager() + + def getPackageName(self) -> str: + return _package_name + + def getContentResolver(self): + from .content import ContentResolver + return ContentResolver() + + def getSystemService(self, name: str): + return android_context.getSystemService(name) + + def isFinishing(self) -> bool: + return self._destroyed + + def isDestroyed(self) -> bool: + return self._destroyed + + def recreate(self): + self.onDestroy() + self.onCreate(None) + self.onStart() + self.onResume() + + def getPreferences(self, mode: int): + from .content import SharedPreferences + return SharedPreferences(_package_name + "_preferences") + + def getSharedPreferences(self, name: str, mode: int): + from .content import SharedPreferences + return SharedPreferences(name) + + def getApplicationContext(self): + return android_context + + def getBaseContext(self): + return android_context + + def getCallingActivity(self) -> Optional[ComponentName]: + return None + + def getCallingPackage(self) -> Optional[str]: + return None + + def getTaskId(self) -> int: + return 1 + + def hasWindowFocus(self) -> bool: + return True + + def isInMultiWindowMode(self) -> bool: + return False + + def isInPictureInPictureMode(self) -> bool: + return False + + def moveTaskToBack(self, non_root: bool) -> bool: + return True + + def onLowMemory(self): + pass + + def onTrimMemory(self, level: int): + pass + + def onConfigurationChanged(self, config): + pass + + def onMultiWindowModeChanged(self, is_in_multi_window_mode: bool, new_config): + pass + + def onPictureInPictureModeChanged(self, is_in_pip_mode: bool, new_config): + pass + + +# ═══════════════════════════════════════════════════════════════ +# Service +# ═══════════════════════════════════════════════════════════════ + +class Service(Stub): + """Service — 后台服务""" + + START_CONTINUATION_MASK = 0xF + START_FLAG_REDELIVERY = 1 + START_FLAG_RETRY = 2 + START_NOT_STICKY = 2 + START_REDELIVER_INTENT = 3 + START_STICKY = 1 + START_STICKY_COMPATIBILITY = 0 + STOP_FOREGROUND_DETACH = 1 + STOP_FOREGROUND_REMOVE = 2 + + def __init__(self): + super().__init__() + self._started = False + + def onCreate(self): + self._started = True + sys.stderr.write(f"[Service] onCreate: {self.__class__.__name__}\n") + + def onStartCommand(self, intent: Optional[Intent], flags: int, start_id: int) -> int: + return Service.START_NOT_STICKY + + def onBind(self, intent: Intent): + return None + + def onUnbind(self, intent: Intent) -> bool: + return False + + def onRebind(self, intent: Intent): + pass + + def onDestroy(self): + self._started = False + sys.stderr.write(f"[Service] onDestroy: {self.__class__.__name__}\n") + + def stopSelf(self): + self.onDestroy() + + def stopSelfResult(self, start_id: int) -> bool: + self.onDestroy() + return True + + def startForeground(self, id_: int, notification: Notification): + pass + + def stopForeground(self, flags: int): + pass + + def getApplication(self): + return None + + def getClass(self): + return self.__class__ + + +# ═══════════════════════════════════════════════════════════════ +# Application +# ═══════════════════════════════════════════════════════════════ + +class Application(Stub): + """Application — 应用级别上下文""" + + def __init__(self): + super().__init__() + self._activity_lifecycle_callbacks: List = [] + self._on_low_memory_listeners: List = [] + self._on_trim_memory_listeners: List = [] + + def onCreate(self): + sys.stderr.write(f"[Application] onCreate: {self.__class__.__name__}\n") + + def onTerminate(self): + pass + + def onConfigurationChanged(self, new_config): + pass + + def onLowMemory(self): + pass + + def onTrimMemory(self, level: int): + pass + + def registerActivityLifecycleCallbacks(self, callback): + self._activity_lifecycle_callbacks.append(callback) + + def unregisterActivityLifecycleCallbacks(self, callback): + try: + self._activity_lifecycle_callbacks.remove(callback) + except ValueError: + pass + + def getApplicationContext(self): + return android_context + + def getPackageManager(self): + from .content_pm import PackageManager + return PackageManager() + + def getContentResolver(self): + from .content import ContentResolver + return ContentResolver() + + def getSystemService(self, name: str): + return android_context.getSystemService(name) + + def getSharedPreferences(self, name: str, mode: int): + from .content import SharedPreferences + return SharedPreferences(name) + + def getFilesDir(self): + return os.path.join(_app_data_dir, "files") + + def getCacheDir(self): + return os.path.join(_app_data_dir, "cache") + + def getBaseContext(self): + return android_context + + +# ═══════════════════════════════════════════════════════════════ +# ActivityManager +# ═══════════════════════════════════════════════════════════════ + +class ActivityManager(Stub): + """ActivityManager — 管理 Activity 运行状态""" + + RECENT_IGNORE_UNAVAILABLE = 0x02 + RECENT_WITH_EXCLUDED = 0x01 + MOVE_TASK_WITH_HOME = 0x01 + MOVE_TASK_NO_USER_ACTION = 0x02 + + class RunningAppProcessInfo(Stub): + """Information about a running process""" + IMPORTANCE_FOREGROUND = 100 + IMPORTANCE_VISIBLE = 200 + IMPORTANCE_SERVICE = 300 + IMPORTANCE_BACKGROUND = 400 + IMPORTANCE_EMPTY = 500 + IMPORTANCE_FOREGROUND_SERVICE = 125 + IMPORTANCE_TOP_SLEEPING = 150 + IMPORTANCE_CACHED = 400 + IMPORTANCE_GONE = 1000 + + def __init__(self): + super().__init__() + self.processName = "" + self.pid = 0 + self.uid = 0 + self.importance = self.IMPORTANCE_FOREGROUND + self.lru = 0 + self.importanceReasonCode = 0 + self.importanceReasonPid = 0 + self.importanceReasonComponent = None + self.pkgList: List[str] = [] + + class AppTask(Stub): + """Represents a task managed by ActivityManager""" + def finishAndRemoveTask(self): + pass + def getTaskInfo(self): + return None + def moveToFront(self): + pass + def setExcludeFromRecents(self, exclude: bool): + pass + + class MemoryInfo(Stub): + """Memory information""" + def __init__(self): + super().__init__() + self.availMem = 0 + self.totalMem = 0 + self.threshold = 0 + self.lowMemory = False + + def __init__(self): + super().__init__() + self._memory_info = self.MemoryInfo() + + def getMemoryInfo(self) -> "ActivityManager.MemoryInfo": + return self._memory_info + + def getRunningAppProcesses(self) -> Optional[List["ActivityManager.RunningAppProcessInfo"]]: + return [] + + def killBackgroundProcesses(self, package_name: str): + pass + + def clearApplicationUserData(self) -> bool: + return True + + def getRecentTasks(self, max_num: int, flags: int) -> List: + return [] + + def getAppTasks(self) -> List["ActivityManager.AppTask"]: + return [] + + def moveTaskToFront(self, task_id: int, flags: int): + pass + + def isBackgroundRestricted(self) -> bool: + return False + + def isLowRamDevice(self) -> bool: + return False + + def getLauncherLargeIconSize(self) -> int: + return 48 + + +# ═══════════════════════════════════════════════════════════════ +# TaskStackBuilder +# ═══════════════════════════════════════════════════════════════ + +class TaskStackBuilder(Stub): + """Builder for synthetic back stack""" + + def __init__(self, context): + super().__init__() + self._context = context + self._intents: List[Intent] = [] + + @staticmethod + def create(context) -> "TaskStackBuilder": + return TaskStackBuilder(context) + + def addNextIntent(self, intent: Intent) -> "TaskStackBuilder": + self._intents.append(intent) + return self + + def addNextIntentWithParentStack(self, intent: Intent) -> "TaskStackBuilder": + self._intents.append(intent) + return self + + def addParentStack(self, activity_cls: type) -> "TaskStackBuilder": + return self + + def startActivities(self, options: Optional["Bundle"] = None): + for intent in self._intents: + sys.stderr.write(f"[TaskStackBuilder] start activity: {intent}\n") + + def startActivitiesIfNeeded(self, options: Optional["Bundle"] = None): + self.startActivities(options) + + def getIntent(self, request_code: int) -> Optional[Intent]: + if self._intents: + return self._intents[-1] + return None + + def editIntentAt(self, index: int) -> Optional[Intent]: + if 0 <= index < len(self._intents): + return self._intents[index] + return None + + def getIntentCount(self) -> int: + return len(self._intents) + + +# ═══════════════════════════════════════════════════════════════ +# Bundle (forward reference for Fragment uses) +# ═══════════════════════════════════════════════════════════════ + +from .os import Bundle + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "Intent", + "ComponentName", + "PendingIntent", + "AlarmManager", + "Notification", + "NotificationChannel", + "NotificationChannelGroup", + "NotificationManager", + "NotificationCompat", + "Dialog", + "AlertDialog", + "ProgressDialog", + "DatePickerDialog", + "TimePickerDialog", + "Fragment", + "FragmentManager", + "FragmentTransaction", + "Activity", + "Service", + "Application", + "ActivityManager", + "TaskStackBuilder", +] \ No newline at end of file diff --git a/android_pyapi/android/bluetooth.py b/android_pyapi/android/bluetooth.py new file mode 100644 index 0000000..14c28c5 --- /dev/null +++ b/android_pyapi/android/bluetooth.py @@ -0,0 +1,791 @@ +""" +Android Bluetooth 组件 — BluetoothAdapter, BluetoothDevice, BluetoothGatt 等 +方法签名完全对齐 Android SDK +""" + +import os +import sys +import uuid +from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, + _sdcard_root, _app_data_dir, _package_name, +) + + +# ═══════════════════════════════════════════════════════════════ +# BluetoothProfile +# ═══════════════════════════════════════════════════════════════ + +class BluetoothProfile(Stub): + """BluetoothProfile — 蓝牙配置档案""" + + A2DP = 2 + HEALTH = 3 + HEADSET = 1 + GATT = 7 + GATT_SERVER = 8 + A2DP_SINK = 11 + AVRC = 12 + HEARING_AID = 21 + LE_AUDIO = 22 + LE_AUDIO_BROADCAST = 26 + + STATE_DISCONNECTED = 0 + STATE_CONNECTING = 1 + STATE_CONNECTED = 2 + STATE_DISCONNECTING = 3 + + def getConnectedDevices(self) -> List[Any]: + return [] + + def getDevicesMatchingConnectionState(self, state: int) -> List[Any]: + return [] + + def getConnectionState(self, device: Any) -> int: + return self.STATE_DISCONNECTED + + +class BluetoothProfileServiceListener(Stub): + """BluetoothProfile.ServiceListener""" + + def onServiceConnected(self, profile_id: int, proxy: Any): + pass + + def onServiceDisconnected(self, profile_id: int): + pass + + +# ═══════════════════════════════════════════════════════════════ +# BluetoothClass +# ═══════════════════════════════════════════════════════════════ + +class BluetoothClass(Stub): + """BluetoothClass — 蓝牙设备类别""" + + class Device(Stub): + COMPUTER_DESKTOP = 0x100 + COMPUTER_LAPTOP = 0x10C + PHONE_SMART = 0x200 + PHONE_UNCATEGORIZED = 0x204 + AUDIO_VIDEO_WEARABLE_HEADSET = 0x404 + AUDIO_VIDEO_HANDSFREE = 0x408 + + class Major(Stub): + MISC = 0x0000 + COMPUTER = 0x0100 + PHONE = 0x0200 + NETWORKING = 0x0300 + AUDIO_VIDEO = 0x0400 + PERIPHERAL = 0x0500 + IMAGING = 0x0600 + WEARABLE = 0x0700 + TOY = 0x0800 + HEALTH = 0x0900 + UNCATEGORIZED = 0x1F00 + + def __init__(self): + super().__init__() + self._device_class = 0 + self._major_class = 0 + + def getDeviceClass(self) -> int: + return self._device_class + + def getMajorDeviceClass(self) -> int: + return self._major_class + + def hasService(self, service: int) -> bool: + return False + + def toString(self) -> str: + return f"BluetoothClass(device=0x{self._device_class:04X})" + + +# ═══════════════════════════════════════════════════════════════ +# BluetoothSocket +# ═══════════════════════════════════════════════════════════════ + +class BluetoothSocket(Stub): + """BluetoothSocket — 蓝牙套接字""" + + TYPE_RFCOMM = 1 + TYPE_L2CAP = 3 + TYPE_SCO = 2 + + def __init__(self, type_: int = TYPE_RFCOMM): + super().__init__() + self._type = type_ + self._closed = False + self._connected = False + self._device: Optional["BluetoothDevice"] = None + + def connect(self): + self._connected = True + + def bind(self): + pass + + def getInputStream(self) -> Any: + return None + + def getOutputStream(self) -> Any: + return None + + def close(self): + self._closed = True + self._connected = False + + def getRemoteDevice(self) -> Optional["BluetoothDevice"]: + return self._device + + def getMaxReceivePacketSize(self) -> int: + return 0 + + def isConnected(self) -> bool: + return self._connected + + def isClosed(self) -> bool: + return self._closed + + +class BluetoothServerSocket(Stub): + """BluetoothServerSocket — 蓝牙服务端套接字""" + + def __init__(self): + super().__init__() + self._closed = False + + def accept(self, timeout: int = 0) -> Optional[BluetoothSocket]: + return None + + def close(self): + self._closed = True + + +# ═══════════════════════════════════════════════════════════════ +# BluetoothDevice +# ═══════════════════════════════════════════════════════════════ + +class BluetoothDevice(Stub): + """BluetoothDevice — 蓝牙设备""" + + BOND_NONE = 10 + BOND_BONDING = 11 + BOND_BONDED = 12 + + DEVICE_TYPE_DUAL = 3 + DEVICE_TYPE_LE = 2 + DEVICE_TYPE_BREDR = 1 + DEVICE_TYPE_UNKNOWN = 0 + + ACTION_FOUND = "android.bluetooth.device.action.FOUND" + ACTION_NAME_CHANGED = "android.bluetooth.device.action.NAME_CHANGED" + ACTION_BOND_STATE_CHANGED = "android.bluetooth.device.action.BOND_STATE_CHANGED" + EXTRA_DEVICE = "android.bluetooth.device.extra.DEVICE" + EXTRA_NAME = "android.bluetooth.device.extra.NAME" + EXTRA_RSSI = "android.bluetooth.device.extra.RSSI" + EXTRA_BOND_STATE = "android.bluetooth.device.extra.BOND_STATE" + EXTRA_PREVIOUS_BOND_STATE = "android.bluetooth.device.extra.PREVIOUS_BOND_STATE" + + def __init__(self, address: str = "00:00:00:00:00:00"): + super().__init__() + self._address = address + self._name = "Unknown" + self._bond_state = self.BOND_NONE + self._device_type = self.DEVICE_TYPE_UNKNOWN + + def getAddress(self) -> str: + return self._address + + def getName(self) -> str: + return self._name + + def setName(self, name: str): + self._name = name + + def getBondState(self) -> int: + return self._bond_state + + def setBondState(self, state: int): + self._bond_state = state + + def getType(self) -> int: + return self._device_type + + def untergehende(self) -> bool: + return self._bond_state == self.BOND_BONDED + + def createRfcommSocketToServiceRecord(self, uuid_str: str) -> BluetoothSocket: + sock = BluetoothSocket(BluetoothSocket.TYPE_RFCOMM) + sock._device = self + return sock + + def createInsecureRfcommSocketToServiceRecord(self, uuid_str: str) -> BluetoothSocket: + sock = BluetoothSocket(BluetoothSocket.TYPE_RFCOMM) + sock._device = self + return sock + + def createL2capChannel(self, psm: int) -> BluetoothSocket: + sock = BluetoothSocket(BluetoothSocket.TYPE_L2CAP) + sock._device = self + return sock + + def createInsecureL2capChannel(self, psm: int) -> BluetoothSocket: + sock = BluetoothSocket(BluetoothSocket.TYPE_L2CAP) + sock._device = self + return sock + + def fetchUuidsWithSdp(self) -> bool: + return False + + def uuidEquals(self, uuid_str: str) -> bool: + return False + + def setPairingConfirmation(self, accept: bool): + pass + + def setPin(self, pin: bytes) -> bool: + return True + + def toString(self) -> str: + return f"BluetoothDevice(address={self._address}, name={self._name})" + + +# ═══════════════════════════════════════════════════════════════ +# BluetoothGattDescriptor +# ═══════════════════════════════════════════════════════════════ + +class BluetoothGattDescriptor(Stub): + """BluetoothGattDescriptor — GATT 描述符""" + + ENABLE_NOTIFICATION_VALUE = bytes([0x01, 0x00]) + ENABLE_INDICATION_VALUE = bytes([0x02, 0x00]) + DISABLE_NOTIFICATION_VALUE = bytes([0x00, 0x00]) + + def __init__(self, uuid_str: str, permissions: int = 0): + super().__init__() + self._uuid = uuid_str + self._value: Optional[bytes] = None + self._permissions = permissions + self._characteristic: Optional["BluetoothGattCharacteristic"] = None + + def getUuid(self) -> str: + return self._uuid + + def getValue(self) -> Optional[bytes]: + return self._value + + def setValue(self, value: bytes): + self._value = value + + def getCharacteristic(self) -> Optional["BluetoothGattCharacteristic"]: + return self._characteristic + + def getPermissions(self) -> int: + return self._permissions + + +# ═══════════════════════════════════════════════════════════════ +# BluetoothGattCharacteristic +# ═══════════════════════════════════════════════════════════════ + +class BluetoothGattCharacteristic(Stub): + """BluetoothGattCharacteristic — GATT 特征""" + + PROPERTY_BROADCAST = 1 + PROPERTY_READ = 2 + PROPERTY_WRITE_NO_RESPONSE = 4 + PROPERTY_WRITE = 8 + PROPERTY_NOTIFY = 16 + PROPERTY_INDICATE = 32 + PROPERTY_SIGNED_WRITE = 64 + PROPERTY_EXTENDED_PROPS = 128 + + WRITE_TYPE_NO_RESPONSE = 1 + WRITE_TYPE_DEFAULT = 2 + WRITE_TYPE_SIGNED = 4 + + PERMISSION_READ = 1 + PERMISSION_READ_ENCRYPTED = 2 + PERMISSION_READ_ENCRYPTED_MITM = 4 + PERMISSION_WRITE = 16 + PERMISSION_WRITE_ENCRYPTED = 32 + PERMISSION_WRITE_ENCRYPTED_MITM = 64 + + FORMAT_FLOAT = 0x20 + FORMAT_SFLOAT = 0x10 + FORMAT_SINT16 = 0x02 + FORMAT_SINT32 = 0x04 + FORMAT_SINT8 = 0x01 + FORMAT_UINT16 = 0x12 + FORMAT_UINT32 = 0x14 + FORMAT_UINT8 = 0x11 + + def __init__(self, uuid_str: str, properties: int = 0, permissions: int = 0): + super().__init__() + self._uuid = uuid_str + self._properties = properties + self._permissions = permissions + self._write_type = self.WRITE_TYPE_DEFAULT + self._value: Optional[bytes] = None + self._service: Optional["BluetoothGattService"] = None + self._descriptors: List[BluetoothGattDescriptor] = [] + + def getUuid(self) -> str: + return self._uuid + + def getService(self) -> Optional["BluetoothGattService"]: + return self._service + + def getPermissions(self) -> int: + return self._permissions + + def getProperties(self) -> int: + return self._properties + + def getWriteType(self) -> int: + return self._write_type + + def setWriteType(self, write_type: int): + self._write_type = write_type + + def getValue(self) -> Optional[bytes]: + return self._value + + def setValue(self, value: bytes): + self._value = value + + def getDescriptors(self) -> List[BluetoothGattDescriptor]: + return list(self._descriptors) + + def getDescriptor(self, uuid_str: str) -> Optional[BluetoothGattDescriptor]: + for d in self._descriptors: + if d.getUuid() == uuid_str: + return d + return None + + def addDescriptor(self, descriptor: BluetoothGattDescriptor): + self._descriptors.append(descriptor) + descriptor._characteristic = self + + def getIntValue(self, format_type: int, offset: int) -> Optional[int]: + if self._value is None: + return None + import struct + try: + fmt_map = { + self.FORMAT_UINT8: ("B", 1), self.FORMAT_SINT8: ("b", 1), + self.FORMAT_UINT16: ("H", 2), self.FORMAT_SINT16: ("h", 2), + self.FORMAT_UINT32: ("I", 4), self.FORMAT_SINT32: ("i", 4), + self.FORMAT_FLOAT: ("f", 4), self.FORMAT_SFLOAT: ("e", 2), + } + fmt, size = fmt_map.get(format_type, ("B", 1)) + if offset + size > len(self._value): + return None + val = struct.unpack(fmt, self._value[offset:offset + size])[0] + return int(val) + except Exception: + return None + + +# ═══════════════════════════════════════════════════════════════ +# BluetoothGattService +# ═══════════════════════════════════════════════════════════════ + +class BluetoothGattService(Stub): + """BluetoothGattService — GATT 服务""" + + SERVICE_TYPE_PRIMARY = 0 + SERVICE_TYPE_SECONDARY = 1 + + def __init__(self, uuid_str: str, service_type: int = SERVICE_TYPE_PRIMARY): + super().__init__() + self._uuid = uuid_str + self._type = service_type + self._characteristics: List[BluetoothGattCharacteristic] = [] + self._included_services: List["BluetoothGattService"] = [] + self._device: Optional[BluetoothDevice] = None + + def getUuid(self) -> str: + return self._uuid + + def getType(self) -> int: + return self._type + + def getCharacteristics(self) -> List[BluetoothGattCharacteristic]: + return list(self._characteristics) + + def getCharacteristic(self, uuid_str: str) -> Optional[BluetoothGattCharacteristic]: + for c in self._characteristics: + if c.getUuid() == uuid_str: + return c + return None + + def addCharacteristic(self, characteristic: BluetoothGattCharacteristic): + self._characteristics.append(characteristic) + characteristic._service = self + + def getIncludedServices(self) -> List["BluetoothGattService"]: + return list(self._included_services) + + def addIncludedService(self, service: "BluetoothGattService"): + self._included_services.append(service) + + def getDevice(self) -> Optional[BluetoothDevice]: + return self._device + + +# ═══════════════════════════════════════════════════════════════ +# BluetoothGattCallback +# ═══════════════════════════════════════════════════════════════ + +class BluetoothGattCallback(Stub): + """BluetoothGattCallback — GATT 回调""" + + def onConnectionStateChange(self, gatt: "BluetoothGatt", status: int, new_state: int): + pass + + def onServicesDiscovered(self, gatt: "BluetoothGatt", status: int): + pass + + def onCharacteristicRead(self, gatt: "BluetoothGatt", + characteristic: BluetoothGattCharacteristic, value: bytes, status: int): + pass + + def onCharacteristicWrite(self, gatt: "BluetoothGatt", + characteristic: BluetoothGattCharacteristic, status: int): + pass + + def onDescriptorRead(self, gatt: "BluetoothGatt", + descriptor: BluetoothGattDescriptor, status: int): + pass + + def onDescriptorWrite(self, gatt: "BluetoothGatt", + descriptor: BluetoothGattDescriptor, status: int): + pass + + def onCharacteristicChanged(self, gatt: "BluetoothGatt", + characteristic: BluetoothGattCharacteristic, value: bytes): + pass + + def onReadRemoteRssy(self, gatt: "BluetoothGatt", rssi: int, status: int): + pass + + def onMtuChanged(self, gatt: "BluetoothGatt", mtu: int, status: int): + pass + + def onPhyUpdate(self, gatt: "BluetoothGatt", tx_phy: int, rx_phy: int, status: int): + pass + + def onPhyRead(self, gatt: "BluetoothGatt", tx_phy: int, rx_phy: int, status: int): + pass + + def onServiceChanged(self, gatt: "BluetoothGatt"): + pass + + def onNotificationSent(self, gatt: "BluetoothGatt", status: int): + pass + + def onConnectionUpdated(self, gatt: "BluetoothGatt", interval: int, + latency: int, timeout: int, status: int): + pass + + +# ═══════════════════════════════════════════════════════════════ +# BluetoothGatt +# ═══════════════════════════════════════════════════════════════ + +class BluetoothGatt(Stub): + """BluetoothGatt — GATT 客户端""" + + CONNECTION_STATE_DISCONNECTED = 0 + CONNECTION_STATE_CONNECTING = 1 + CONNECTION_STATE_CONNECTED = 2 + CONNECTION_STATE_DISCONNECTING = 3 + + GATT_SUCCESS = 0 + GATT_FAILURE = 1 + GATT_CONNECTION_CONGESTED = 143 + GATT_INSUFFICIENT_AUTHENTICATION = 5 + GATT_INSUFFICIENT_ENCRYPTION = 15 + GATT_INSUFFICIENT_KEY_SIZE = 12 + GATT_INVALID_ATTRIBUTE_LENGTH = 13 + GATT_REQUEST_NOT_SUPPORTED = 6 + GATT_WRITE_NOT_PERMITTED = 3 + GATT_READ_NOT_PERMITTED = 2 + GATT_WRITE_NO_RESPONSE = 1 + GATT_WRITE_DEFAULT = 0 + + def __init__(self, device: BluetoothDevice): + super().__init__() + self._device = device + self._services: List[BluetoothGattService] = [] + self._connected = False + self._mtu = 23 + + def connect(self) -> bool: + self._connected = True + return True + + def disconnect(self): + self._connected = False + + def close(self): + self._connected = False + self._services.clear() + + def discoverServices(self) -> bool: + return True + + def getServices(self) -> List[BluetoothGattService]: + return list(self._services) + + def getService(self, uuid_str: str) -> Optional[BluetoothGattService]: + for s in self._services: + if s.getUuid() == uuid_str: + return s + return None + + def getConnectedDevices(self) -> List[BluetoothDevice]: + return [self._device] if self._connected else [] + + def getDevicesMatchingConnectionState(self, state: int) -> List[BluetoothDevice]: + if state == self.CONNECTION_STATE_CONNECTED and self._connected: + return [self._device] + return [] + + def readCharacteristic(self, characteristic: BluetoothGattCharacteristic) -> bool: + return True + + def writeCharacteristic(self, characteristic: BluetoothGattCharacteristic) -> bool: + return True + + def readDescriptor(self, descriptor: BluetoothGattDescriptor) -> bool: + return True + + def writeDescriptor(self, descriptor: BluetoothGattDescriptor) -> bool: + return True + + def setCharacteristicNotification(self, characteristic: BluetoothGattCharacteristic, + enable: bool) -> bool: + return True + + def readRemoteRssy(self) -> bool: + return True + + def requestMtu(self, mtu: int) -> bool: + self._mtu = mtu + return True + + def getMtu(self) -> int: + return self._mtu + + def requestConnectionPriority(self, connection_priority: int) -> bool: + return True + + def getDevice(self) -> BluetoothDevice: + return self._device + + +# ═══════════════════════════════════════════════════════════════ +# BluetoothManager +# ═══════════════════════════════════════════════════════════════ + +class BluetoothManager(Stub): + """BluetoothManager — 蓝牙管理器""" + + def __init__(self, context: Any = None): + super().__init__() + self._context = context + + def getAdapter(self) -> Optional["BluetoothAdapter"]: + return BluetoothAdapter.getDefaultAdapter() + + +# ═══════════════════════════════════════════════════════════════ +# BluetoothAdapter +# ═══════════════════════════════════════════════════════════════ + +class BluetoothAdapter(Stub): + """BluetoothAdapter — 蓝牙适配器""" + + STATE_OFF = 10 + STATE_TURNING_ON = 11 + STATE_ON = 12 + STATE_TURNING_OFF = 13 + + ACTION_REQUEST_ENABLE = "android.bluetooth.adapter.action.REQUEST_ENABLE" + ACTION_REQUEST_DISCOVERABLE = "android.bluetooth.adapter.action.REQUEST_DISCOVERABLE" + ACTION_STATE_CHANGED = "android.bluetooth.adapter.action.STATE_CHANGED" + ACTION_DISCOVERY_STARTED = "android.bluetooth.adapter.action.DISCOVERY_STARTED" + ACTION_DISCOVERY_FINISHED = "android.bluetooth.adapter.action.DISCOVERY_FINISHED" + + SCAN_MODE_NONE = 20 + SCAN_MODE_CONNECTABLE = 21 + SCAN_MODE_CONNECTABLE_DISCOVERABLE = 23 + + _default_adapter: Optional["BluetoothAdapter"] = None + + def __init__(self): + super().__init__() + self._enabled = True + self._state = self.STATE_ON + self._address = "00:1A:2B:3C:4D:5E" + self._name = "MockBluetooth" + self._discovering = False + self._bonded_devices: List[BluetoothDevice] = [] + + @staticmethod + def getDefaultAdapter() -> Optional["BluetoothAdapter"]: + if BluetoothAdapter._default_adapter is None: + BluetoothAdapter._default_adapter = BluetoothAdapter() + return BluetoothAdapter._default_adapter + + def isEnabled(self) -> bool: + return self._enabled + + def enable(self) -> bool: + self._enabled = True + self._state = self.STATE_ON + return True + + def disable(self) -> bool: + self._enabled = False + self._state = self.STATE_OFF + return True + + def getAddress(self) -> str: + return self._address + + def getName(self) -> str: + return self._name + + def setName(self, name: str) -> bool: + self._name = name + return True + + def getBondedDevices(self) -> Set[BluetoothDevice]: + return set(self._bonded_devices) + + def startDiscovery(self) -> bool: + self._discovering = True + return True + + def cancelDiscovery(self) -> bool: + self._discovering = False + return True + + def isDiscovering(self) -> bool: + return self._discovering + + @staticmethod + def checkBluetoothAddress(address: str) -> bool: + import re + return bool(re.match(r"^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$", address)) + + def getProfileProxy(self, context: Any, listener: BluetoothProfileServiceListener, + profile_id: int) -> bool: + return True + + def closeProfileProxy(self, profile_id: int, proxy: Any): + pass + + def getState(self) -> int: + return self._state + + def listenUsingRfcommWithServiceRecord(self, name: str, uuid_str: str) -> BluetoothServerSocket: + return BluetoothServerSocket() + + def listenUsingInsecureRfcommWithServiceRecord(self, name: str, + uuid_str: str) -> BluetoothServerSocket: + return BluetoothServerSocket() + + def getRemoteDevice(self, address: str) -> Optional[BluetoothDevice]: + if not BluetoothAdapter.checkBluetoothAddress(address): + return None + return BluetoothDevice(address) + + def getLeScanner(self) -> Any: + from .bluetooth_le import BluetoothLeScanner + return BluetoothLeScanner() + + def toString(self) -> str: + return f"BluetoothAdapter(name={self._name})" + + +# ═══════════════════════════════════════════════════════════════ +# Additional profile stubs +# ═══════════════════════════════════════════════════════════════ + +class BluetoothHeadset(Stub): + pass + + +class BluetoothA2dp(Stub): + pass + + +class BluetoothHealth(Stub): + pass + + +class BluetoothHealthCallback(Stub): + pass + + +class BluetoothHealthAppConfiguration(Stub): + pass + + +class BluetoothCodecConfig(Stub): + pass + + +class BluetoothLeAudio(Stub): + pass + + +class BluetoothLeBroadcast(Stub): + pass + + +class BluetoothLeBroadcastMetadata(Stub): + pass + + +class BluetoothLeBroadcastSubgroup(Stub): + pass + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "BluetoothAdapter", + "BluetoothDevice", + "BluetoothServerSocket", + "BluetoothSocket", + "BluetoothClass", + "BluetoothGatt", + "BluetoothGattCallback", + "BluetoothGattCharacteristic", + "BluetoothGattDescriptor", + "BluetoothGattService", + "BluetoothHeadset", + "BluetoothA2dp", + "BluetoothHealth", + "BluetoothHealthCallback", + "BluetoothHealthAppConfiguration", + "BluetoothProfile", + "BluetoothProfileServiceListener", + "BluetoothManager", + "BluetoothCodecConfig", + "BluetoothLeAudio", + "BluetoothLeBroadcast", + "BluetoothLeBroadcastMetadata", + "BluetoothLeBroadcastSubgroup", +] \ No newline at end of file diff --git a/android_pyapi/android/bluetooth_le.py b/android_pyapi/android/bluetooth_le.py new file mode 100644 index 0000000..0a8d311 --- /dev/null +++ b/android_pyapi/android/bluetooth_le.py @@ -0,0 +1,512 @@ +""" +Android BLE 组件 — BluetoothLeScanner, ScanCallback, ScanFilter 等 +方法签名完全对齐 Android SDK +""" + +import os +import sys +from typing import Any, Dict, List, Optional, Set, Tuple, Union + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, + _sdcard_root, _app_data_dir, _package_name, +) + + +# ═══════════════════════════════════════════════════════════════ +# ScanRecord +# ═══════════════════════════════════════════════════════════════ + +class ScanRecord(Stub): + """ScanRecord — 扫描记录""" + + def __init__(self): + super().__init__() + self._service_uuids: List[str] = [] + self._service_solicitation_uuids: List[str] = [] + self._service_data: Dict[str, bytes] = {} + self._manufacturer_specific_data: Dict[int, bytes] = {} + self._tx_power_level: int = -127 + self._device_name: str = "" + self._advertise_flags: int = 0 + self._bytes_data: bytes = b"" + + def getServiceUuids(self) -> Optional[List[str]]: + return list(self._service_uuids) if self._service_uuids else None + + def getServiceSolicitationUuids(self) -> Optional[List[str]]: + return list(self._service_solicitation_uuids) if self._service_solicitation_uuids else None + + def getServiceData(self) -> Optional[Dict[str, bytes]]: + return dict(self._service_data) if self._service_data else None + + def getServiceDataForService(self, uuid_str: str) -> Optional[bytes]: + return self._service_data.get(uuid_str) + + def getManufacturerSpecificData(self) -> Optional[Dict[int, bytes]]: + return dict(self._manufacturer_specific_data) if self._manufacturer_specific_data else None + + def getTxPowerLevel(self) -> int: + return self._tx_power_level + + def getDeviceName(self) -> Optional[str]: + return self._device_name or None + + def getAdvertiseFlags(self) -> int: + return self._advertise_flags + + def getBytes(self) -> bytes: + return self._bytes_data + + +# ═══════════════════════════════════════════════════════════════ +# ScanFilter +# ═══════════════════════════════════════════════════════════════ + +class ScanFilter(Stub): + """ScanFilter — 扫描过滤器""" + + class Builder(Stub): + def __init__(self): + super().__init__() + self._device_name: Optional[str] = None + self._device_address: Optional[str] = None + self._service_uuid: Optional[str] = None + self._service_data: Optional[bytes] = None + self._manufacturer_id: int = -1 + self._manufacturer_data: Optional[bytes] = None + + def setDeviceName(self, name: str) -> "ScanFilter.Builder": + self._device_name = name + return self + + def setDeviceAddress(self, address: str) -> "ScanFilter.Builder": + self._device_address = address + return self + + def setServiceUuid(self, uuid_str: str) -> "ScanFilter.Builder": + self._service_uuid = uuid_str + return self + + def setServiceData(self, data: bytes) -> "ScanFilter.Builder": + self._service_data = data + return self + + def setManufacturerData(self, manufacturer_id: int, data: bytes) -> "ScanFilter.Builder": + self._manufacturer_id = manufacturer_id + self._manufacturer_data = data + return self + + def build(self) -> "ScanFilter": + return ScanFilter( + device_name=self._device_name, + device_address=self._device_address, + service_uuid=self._service_uuid, + service_data=self._service_data, + manufacturer_id=self._manufacturer_id, + manufacturer_data=self._manufacturer_data, + ) + + def __init__(self, device_name: Optional[str] = None, + device_address: Optional[str] = None, + service_uuid: Optional[str] = None, + service_data: Optional[bytes] = None, + manufacturer_id: int = -1, + manufacturer_data: Optional[bytes] = None): + super().__init__() + self._device_name = device_name + self._device_address = device_address + self._service_uuid = service_uuid + self._service_data = service_data + self._manufacturer_id = manufacturer_id + self._manufacturer_data = manufacturer_data + + +class ScanFilterBuilder(ScanFilter.Builder): + """ScanFilter.Builder 别名""" + pass + + +# ═══════════════════════════════════════════════════════════════ +# ScanSettings +# ═══════════════════════════════════════════════════════════════ + +class ScanSettings(Stub): + """ScanSettings — 扫描设置""" + + SCAN_MODE_OPPORTUNISTIC = -1 + SCAN_MODE_LOW_POWER = 0 + SCAN_MODE_BALANCED = 1 + SCAN_MODE_LOW_LATENCY = 2 + + CALLBACK_TYPE_ALL_MATCHES = 1 + CALLBACK_TYPE_FIRST_MATCH = 2 + CALLBACK_TYPE_MATCH_LOST = 4 + + MATCH_NUM_FEW_CFG = 2 + MATCH_NUM_MAX_CFG = 1 + MATCH_MODE_AGGRESSIVE = 0 + MATCH_MODE_STICKY = 1 + + class Builder(Stub): + def __init__(self): + super().__init__() + self._scan_mode = ScanSettings.SCAN_MODE_LOW_POWER + self._callback_type = ScanSettings.CALLBACK_TYPE_ALL_MATCHES + self._legacy = True + self._phy = 1 + + def setScanMode(self, scan_mode: int) -> "ScanSettings.Builder": + self._scan_mode = scan_mode + return self + + def setCallbackType(self, callback_type: int) -> "ScanSettings.Builder": + self._callback_type = callback_type + return self + + def setLegacy(self, legacy: bool) -> "ScanSettings.Builder": + self._legacy = legacy + return self + + def setPhy(self, phy: int) -> "ScanSettings.Builder": + self._phy = phy + return self + + def build(self) -> "ScanSettings": + return ScanSettings( + scan_mode=self._scan_mode, + callback_type=self._callback_type, + legacy=self._legacy, + phy=self._phy, + ) + + def __init__(self, scan_mode: int = SCAN_MODE_LOW_POWER, + callback_type: int = CALLBACK_TYPE_ALL_MATCHES, + legacy: bool = True, phy: int = 1): + super().__init__() + self._scan_mode = scan_mode + self._callback_type = callback_type + self._legacy = legacy + self._phy = phy + + def getScanMode(self) -> int: + return self._scan_mode + + def getCallbackType(self) -> int: + return self._callback_type + + def getLegacy(self) -> bool: + return self._legacy + + def getPhy(self) -> int: + return self._phy + + +# ═══════════════════════════════════════════════════════════════ +# ScanResult +# ═══════════════════════════════════════════════════════════════ + +class ScanResult(Stub): + """ScanResult — BLE 扫描结果""" + + DATA_COMPLETE = 0 + DATA_TRUNCATED = 2 + PHY_LE_1M = 1 + PHY_LE_2M = 2 + PHY_LE_CODED = 3 + PERIODIC_INTERVAL_NOT_PRESENT = 0 + + def __init__(self, device: Any = None, scan_record: Optional[ScanRecord] = None, + rssi: int = -127, timestamp_nanos: int = 0): + super().__init__() + self._device = device + self._scan_record = scan_record or ScanRecord() + self._rssi = rssi + self._timestamp_nanos = timestamp_nanos + self._primary_phy = self.PHY_LE_1M + self._secondary_phy = 0 + self._advertising_sid = -1 + self._tx_power = -127 + self._periodic_interval = self.PERIODIC_INTERVAL_NOT_PRESENT + self._data_status = self.DATA_COMPLETE + + def getDevice(self) -> Any: + return self._device + + def getScanRecord(self) -> Optional[ScanRecord]: + return self._scan_record + + def getRssi(self) -> int: + return self._rssi + + def getTimestampNanos(self) -> int: + return self._timestamp_nanos + + def getPrimaryPhy(self) -> int: + return self._primary_phy + + def getSecondaryPhy(self) -> int: + return self._secondary_phy + + def getAdvertisingSid(self) -> int: + return self._advertising_sid + + def getTxPower(self) -> int: + return self._tx_power + + def getPeriodicAdvertisingInterval(self) -> int: + return self._periodic_interval + + def getDataStatus(self) -> int: + return self._data_status + + +# ═══════════════════════════════════════════════════════════════ +# ScanCallback +# ═══════════════════════════════════════════════════════════════ + +class ScanCallback(Stub): + """ScanCallback — 扫描回调""" + + SCAN_FAILED_ALREADY_STARTED = 1 + SCAN_FAILED_APPLICATION_REGISTRATION_FAILED = 2 + SCAN_FAILED_INTERNAL_ERROR = 3 + SCAN_FAILED_FEATURE_UNSUPPORTED = 4 + SCAN_FAILED_OUT_OF_HARDWARE_RESOURCES = 5 + SCAN_FAILED_SCANNING_TOO_FREQUENTLY = 6 + + def onScanResult(self, callback_type: int, result: ScanResult): + pass + + def onBatchScanResults(self, results: List[ScanResult]): + pass + + def onScanFailed(self, error_code: int): + pass + + +# ═══════════════════════════════════════════════════════════════ +# BluetoothLeScanner +# ═══════════════════════════════════════════════════════════════ + +class BluetoothLeScanner(Stub): + """BluetoothLeScanner — BLE 扫描器""" + + def __init__(self): + super().__init__() + + def startScan(self, filters: Optional[List[ScanFilter]] = None, + settings: Optional[ScanSettings] = None, + callback: Optional[ScanCallback] = None): + pass + + def startScanWithFilters(self, filters: List[ScanFilter], + callback: ScanCallback): + self.startScan(filters, None, callback) + + def stopScan(self, callback: Optional[ScanCallback] = None): + pass + + def flushPendingScanResults(self, callback: ScanCallback): + pass + + +# ═══════════════════════════════════════════════════════════════ +# AdvertiseData / AdvertiseSettings / AdvertiseCallback +# ═══════════════════════════════════════════════════════════════ + +class AdvertiseData(Stub): + """AdvertiseData — 广播数据""" + + class Builder(Stub): + def __init__(self): + super().__init__() + self._include_device_name = False + self._include_tx_power_level = False + self._service_uuids: List[str] = [] + self._service_data: Dict[str, bytes] = {} + self._manufacturer_data: Dict[int, bytes] = {} + + def setIncludeDeviceName(self, include: bool) -> "AdvertiseData.Builder": + self._include_device_name = include + return self + + def setIncludeTxPowerLevel(self, include: bool) -> "AdvertiseData.Builder": + self._include_tx_power_level = include + return self + + def addServiceUuid(self, uuid_str: str) -> "AdvertiseData.Builder": + self._service_uuids.append(uuid_str) + return self + + def addServiceData(self, uuid_str: str, data: bytes) -> "AdvertiseData.Builder": + self._service_data[uuid_str] = data + return self + + def addManufacturerData(self, manufacturer_id: int, data: bytes) -> "AdvertiseData.Builder": + self._manufacturer_data[manufacturer_id] = data + return self + + def build(self) -> "AdvertiseData": + return AdvertiseData( + include_device_name=self._include_device_name, + include_tx_power_level=self._include_tx_power_level, + service_uuids=self._service_uuids, + service_data=self._service_data, + manufacturer_data=self._manufacturer_data, + ) + + def __init__(self, include_device_name: bool = False, + include_tx_power_level: bool = False, + service_uuids: Optional[List[str]] = None, + service_data: Optional[Dict[str, bytes]] = None, + manufacturer_data: Optional[Dict[int, bytes]] = None): + super().__init__() + self._include_device_name = include_device_name + self._include_tx_power_level = include_tx_power_level + self._service_uuids = service_uuids or [] + self._service_data = service_data or {} + self._manufacturer_data = manufacturer_data or {} + + +class AdvertiseDataBuilder(AdvertiseData.Builder): + pass + + +class AdvertiseSettings(Stub): + """AdvertiseSettings — 广播设置""" + + ADVERTISE_MODE_LOW_POWER = 0 + ADVERTISE_MODE_BALANCED = 1 + ADVERTISE_MODE_LOW_LATENCY = 2 + + ADVERTISE_TX_POWER_ULTRA_LOW = 0 + ADVERTISE_TX_POWER_LOW = 1 + ADVERTISE_TX_POWER_MEDIUM = 2 + ADVERTISE_TX_POWER_HIGH = 3 + + class Builder(Stub): + def __init__(self): + super().__init__() + self._advertise_mode = AdvertiseSettings.ADVERTISE_MODE_LOW_POWER + self._tx_power_level = AdvertiseSettings.ADVERTISE_TX_POWER_MEDIUM + self._connectable = True + self._timeout = 0 + + def setAdvertiseMode(self, mode: int) -> "AdvertiseSettings.Builder": + self._advertise_mode = mode + return self + + def setTxPowerLevel(self, power: int) -> "AdvertiseSettings.Builder": + self._tx_power_level = power + return self + + def setConnectable(self, connectable: bool) -> "AdvertiseSettings.Builder": + self._connectable = connectable + return self + + def setTimeout(self, timeout: int) -> "AdvertiseSettings.Builder": + self._timeout = timeout + return self + + def build(self) -> "AdvertiseSettings": + return AdvertiseSettings( + advertise_mode=self._advertise_mode, + tx_power_level=self._tx_power_level, + connectable=self._connectable, + timeout=self._timeout, + ) + + def __init__(self, advertise_mode: int = ADVERTISE_MODE_LOW_POWER, + tx_power_level: int = ADVERTISE_TX_POWER_MEDIUM, + connectable: bool = True, timeout: int = 0): + super().__init__() + self._advertise_mode = advertise_mode + self._tx_power_level = tx_power_level + self._connectable = connectable + self._timeout = timeout + + def getAdvertiseMode(self) -> int: + return self._advertise_mode + + def getTxPowerLevel(self) -> int: + return self._tx_power_level + + def isConnectable(self) -> bool: + return self._connectable + + def getTimeout(self) -> int: + return self._timeout + + +class AdvertiseCallback(Stub): + """AdvertiseCallback — 广播回调""" + + ADVERTISE_FAILED_DATA_TOO_LARGE = 1 + ADVERTISE_FAILED_TOO_MANY_ADVERTISERS = 2 + ADVERTISE_FAILED_ALREADY_STARTED = 3 + ADVERTISE_FAILED_INTERNAL_ERROR = 4 + ADVERTISE_FAILED_FEATURE_UNSUPPORTED = 5 + + def onStartSuccess(self, settings_in_effect: AdvertiseSettings): + pass + + def onStartFailure(self, error_code: int): + pass + + +class BluetoothLeAdvertiser(Stub): + """BluetoothLeAdvertiser — BLE 广播器""" + + def startAdvertising(self, settings: AdvertiseSettings, + advertise_data: AdvertiseData, + scan_response: Optional[AdvertiseData], + callback: AdvertiseCallback): + try: + callback.onStartSuccess(settings) + except Exception: + pass + + def stopAdvertising(self, callback: AdvertiseCallback): + pass + + +class PeriodicAdvertisingManager(Stub): + pass + + +class PeriodicAdvertisingCallback(Stub): + pass + + +class DistanceMeasurementManager(Stub): + pass + + +class DistanceMeasurementResult(Stub): + pass + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "BluetoothLeScanner", + "ScanCallback", + "ScanResult", + "ScanFilter", + "ScanFilterBuilder", + "ScanSettings", + "ScanRecord", + "BluetoothLeAdvertiser", + "AdvertiseCallback", + "AdvertiseData", + "AdvertiseDataBuilder", + "AdvertiseSettings", + "PeriodicAdvertisingManager", + "PeriodicAdvertisingCallback", + "DistanceMeasurementManager", + "DistanceMeasurementResult", +] \ No newline at end of file diff --git a/android_pyapi/android/content.py b/android_pyapi/android/content.py new file mode 100644 index 0000000..7ec2547 --- /dev/null +++ b/android_pyapi/android/content.py @@ -0,0 +1,1671 @@ +""" +Android Content 组件 — Context, ContentResolver, Uri, SharedPreferences 等 +方法签名完全对齐 Android SDK +""" + +import json +import os +import sys +import threading +from typing import Any, Dict, List, Optional, Set, Tuple, Union +from urllib.parse import urlparse, urlunparse, urlencode, parse_qs, quote, unquote + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, + _sdcard_root, _app_data_dir, _package_name, +) + + +# ═══════════════════════════════════════════════════════════════ +# Uri +# ═══════════════════════════════════════════════════════════════ + +class Uri(Stub): + """Android Uri — 统一资源标识符""" + + def __init__(self, scheme: str = "", authority: str = "", path: str = "", + query: str = "", fragment: str = "", host: str = "", port: int = -1, + ssp: str = "", user_info: str = ""): + super().__init__() + self._scheme = scheme + self._authority = authority + self._path = path + self._query = query + self._fragment = fragment + self._host = host + self._port = port + self._ssp = ssp + self._user_info = user_info + self._opaque = bool(ssp) + self._cached_string: Optional[str] = None + + @staticmethod + def parse(uri_string: str) -> "Uri": + parsed = urlparse(uri_string) + host = parsed.hostname or "" + port = parsed.port or -1 + return Uri( + scheme=parsed.scheme, + authority=parsed.netloc, + path=parsed.path, + query=parsed.query, + fragment=parsed.fragment, + host=host, + port=port, + user_info=parsed.username or "", + ) + + @staticmethod + def fromParts(scheme: str, ssp: str, fragment: str) -> "Uri": + uri = Uri(scheme=scheme, ssp=ssp, fragment=fragment) + uri._opaque = True + return uri + + @staticmethod + def withAppendedPath(base_uri: "Uri", path_segment: str) -> "Uri": + new_path = base_uri._path.rstrip("/") + "/" + path_segment + return Uri( + scheme=base_uri._scheme, + authority=base_uri._authority, + path=new_path, + query=base_uri._query, + fragment=base_uri._fragment, + host=base_uri._host, + port=base_uri._port, + ) + + @staticmethod + def encode(s: str) -> str: + return quote(s, safe=":/?#[]@!$&'()*+,;=-._~") + + @staticmethod + def decode(s: str) -> str: + return unquote(s) + + def buildUpon(self) -> "Uri.Builder": + b = Uri.Builder() + b._scheme = self._scheme + b._authority = self._authority + b._path = self._path + b._query = self._query + b._fragment = self._fragment + return b + + def getScheme(self) -> Optional[str]: + return self._scheme or None + + def getAuthority(self) -> Optional[str]: + return self._authority or None + + def getPath(self) -> Optional[str]: + return self._path or None + + def getQuery(self) -> Optional[str]: + return self._query or None + + def getFragment(self) -> Optional[str]: + return self._fragment or None + + def getHost(self) -> Optional[str]: + return self._host or None + + def getPort(self) -> int: + return self._port + + def getPathSegments(self) -> List[str]: + return [s for s in self._path.split("/") if s] if self._path else [] + + def getLastPathSegment(self) -> Optional[str]: + segments = self.getPathSegments() + return segments[-1] if segments else None + + def getUserInfo(self) -> Optional[str]: + return self._user_info or None + + def isAbsolute(self) -> bool: + return bool(self._scheme) + + def isOpaque(self) -> bool: + return self._opaque + + def isHierarchical(self) -> bool: + return not self._opaque + + def getSchemeSpecificPart(self) -> Optional[str]: + return self._ssp or None + + def normalizeScheme(self) -> "Uri": + if self._scheme: + self._scheme = self._scheme.lower() + return self + + def toString(self) -> str: + if self._cached_string is not None: + return self._cached_string + if self._opaque and self._ssp: + result = f"{self._scheme}:{self._ssp}" + if self._fragment: + result += f"#{self._fragment}" + else: + parts = [] + if self._scheme: + parts.append(f"{self._scheme}:") + if self._authority: + parts.append(f"//{self._authority}") + if self._path: + parts.append(self._path) + if self._query: + parts.append(f"?{self._query}") + if self._fragment: + parts.append(f"#{self._fragment}") + result = "".join(parts) + self._cached_string = result + return result + + def __repr__(self): + return self.toString() + + def __str__(self): + return self.toString() + + def __eq__(self, other): + if isinstance(other, Uri): + return self.toString() == other.toString() + return NotImplemented + + def __hash__(self): + return hash(self.toString()) + + class Builder(Stub): + """Uri builder pattern""" + + def __init__(self): + super().__init__() + self._scheme = "" + self._authority = "" + self._path = "" + self._query = "" + self._fragment = "" + self._host = "" + self._port = -1 + self._segments: List[str] = [] + + def scheme(self, scheme: str) -> "Uri.Builder": + self._scheme = scheme + return self + + def authority(self, authority: str) -> "Uri.Builder": + self._authority = authority + return self + + def path(self, path: str) -> "Uri.Builder": + self._path = path + return self + + def appendPath(self, new_segment: str) -> "Uri.Builder": + self._segments.append(new_segment) + return self + + def query(self, query: str) -> "Uri.Builder": + self._query = query + return self + + def appendQueryParameter(self, key: str, value: str) -> "Uri.Builder": + params = dict(parse_qs(self._query, keep_blank_values=True)) if self._query else {} + if key in params: + params[key].append(value) + else: + params[key] = [value] + self._query = urlencode(params, doseq=True) + return self + + def fragment(self, fragment: str) -> "Uri.Builder": + self._fragment = fragment + return self + + def opaquePart(self, opaque_part: str) -> "Uri.Builder": + return self + + def build(self) -> "Uri": + path = self._path + if self._segments: + path = (path.rstrip("/") if path else "") + "/" + "/".join(self._segments) + return Uri(self._scheme, self._authority, path, self._query, self._fragment) + + +# ═══════════════════════════════════════════════════════════════ +# ContentValues +# ═══════════════════════════════════════════════════════════════ + +class ContentValues(Stub): + """ContentValues — 类似 dict 的内容值容器""" + + def __init__(self, from_dict: Optional[Dict[str, Any]] = None): + super().__init__() + self._values: Dict[str, Any] = dict(from_dict) if from_dict else {} + + def put(self, key: str, value: Any): + self._values[key] = value + + def putNull(self, key: str): + self._values[key] = None + + def get(self, key: str) -> Optional[Any]: + return self._values.get(key) + + def getAsString(self, key: str) -> Optional[str]: + v = self._values.get(key) + return str(v) if v is not None else None + + def getAsInteger(self, key: str) -> Optional[int]: + v = self._values.get(key) + if v is None: + return None + try: + return int(v) + except (ValueError, TypeError): + return None + + def getAsLong(self, key: str) -> Optional[int]: + return self.getAsInteger(key) + + def getAsFloat(self, key: str) -> Optional[float]: + v = self._values.get(key) + if v is None: + return None + try: + return float(v) + except (ValueError, TypeError): + return None + + def getAsDouble(self, key: str) -> Optional[float]: + return self.getAsFloat(key) + + def getAsBoolean(self, key: str) -> Optional[bool]: + v = self._values.get(key) + if v is None: + return None + if isinstance(v, bool): + return v + if isinstance(v, str): + return v.lower() in ("true", "1", "yes", "y") + return bool(v) + + def getAsByteArray(self, key: str) -> Optional[bytes]: + v = self._values.get(key) + if isinstance(v, bytes): + return v + if isinstance(v, str): + return v.encode("utf-8") + return None + + def containsKey(self, key: str) -> bool: + return key in self._values + + def valueSet(self) -> Set[str]: + return set(self._values.keys()) + + def keySet(self) -> Set[str]: + return set(self._values.keys()) + + def size(self) -> int: + return len(self._values) + + def isEmpty(self) -> bool: + return len(self._values) == 0 + + def clear(self): + self._values.clear() + + def remove(self, key: str): + self._values.pop(key, None) + + def putAll(self, other: "ContentValues"): + if other: + self._values.update(other._values) + + def equals(self, other) -> bool: + if isinstance(other, ContentValues): + return self._values == other._values + return False + + def hashCode(self) -> int: + return hash(frozenset(self._values.items())) & 0x7FFFFFFF + + def toString(self) -> str: + return f"ContentValues({self._values})" + + def __getitem__(self, key: str): + return self._values[key] + + def __setitem__(self, key: str, value: Any): + self._values[key] = value + + def __contains__(self, key: str) -> bool: + return key in self._values + + def __len__(self) -> int: + return len(self._values) + + def __repr__(self): + return self.toString() + + +# ═══════════════════════════════════════════════════════════════ +# ContentResolver +# ═══════════════════════════════════════════════════════════════ + +class ContentResolver(Stub): + """ContentResolver — 内容解析器""" + + NOTIFY_SYNC_TO_NETWORK = 1 + NOTIFY_SKIP_NOTIFY_FOR_DESCENDANTS = 2 + + def __init__(self): + super().__init__() + self._observers: Dict[str, List[Any]] = {} + + def query(self, uri: Uri, projection: Optional[List[str]], selection: Optional[str], + selection_args: Optional[List[str]], sort_order: Optional[str], + cancellation_signal: Any = None) -> Any: + """Query content provider""" + sys.stderr.write(f"[ContentResolver] query: uri={uri}\n") + return None + + def insert(self, uri: Uri, values: ContentValues) -> Optional[Uri]: + sys.stderr.write(f"[ContentResolver] insert: uri={uri}\n") + return uri + + def update(self, uri: Uri, values: ContentValues, selection: Optional[str], + selection_args: Optional[List[str]]) -> int: + sys.stderr.write(f"[ContentResolver] update: uri={uri}\n") + return 0 + + def delete(self, uri: Uri, selection: Optional[str], + selection_args: Optional[List[str]]) -> int: + sys.stderr.write(f"[ContentResolver] delete: uri={uri}\n") + return 0 + + def applyBatch(self, authority: str, operations: List[Any]) -> List[Any]: + sys.stderr.write(f"[ContentResolver] applyBatch: authority={authority}\n") + return [] + + def bulkInsert(self, uri: Uri, values: List[ContentValues]) -> int: + sys.stderr.write(f"[ContentResolver] bulkInsert: uri={uri}\n") + return len(values) if values else 0 + + def call(self, uri: Uri, method: str, arg: Optional[str], extras: Optional[ContentValues]) -> Optional[ContentValues]: + return None + + def notifyChange(self, uri: Uri, observer: Any, sync_to_network: bool = False): + uri_str = str(uri) + if uri_str in self._observers: + for obs in list(self._observers[uri_str]): + try: + obs.onChange(True) + except Exception: + pass + + def registerContentObserver(self, uri: Uri, notify_for_descendants: bool, observer: Any): + uri_str = str(uri) + if uri_str not in self._observers: + self._observers[uri_str] = [] + self._observers[uri_str].append(observer) + + def unregisterContentObserver(self, observer: Any): + for uri_str in list(self._observers.keys()): + if observer in self._observers[uri_str]: + self._observers[uri_str].remove(observer) + if not self._observers[uri_str]: + del self._observers[uri_str] + + def getType(self, uri: Uri) -> Optional[str]: + return None + + def acquireContentProviderClient(self, uri: Uri) -> Optional["ContentProviderClient"]: + return ContentProviderClient(uri) + + def acquireUnstableContentProviderClient(self, uri: Uri) -> Optional["ContentProviderClient"]: + return ContentProviderClient(uri) + + def getStreamTypes(self, uri: Uri, mime_type_filter: str) -> Optional[List[str]]: + return None + + def openInputStream(self, uri: Uri) -> Any: + return None + + def openOutputStream(self, uri: Uri) -> Any: + return None + + +# ═══════════════════════════════════════════════════════════════ +# Context +# ═══════════════════════════════════════════════════════════════ + +class Context(Stub): + """Android Context — 应用上下文""" + + # Service 常量 + POWER_SERVICE = "power" + WINDOW_SERVICE = "window" + LAYOUT_INFLATER_SERVICE = "layout_inflater" + ACTIVITY_SERVICE = "activity" + ALARM_SERVICE = "alarm" + NOTIFICATION_SERVICE = "notification" + ACCESSIBILITY_SERVICE = "accessibility" + KEYGUARD_SERVICE = "keyguard" + LOCATION_SERVICE = "location" + SENSOR_SERVICE = "sensor" + STORAGE_SERVICE = "storage" + VIBRATOR_SERVICE = "vibrator" + CONNECTIVITY_SERVICE = "connectivity" + WIFI_SERVICE = "wifi" + AUDIO_SERVICE = "audio" + TELEPHONY_SERVICE = "telephony" + INPUT_METHOD_SERVICE = "input_method" + CAMERA_SERVICE = "camera" + BATTERY_SERVICE = "battery" + + # Mode 常量 + MODE_PRIVATE = 0x0000 + MODE_WORLD_READABLE = 0x0001 + MODE_WORLD_WRITEABLE = 0x0002 + MODE_APPEND = 0x8000 + MODE_MULTI_PROCESS = 0x0004 + + # Flag 常量 + BIND_AUTO_CREATE = 0x0001 + BIND_DEBUG_UNBIND = 0x0002 + BIND_NOT_FOREGROUND = 0x0004 + BIND_ABOVE_CLIENT = 0x0008 + BIND_ALLOW_OOM_MANAGEMENT = 0x0010 + BIND_WAIVE_PRIORITY = 0x0020 + BIND_IMPORTANT = 0x0040 + BIND_ADJUST_WITH_ACTIVITY = 0x0080 + + def __init__(self): + super().__init__() + self._package_name = _package_name + self._services: Dict[str, Any] = {} + self._shared_prefs: Dict[str, "SharedPreferences"] = {} + self._registered_receivers: List[Dict] = [] + self._content_resolver = ContentResolver() + + def getPackageName(self) -> str: + return self._package_name + + def getFilesDir(self): + return os.path.join(_app_data_dir, "files") + + def getCacheDir(self): + return os.path.join(_app_data_dir, "cache") + + def getCodeCacheDir(self): + return os.path.join(_app_data_dir, "code_cache") + + def getNoBackupFilesDir(self): + return os.path.join(_app_data_dir, "no_backup") + + def getExternalFilesDir(self, type_: Optional[str] = None) -> str: + base = os.path.join(_sdcard_root, "Android", "data", self._package_name, "files") + if type_: + base = os.path.join(base, type_) + os.makedirs(base, exist_ok=True) + return base + + def getExternalCacheDir(self): + base = os.path.join(_sdcard_root, "Android", "data", self._package_name, "cache") + os.makedirs(base, exist_ok=True) + return base + + def getObbDir(self): + base = os.path.join(_sdcard_root, "Android", "obb", self._package_name) + os.makedirs(base, exist_ok=True) + return base + + def getDataDir(self): + return _app_data_dir + + def getPackageCodePath(self) -> str: + return os.path.join(_app_data_dir, "base.apk") + + def getPackageResourcePath(self) -> str: + return os.path.join(_app_data_dir, "base.apk") + + def startActivity(self, intent: Any): + sys.stderr.write(f"[Context] startActivity: {intent}\n") + + def startActivities(self, intents: List[Any], options: Optional[Any] = None): + for intent in intents: + self.startActivity(intent) + + def sendBroadcast(self, intent: Any): + sys.stderr.write(f"[Context] sendBroadcast: {intent}\n") + for receiver in self._registered_receivers: + if self._matches_intent_filter(intent, receiver.get("filter")): + try: + receiver["receiver"].onReceive(self, intent) + except Exception as e: + sys.stderr.write(f"[Context] broadcast error: {e}\n") + + def sendOrderedBroadcast(self, intent: Any, receiver_permission: Optional[str] = None): + self.sendBroadcast(intent) + + def sendStickyBroadcast(self, intent: Any): + self.sendBroadcast(intent) + + def registerReceiver(self, receiver: Optional[Any], filter: Any) -> Optional[Any]: + if receiver: + self._registered_receivers.append({"receiver": receiver, "filter": filter}) + return receiver + + def unregisterReceiver(self, receiver: Any): + self._registered_receivers = [ + r for r in self._registered_receivers + if r["receiver"] is not receiver + ] + + def _matches_intent_filter(self, intent: Any, intent_filter: Any) -> bool: + if intent_filter is None: + return True + action = getattr(intent, "getAction", lambda: None)() + if intent_filter._action and action != intent_filter._action: + return False + return True + + def getContentResolver(self) -> ContentResolver: + return self._content_resolver + + def getSharedPreferences(self, name: str, mode: int = MODE_PRIVATE) -> "SharedPreferences": + if name not in self._shared_prefs: + self._shared_prefs[name] = SharedPreferences(name) + return self._shared_prefs[name] + + def getPackageManager(self): + from .content_pm import PackageManager + return PackageManager() + + def getResources(self): + return None + + def getAssets(self): + return None + + def getMainLooper(self): + from .os import Looper + return Looper.getMainLooper() + + def getApplicationContext(self): + return self + + def getSystemService(self, name: str) -> Any: + if name == Context.ACTIVITY_SERVICE: + from .app import ActivityManager + return ActivityManager() + if name == Context.ALARM_SERVICE: + from .app import AlarmManager + return AlarmManager() + if name == Context.NOTIFICATION_SERVICE: + from .app import NotificationManager + return NotificationManager() + if name == Context.VIBRATOR_SERVICE: + from .os import Vibrator + return Vibrator() + if name == Context.POWER_SERVICE: + from .os import PowerManager + return PowerManager() + if name == Context.LOCATION_SERVICE: + from .location import LocationManager + return LocationManager() + if name == Context.SENSOR_SERVICE: + from .hardware import SensorManager + return SensorManager() + if name == Context.CONNECTIVITY_SERVICE: + from .net import ConnectivityManager + return ConnectivityManager() + if name == Context.WIFI_SERVICE: + from .net_wifi import WifiManager + return WifiManager() + if name == Context.AUDIO_SERVICE: + from .media import AudioManager + return AudioManager() + if name == Context.TELEPHONY_SERVICE: + from .telephony import TelephonyManager + return TelephonyManager() + if name == Context.INPUT_METHOD_SERVICE: + from .view_inputmethod import InputMethodManager + return InputMethodManager() + if name == Context.CAMERA_SERVICE: + from .hardware_camera2 import CameraManager + return CameraManager() + if name == Context.BATTERY_SERVICE: + from .os import BatteryManager + return BatteryManager() + return self._services.get(name) + + def startService(self, intent: Any) -> Optional[Any]: + sys.stderr.write(f"[Context] startService: {intent}\n") + return None + + def stopService(self, intent: Any) -> bool: + return True + + def bindService(self, intent: Any, conn: Any, flags: int) -> bool: + sys.stderr.write(f"[Context] bindService: {intent}\n") + return True + + def unbindService(self, conn: Any): + pass + + def getString(self, res_id: int, *args) -> str: + return str(res_id) + + def getColor(self, color_id: int) -> int: + return 0 + + def getDrawable(self, drawable_id: int): + return None + + def getWallpaper(self): + return None + + def getWallpaperDesiredMinimumWidth(self) -> int: + return 1080 + + def getWallpaperDesiredMinimumHeight(self) -> int: + return 1920 + + def checkCallingPermission(self, permission: str) -> int: + from .content_pm import PackageManager + return PackageManager.PERMISSION_GRANTED + + def checkSelfPermission(self, permission: str) -> int: + from .content_pm import PackageManager + return PackageManager.PERMISSION_GRANTED + + def shouldShowRequestPermissionRationale(self, permission: str) -> bool: + return False + + def enforcePermission(self, permission: str, pid: int, uid: int, message: Optional[str]): + pass + + def createPackageContext(self, package_name: str, flags: int) -> "Context": + ctx = Context() + ctx._package_name = package_name + return ctx + + def isDeviceProtectedStorage(self) -> bool: + return False + + def isCredentialProtectedStorage(self) -> bool: + return False + + def deleteFile(self, name: str) -> bool: + path = os.path.join(self.getFilesDir(), name) + try: + os.remove(path) + return True + except OSError: + return False + + def fileList(self) -> List[str]: + try: + return os.listdir(self.getFilesDir()) + except OSError: + return [] + + def getDatabasePath(self, name: str): + path = os.path.join(_app_data_dir, "databases", name) + os.makedirs(os.path.dirname(path), exist_ok=True) + return path + + def databaseList(self) -> List[str]: + db_dir = os.path.join(_app_data_dir, "databases") + try: + return [f for f in os.listdir(db_dir) if f.endswith(".db")] + except OSError: + return [] + + def deleteDatabase(self, name: str) -> bool: + db_path = os.path.join(_app_data_dir, "databases", name) + try: + os.remove(db_path) + return True + except OSError: + return False + + def getDir(self, name: str, mode: int) -> str: + path = os.path.join(_app_data_dir, name) + os.makedirs(path, exist_ok=True) + return path + + def toString(self) -> str: + return f"Context{{{self._package_name}}}" + + +class ContextWrapper(Context): + """ContextWrapper — Context 的包装器""" + + def __init__(self, base: Context): + super().__init__() + self._base = base + + def getBaseContext(self) -> Context: + return self._base + + def getPackageName(self) -> str: + return self._base.getPackageName() + + def getFilesDir(self): + return self._base.getFilesDir() + + def getCacheDir(self): + return self._base.getCacheDir() + + def startActivity(self, intent: Any): + self._base.startActivity(intent) + + def sendBroadcast(self, intent: Any): + self._base.sendBroadcast(intent) + + def getContentResolver(self) -> ContentResolver: + return self._base.getContentResolver() + + def getSharedPreferences(self, name: str, mode: int) -> "SharedPreferences": + return self._base.getSharedPreferences(name, mode) + + def getSystemService(self, name: str) -> Any: + return self._base.getSystemService(name) + + def startService(self, intent: Any) -> Optional[Any]: + return self._base.startService(intent) + + def bindService(self, intent: Any, conn: Any, flags: int) -> bool: + return self._base.bindService(intent, conn, flags) + + def registerReceiver(self, receiver: Optional[Any], filter: Any) -> Optional[Any]: + return self._base.registerReceiver(receiver, filter) + + def unregisterReceiver(self, receiver: Any): + self._base.unregisterReceiver(receiver) + + +# ═══════════════════════════════════════════════════════════════ +# IntentFilter +# ═══════════════════════════════════════════════════════════════ + +class IntentFilter(Stub): + """IntentFilter — 描述 Intent 匹配规则""" + + MATCH_CATEGORY_EMPTY = 0x100000 + MATCH_CATEGORY_HOST = 0x200000 + MATCH_CATEGORY_PORT = 0x400000 + MATCH_CATEGORY_PATH = 0x800000 + MATCH_CATEGORY_SCHEME = 0x1000000 + MATCH_CATEGORY_SCHEME_SPECIFIC_PART = 0x2000000 + MATCH_CATEGORY_TYPE = 0x4000000 + NO_MATCH_ACTION = -3 + NO_MATCH_CATEGORY = -4 + NO_MATCH_DATA = -5 + NO_MATCH_TYPE = -6 + + def __init__(self, action: Optional[str] = None): + super().__init__() + self._action = action + self._actions: List[str] = [] + self._categories: List[str] = [] + self._data_schemes: List[str] = [] + self._data_authorities: List[str] = [] + self._data_paths: List[str] = [] + self._data_types: List[str] = [] + self._priority = 0 + if action: + self.addAction(action) + + def addAction(self, action: str): + if action not in self._actions: + self._actions.append(action) + + def addCategory(self, category: str): + if category not in self._categories: + self._categories.append(category) + + def addDataScheme(self, scheme: str): + if scheme not in self._data_schemes: + self._data_schemes.append(scheme) + + def addDataAuthority(self, host: str, port: int = -1): + auth = f"{host}:{port}" if port >= 0 else host + if auth not in self._data_authorities: + self._data_authorities.append(auth) + + def addDataPath(self, path: str, pattern_type: int = 0): + if path not in self._data_paths: + self._data_paths.append(path) + + def addDataType(self, type_: str): + if type_ not in self._data_types: + self._data_types.append(type_) + + def hasAction(self, action: str) -> bool: + return action in self._actions + + def hasCategory(self, category: str) -> bool: + return category in self._categories + + def hasDataScheme(self, scheme: str) -> bool: + return scheme in self._data_schemes + + def countActions(self) -> int: + return len(self._actions) + + def getAction(self, index: int) -> str: + return self._actions[index] + + def setPriority(self, priority: int): + self._priority = priority + + def getPriority(self) -> int: + return self._priority + + def match(self, action: str, type_: Optional[str], scheme: Optional[str], + data: Optional[Any], categories: Optional[Set[str]], tag: str) -> int: + if action and action not in self._actions: + return self.NO_MATCH_ACTION + return self.MATCH_CATEGORY_EMPTY + + def matchAction(self, action: str) -> bool: + return action in self._actions + + def matchCategories(self, categories: Set[str]) -> Optional[str]: + return None + + def matchData(self, type_: str, scheme: str, data: Any) -> int: + return self.MATCH_CATEGORY_EMPTY + + def dump(self, du: Any, prefix: str): + pass + + def describeContents(self) -> int: + return 0 + + def toString(self) -> str: + return f"IntentFilter(actions={self._actions})" + + +# ═══════════════════════════════════════════════════════════════ +# BroadcastReceiver +# ═══════════════════════════════════════════════════════════════ + +class BroadcastReceiver(Stub): + """BroadcastReceiver — 广播接收器""" + + RESULT_OK = -1 + RESULT_CANCELED = 0 + RESULT_REDIRECT = 1 + + def __init__(self): + super().__init__() + self._result_code = self.RESULT_OK + self._result_data = "" + self._result_extras: Optional[ContentValues] = None + self._ordered = False + self._initial_sticky = False + + def onReceive(self, context: Context, intent: Any): + """Override this method to handle broadcasts""" + pass + + def setResultCode(self, code: int): + self._result_code = code + + def getResultCode(self) -> int: + return self._result_code + + def setResultData(self, data: str): + self._result_data = data + + def getResultData(self) -> str: + return self._result_data + + def setResult(self, code: int, data: str, extras: Optional[ContentValues]): + self._result_code = code + self._result_data = data + self._result_extras = extras + + def setResultExtras(self, extras: ContentValues): + self._result_extras = extras + + def getResultExtras(self, make_map: bool) -> Optional[ContentValues]: + return self._result_extras + + def abortBroadcast(self): + self._result_code = self.RESULT_CANCELED + + def isOrderedBroadcast(self) -> bool: + return self._ordered + + def isInitialStickyBroadcast(self) -> bool: + return self._initial_sticky + + def getDebugUnregister(self) -> bool: + return False + + def toString(self) -> str: + return f"BroadcastReceiver@{hex(id(self))}" + + +# ═══════════════════════════════════════════════════════════════ +# SharedPreferences / SharedPreferencesEditor +# ═══════════════════════════════════════════════════════════════ + +_SHARED_PREFS_DIR = os.path.join(_app_data_dir, "shared_prefs") +os.makedirs(_SHARED_PREFS_DIR, exist_ok=True) + +class SharedPreferences(Stub): + """SharedPreferences — JSON 文件实现的持久化键值存储""" + + def __init__(self, name: str): + super().__init__() + self._name = name + self._lock = threading.Lock() + self._file_path = os.path.join(_SHARED_PREFS_DIR, f"{name}.json") + self._data: Dict[str, Any] = {} + self._load() + + def _load(self): + try: + if os.path.exists(self._file_path): + with open(self._file_path, "r", encoding="utf-8") as f: + self._data = json.load(f) + else: + self._data = {} + except (json.JSONDecodeError, OSError): + self._data = {} + + def _save(self): + with self._lock: + os.makedirs(os.path.dirname(self._file_path), exist_ok=True) + with open(self._file_path, "w", encoding="utf-8") as f: + json.dump(self._data, f, indent=2, ensure_ascii=False) + + def getString(self, key: str, def_value: Optional[str] = None) -> Optional[str]: + v = self._data.get(key) + return str(v) if v is not None else def_value + + def getInt(self, key: str, def_value: int = 0) -> int: + v = self._data.get(key) + if isinstance(v, int) or isinstance(v, float): + return int(v) + return def_value + + def getLong(self, key: str, def_value: int = 0) -> int: + return self.getInt(key, def_value) + + def getFloat(self, key: str, def_value: float = 0.0) -> float: + v = self._data.get(key) + if isinstance(v, (int, float)): + return float(v) + return def_value + + def getBoolean(self, key: str, def_value: bool = False) -> bool: + v = self._data.get(key) + if isinstance(v, bool): + return v + if isinstance(v, str): + return v.lower() in ("true", "1", "yes") + return def_value + + def getAll(self) -> Dict[str, Any]: + return dict(self._data) + + def contains(self, key: str) -> bool: + return key in self._data + + def edit(self) -> "SharedPreferencesEditor": + return SharedPreferencesEditor(self) + + def registerOnSharedPreferenceChangeListener(self, listener): + pass + + def unregisterOnSharedPreferenceChangeListener(self, listener): + pass + + def getSharedPrefsFile(self): + return self._file_path + + def toString(self) -> str: + return f"SharedPreferences({self._name})" + + +class SharedPreferencesEditor(Stub): + """SharedPreferences Editor""" + + def __init__(self, prefs: SharedPreferences): + super().__init__() + self._prefs = prefs + self._modified: Dict[str, Any] = {} + self._removed: Set[str] = set() + self._clear_all = False + + def putString(self, key: str, value: str) -> "SharedPreferencesEditor": + self._modified[key] = value + self._removed.discard(key) + return self + + def putInt(self, key: str, value: int) -> "SharedPreferencesEditor": + self._modified[key] = value + self._removed.discard(key) + return self + + def putLong(self, key: str, value: int) -> "SharedPreferencesEditor": + self._modified[key] = value + self._removed.discard(key) + return self + + def putFloat(self, key: str, value: float) -> "SharedPreferencesEditor": + self._modified[key] = value + self._removed.discard(key) + return self + + def putBoolean(self, key: str, value: bool) -> "SharedPreferencesEditor": + self._modified[key] = value + self._removed.discard(key) + return self + + def remove(self, key: str) -> "SharedPreferencesEditor": + self._removed.add(key) + self._modified.pop(key, None) + return self + + def clear(self) -> "SharedPreferencesEditor": + self._clear_all = True + self._modified.clear() + self._removed.clear() + return self + + def apply(self): + """异步保存""" + self.commit() + + def commit(self) -> bool: + try: + if self._clear_all: + self._prefs._data.clear() + for key in self._removed: + self._prefs._data.pop(key, None) + self._prefs._data.update(self._modified) + self._prefs._save() + self._modified.clear() + self._removed.clear() + self._clear_all = False + return True + except Exception: + return False + + +# ═══════════════════════════════════════════════════════════════ +# ComponentName +# ═══════════════════════════════════════════════════════════════ + +class ComponentName(Stub): + """ComponentName — 标识包中的特定组件""" + + def __init__(self, pkg: str, cls: str): + super().__init__() + self._package = pkg + self._classname = cls + + def getPackageName(self) -> str: + return self._package + + def getClassName(self) -> str: + return self._classname + + def getShortClassName(self) -> str: + return self._classname.split(".")[-1] if "." in self._classname else self._classname + + def flattenToString(self) -> str: + return f"{self._package}/{self._classname}" + + def flattenToShortString(self) -> str: + return f"{self._package}/{self.getShortClassName()}" + + @staticmethod + def unflattenFromString(str_: str) -> Optional["ComponentName"]: + if "/" in str_: + parts = str_.split("/", 1) + return ComponentName(parts[0], parts[1]) + return None + + def toString(self) -> str: + return f"ComponentInfo{{{self._package}/{self._classname}}}" + + def __repr__(self): + return self.toString() + + +# ═══════════════════════════════════════════════════════════════ +# ClipData / ClipDescription +# ═══════════════════════════════════════════════════════════════ + +class ClipDescription(Stub): + """ClipDescription — 描述剪贴板数据""" + + MIMETYPE_TEXT_PLAIN = "text/plain" + MIMETYPE_TEXT_HTML = "text/html" + MIMETYPE_TEXT_URILIST = "text/uri-list" + MIMETYPE_TEXT_INTENT = "text/vnd.android.intent" + + def __init__(self, label: str, mime_types: List[str]): + super().__init__() + self._label = label + self._mime_types = list(mime_types) + self._timestamp = 0 + + def getLabel(self) -> str: + return self._label + + def getMimeType(self, index: int) -> str: + if 0 <= index < len(self._mime_types): + return self._mime_types[index] + return "" + + def getMimeTypeCount(self) -> int: + return len(self._mime_types) + + def filterMimeTypes(self, mime_type: str) -> bool: + return mime_type in self._mime_types + + def compareMimeTypes(self, mime_type1: str, mime_type2: str) -> bool: + return mime_type1 == mime_type2 + + def getTimestamp(self) -> int: + return self._timestamp + + def toString(self) -> str: + return f"ClipDescription({self._label}, {self._mime_types})" + + +class ClipData(Stub): + """ClipData — 剪贴板数据""" + + def __init__(self, description: ClipDescription, item: "ClipData.Item"): + super().__init__() + self._description = description + self._items: List["ClipData.Item"] = [item] if item else [] + + class Item(Stub): + """单个剪贴板条目""" + def __init__(self, text: Optional[str] = None, intent: Optional[Any] = None, uri: Optional[Uri] = None): + super().__init__() + self._text = text + self._intent = intent + self._uri = uri + self._html_text = None + + def getText(self) -> Optional[str]: + return self._text + + def getIntent(self): + return self._intent + + def getUri(self) -> Optional[Uri]: + return self._uri + + def getHtmlText(self) -> Optional[str]: + return self._html_text + + def setHtmlText(self, html_text: str): + self._html_text = html_text + + def coerceToText(self, context: Context) -> str: + if self._text: + return self._text + if self._uri: + return str(self._uri) + if self._intent: + return str(self._intent) + return "" + + def coerceToHtmlText(self, context: Context) -> Optional[str]: + return self._html_text + + def toString(self) -> str: + return f"ClipData.Item({self._text})" + + @staticmethod + def newPlainText(label: str, text: str) -> "ClipData": + desc = ClipDescription(label, [ClipDescription.MIMETYPE_TEXT_PLAIN]) + return ClipData(desc, ClipData.Item(text=text)) + + @staticmethod + def newUri(cr: ContentResolver, label: str, uri: Uri) -> "ClipData": + desc = ClipDescription(label, [ClipDescription.MIMETYPE_TEXT_URILIST]) + return ClipData(desc, ClipData.Item(uri=uri)) + + @staticmethod + def newIntent(label: str, intent: Any) -> "ClipData": + desc = ClipDescription(label, [ClipDescription.MIMETYPE_TEXT_INTENT]) + return ClipData(desc, ClipData.Item(intent=intent)) + + def getDescription(self) -> ClipDescription: + return self._description + + def addItem(self, item: "ClipData.Item"): + self._items.append(item) + + def getItemAt(self, index: int) -> Optional["ClipData.Item"]: + if 0 <= index < len(self._items): + return self._items[index] + return None + + def getItemCount(self) -> int: + return len(self._items) + + def toString(self) -> str: + return f"ClipData({self._description})" + + +# ═══════════════════════════════════════════════════════════════ +# ContentProvider / ContentProviderClient +# ═══════════════════════════════════════════════════════════════ + +class ContentProvider(Stub): + """ContentProvider — 内容提供者基类""" + + def __init__(self): + super().__init__() + self._context: Optional[Context] = None + self._calling_package = "" + + def onCreate(self) -> bool: + return True + + def query(self, uri: Uri, projection: Optional[List[str]], selection: Optional[str], + selection_args: Optional[List[str]], sort_order: Optional[str]) -> Optional[Any]: + return None + + def insert(self, uri: Uri, values: ContentValues) -> Optional[Uri]: + return None + + def update(self, uri: Uri, values: ContentValues, selection: Optional[str], + selection_args: Optional[List[str]]) -> int: + return 0 + + def delete(self, uri: Uri, selection: Optional[str], selection_args: Optional[List[str]]) -> int: + return 0 + + def getType(self, uri: Uri) -> Optional[str]: + return None + + def getStreamTypes(self, uri: Uri, mime_type_filter: str) -> Optional[List[str]]: + return None + + def openFile(self, uri: Uri, mode: str) -> Any: + return None + + def openAssetFile(self, uri: Uri, mode: str) -> Any: + return None + + def attachInfo(self, context: Context, info: Any): + self._context = context + + def getContext(self) -> Optional[Context]: + return self._context + + def getCallingPackage(self) -> str: + return self._calling_package + + def applyBatch(self, operations: List[Any]) -> List[Any]: + return [] + + def bulkInsert(self, uri: Uri, values: List[ContentValues]) -> int: + return len(values) if values else 0 + + def isTemporary(self) -> bool: + return False + + def shutdown(self): + pass + + def toString(self) -> str: + return f"ContentProvider@{hex(id(self))}" + + +class ContentProviderClient(Stub): + """ContentProviderClient — 内容提供者客户端""" + + def __init__(self, uri: Optional[Uri] = None): + super().__init__() + self._uri = uri + + def query(self, uri: Uri, projection: Optional[List[str]], selection: Optional[str], + selection_args: Optional[List[str]], sort_order: Optional[str]) -> Optional[Any]: + return None + + def insert(self, uri: Uri, values: ContentValues) -> Optional[Uri]: + return uri + + def update(self, uri: Uri, values: ContentValues, selection: Optional[str], + selection_args: Optional[List[str]]) -> int: + return 0 + + def delete(self, uri: Uri, selection: Optional[str], selection_args: Optional[List[str]]) -> int: + return 0 + + def applyBatch(self, operations: List[Any]) -> List[Any]: + return [] + + def bulkInsert(self, uri: Uri, values: List[ContentValues]) -> int: + return len(values) if values else 0 + + def getType(self, uri: Uri) -> Optional[str]: + return None + + def getStreamTypes(self, uri: Uri, mime_type_filter: str) -> Optional[List[str]]: + return None + + def call(self, method: str, arg: Optional[str], extras: Optional[ContentValues]) -> Optional[ContentValues]: + return None + + def release(self): + pass + + def close(self): + pass + + def openFile(self, uri: Uri, mode: str) -> Any: + return None + + def openAssetFile(self, uri: Uri, mode: str) -> Any: + return None + + def openTypedAssetFile(self, uri: Uri, mime_type: str, opts: Optional[ContentValues]) -> Any: + return None + + def getLocalContentProvider(self) -> Optional[ContentProvider]: + return None + + +class ContentProviderOperation(Stub): + """ContentProviderOperation — 批量操作""" + + TYPE_INSERT = 1 + TYPE_UPDATE = 2 + TYPE_DELETE = 3 + TYPE_ASSERT = 4 + + class Builder(Stub): + def __init__(self, type_: int, uri: Uri): + super().__init__() + self._type = type_ + self._uri = uri + self._values: Optional[ContentValues] = None + self._selection: Optional[str] = None + self._selection_args: Optional[List[str]] = None + + def withValue(self, key: str, value: Any) -> "ContentProviderOperation.Builder": + if self._values is None: + self._values = ContentValues() + self._values.put(key, value) + return self + + def withValues(self, values: ContentValues) -> "ContentProviderOperation.Builder": + self._values = values + return self + + def withSelection(self, selection: str, selection_args: List[str]) -> "ContentProviderOperation.Builder": + self._selection = selection + self._selection_args = selection_args + return self + + def build(self) -> "ContentProviderOperation": + op = ContentProviderOperation() + op._type = self._type + op._uri = self._uri + op._values = self._values + op._selection = self._selection + op._selection_args = self._selection_args + return op + + @staticmethod + def newInsert(uri: Uri) -> "ContentProviderOperation.Builder": + return ContentProviderOperation.Builder(ContentProviderOperation.TYPE_INSERT, uri) + + @staticmethod + def newUpdate(uri: Uri) -> "ContentProviderOperation.Builder": + return ContentProviderOperation.Builder(ContentProviderOperation.TYPE_UPDATE, uri) + + @staticmethod + def newDelete(uri: Uri) -> "ContentProviderOperation.Builder": + return ContentProviderOperation.Builder(ContentProviderOperation.TYPE_DELETE, uri) + + @staticmethod + def newAssert(uri: Uri) -> "ContentProviderOperation.Builder": + return ContentProviderOperation.Builder(ContentProviderOperation.TYPE_ASSERT, uri) + + +class ContentProviderResult(Stub): + """ContentProviderResult — 操作结果""" + + def __init__(self, uri: Optional[Uri] = None, count: Optional[int] = None): + super().__init__() + self.uri = uri + self.count = count + + +# ═══════════════════════════════════════════════════════════════ +# Loader / CursorLoader / DialogInterface +# ═══════════════════════════════════════════════════════════════ + +class Loader(Stub): + """Loader — 异步数据加载器基类""" + + def __init__(self, context: Context): + super().__init__() + self._context = context + self._started = False + self._abandoned = False + self._listeners: List = [] + + def deliverResult(self, data: Any): + for listener in self._listeners: + try: + listener.onLoadFinished(self, data) + except Exception: + pass + + def startLoading(self): + self._started = True + + def forceLoad(self): + self.deliverResult(None) + + def stopLoading(self): + self._started = False + + def abandon(self): + self._abandoned = True + + def isStarted(self) -> bool: + return self._started + + def isAbandoned(self) -> bool: + return self._abandoned + + def reset(self): + self._started = False + self._abandoned = False + + def registerListener(self, listener): + if listener not in self._listeners: + self._listeners.append(listener) + + def unregisterListener(self, listener): + if listener in self._listeners: + self._listeners.remove(listener) + + def dataToString(self, data: Any) -> str: + return str(data) + + def toString(self) -> str: + return f"Loader@{hex(id(self))}" + + +class CursorLoader(Loader): + """CursorLoader — 游标加载器""" + + def __init__(self, context: Context, uri: Uri, projection: Optional[List[str]], + selection: Optional[str], selection_args: Optional[List[str]], sort_order: Optional[str]): + super().__init__(context) + self._uri = uri + self._projection = projection + self._selection = selection + self._selection_args = selection_args + self._sort_order = sort_order + + def getUri(self) -> Uri: + return self._uri + + def setUri(self, uri: Uri): + self._uri = uri + + def getProjection(self) -> Optional[List[str]]: + return self._projection + + def setProjection(self, projection: Optional[List[str]]): + self._projection = projection + + def getSelection(self) -> Optional[str]: + return self._selection + + def setSelection(self, selection: Optional[str]): + self._selection = selection + + def getSelectionArgs(self) -> Optional[List[str]]: + return self._selection_args + + def setSelectionArgs(self, args: Optional[List[str]]): + self._selection_args = args + + def getSortOrder(self) -> Optional[str]: + return self._sort_order + + def setSortOrder(self, sort_order: Optional[str]): + self._sort_order = sort_order + + def loadInBackground(self): + return None + + +class DialogInterface(Stub): + """DialogInterface — 对话框接口常量""" + + BUTTON_POSITIVE = -1 + BUTTON_NEGATIVE = -2 + BUTTON_NEUTRAL = -3 + + def cancel(self): + pass + + def dismiss(self): + pass + + +# ═══════════════════════════════════════════════════════════════ +# SyncAdapter / SyncResult +# ═══════════════════════════════════════════════════════════════ + +class SyncAdapter(Stub): + """SyncAdapter — 同步适配器""" + + def __init__(self, context: Context, auto_initialize: bool, allow_parallel_syncs: bool): + super().__init__() + self._context = context + + def onPerformSync(self, account: Any, extras: ContentValues, authority: str, + provider: ContentProviderClient, sync_result: "SyncResult"): + pass + + def onSecurityException(self, account: Any, extras: ContentValues, + authority: str, sync_result: "SyncResult"): + pass + + +class SyncResult(Stub): + """SyncResult — 同步结果""" + + def __init__(self): + super().__init__() + self.stats = self._Stats() + + class _Stats: + def __init__(self): + self.numEntries = 0 + self.numUpdates = 0 + self.numDeletes = 0 + self.numInserts = 0 + self.numSkippedEntries = 0 + + def clear(self): + self.stats = self._Stats() + + def hasError(self) -> bool: + return False + + def hasSoftError(self) -> bool: + return False + + def hasHardError(self) -> bool: + return False + + def madeSomeProgress(self) -> bool: + return self.stats.numEntries > 0 + + def toString(self) -> str: + return f"SyncResult({self.stats.numEntries} entries)" + + +# ═══════════════════════════════════════════════════════════════ +# 替换 _core.py 中的 _GlobalContext +# ═══════════════════════════════════════════════════════════════ + +_real_context = Context() +# 将 _core 中的 android_context 替换为真实 Context +import importlib +try: + _core_mod = importlib.import_module(".._core", __package__) + _core_mod.android_context.__class__ = Context +except Exception: + pass + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "Uri", + "ContentValues", + "ContentResolver", + "Context", + "ContextWrapper", + "IntentFilter", + "BroadcastReceiver", + "SharedPreferences", + "SharedPreferencesEditor", + "ComponentName", + "ClipData", + "ClipDescription", + "ContentProvider", + "ContentProviderClient", + "ContentProviderOperation", + "ContentProviderResult", + "CursorLoader", + "Loader", + "DialogInterface", + "SyncAdapter", + "SyncResult", +] \ No newline at end of file diff --git a/android_pyapi/android/content_pm.py b/android_pyapi/android/content_pm.py new file mode 100644 index 0000000..1f2283e --- /dev/null +++ b/android_pyapi/android/content_pm.py @@ -0,0 +1,801 @@ +""" +Android PackageManager 组件 — PackageManager, PackageInfo, ApplicationInfo 等 +方法签名完全对齐 Android SDK +""" + +import json +import os +import sys +from typing import Any, Dict, List, Optional, Set + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, + _sdcard_root, _app_data_dir, _package_name, +) + + +# ═══════════════════════════════════════════════════════════════ +# 数据存储路径 +# ═══════════════════════════════════════════════════════════════ + +_PACKAGE_DATA_DIR = os.path.join(_app_data_dir, "package_data") +os.makedirs(_PACKAGE_DATA_DIR, exist_ok=True) + +_DEFAULT_PACKAGE_INFO_PATH = os.path.join(_PACKAGE_DATA_DIR, f"{_package_name}.json") + + +def _get_default_package_info() -> Dict[str, Any]: + """获取默认包信息""" + return { + "packageName": _package_name, + "versionName": "1.0.0", + "versionCode": 1, + "applicationInfo": { + "name": _package_name, + "packageName": _package_name, + "className": f"{_package_name}.MainApplication", + "icon": 0, + "targetSdkVersion": 34, + "sourceDir": os.path.join(_app_data_dir, "base.apk"), + "dataDir": _app_data_dir, + "enabled": True, + "flags": 0, + "theme": 0, + "labelRes": 0, + "descriptionRes": 0, + "logo": 0, + "banner": 0, + "processName": _package_name, + "uid": 10001, + "manageSpaceActivityName": "", + "taskAffinity": "", + "permission": "", + }, + "activities": [], + "services": [], + "receivers": [], + "providers": [], + "permissions": [], + "requestedPermissions": [ + "android.permission.INTERNET", + "android.permission.ACCESS_NETWORK_STATE", + ], + "features": { + "android.hardware.camera": True, + "android.hardware.wifi": True, + "android.hardware.bluetooth": True, + "android.hardware.location": True, + "android.hardware.sensor.accelerometer": True, + "android.hardware.sensor.gyroscope": True, + "android.hardware.touchscreen": True, + "android.hardware.microphone": True, + "android.hardware.nfc": False, + "android.hardware.telephony": True, + "android.software.picture_in_picture": True, + "android.hardware.usb.host": False, + } + } + + +# ═══════════════════════════════════════════════════════════════ +# PackageItemInfo (基类) +# ═══════════════════════════════════════════════════════════════ + +class PackageItemInfo(Stub): + """PackageItemInfo — 包条目信息基类""" + + def __init__(self, data: Optional[Dict[str, Any]] = None): + super().__init__() + data = data or {} + self.name = data.get("name", "") + self.packageName = data.get("packageName", "") + self.labelRes = data.get("labelRes", 0) + self.nonLocalizedLabel = data.get("nonLocalizedLabel", None) + self.icon = data.get("icon", 0) + self.banner = data.get("banner", 0) + self.logo = data.get("logo", 0) + + def loadLabel(self, pm: "PackageManager") -> str: + return self.nonLocalizedLabel or self.name.split(".")[-1] if self.name else "" + + def loadIcon(self, pm: "PackageManager") -> Any: + return None + + def loadLogo(self, pm: "PackageManager") -> Any: + return None + + def loadBanner(self, pm: "PackageManager") -> Any: + return None + + def toString(self) -> str: + return f"{self.__class__.__name__}({self.packageName}:{self.name})" + + +class ComponentInfo(PackageItemInfo): + """ComponentInfo — 组件信息基类""" + + def __init__(self, data: Optional[Dict[str, Any]] = None): + super().__init__(data) + data = data or {} + self.processName = data.get("processName", self.packageName) + self.splitName = data.get("splitName", None) + self.enabled = data.get("enabled", True) + self.exported = data.get("exported", False) + self.directBootAware = data.get("directBootAware", False) + + def getComponentName(self) -> Any: + from .content import ComponentName + return ComponentName(self.packageName, self.name) + + def isEnabled(self) -> bool: + return self.enabled + + +# ═══════════════════════════════════════════════════════════════ +# ApplicationInfo +# ═══════════════════════════════════════════════════════════════ + +class ApplicationInfo(ComponentInfo): + """ApplicationInfo — 应用信息""" + + FLAG_SYSTEM = 1 + FLAG_DEBUGGABLE = 2 + FLAG_HAS_CODE = 4 + FLAG_ALLOW_CLEAR_USER_DATA = 0x00400000 + FLAG_ALLOW_BACKUP = 0x00008000 + FLAG_EXTERNAL_STORAGE = 0x00100000 + FLAG_LARGE_HEAP = 0x00100000 + FLAG_MULTIPROCESS = 0x00010000 + FLAG_TEST_ONLY = 0x00000100 + FLAG_STOPPED = 0x00200000 + FLAG_RESTART_ON_UPGRADE = 0x00000020 + + def __init__(self, data: Optional[Dict[str, Any]] = None): + super().__init__(data) + data = data or {} + self.taskAffinity = data.get("taskAffinity", "") + self.permission = data.get("permission", "") + self.processName = data.get("processName", self.packageName) + self.className = data.get("className", "") + self.descriptionRes = data.get("descriptionRes", 0) + self.theme = data.get("theme", 0) + self.flags = data.get("flags", 0) + self.sourceDir = data.get("sourceDir", "") + self.publicSourceDir = data.get("publicSourceDir", self.sourceDir) + self.dataDir = data.get("dataDir", "") + self.nativeLibraryDir = data.get("nativeLibraryDir", "") + self.metaData = data.get("metaData", None) + self.manageSpaceActivityName = data.get("manageSpaceActivityName", "") + self.targetSdkVersion = data.get("targetSdkVersion", 34) + self.uid = data.get("uid", 10001) + self.backupAgentName = data.get("backupAgentName", "") + self.enabled = data.get("enabled", True) + + def loadDescription(self, pm: "PackageManager") -> Optional[str]: + return None + + def toString(self) -> str: + return f"ApplicationInfo({self.packageName}, targetSdk={self.targetSdkVersion})" + + +# ═══════════════════════════════════════════════════════════════ +# ActivityInfo +# ═══════════════════════════════════════════════════════════════ + +class ActivityInfo(ComponentInfo): + """ActivityInfo — Activity 组件信息""" + + CONFIG_MCC = 0x0001 + CONFIG_MNC = 0x0002 + CONFIG_LOCALE = 0x0004 + CONFIG_TOUCHSCREEN = 0x0008 + CONFIG_KEYBOARD = 0x0010 + CONFIG_KEYBOARD_HIDDEN = 0x0020 + CONFIG_NAVIGATION = 0x0040 + CONFIG_ORIENTATION = 0x0080 + CONFIG_SCREEN_LAYOUT = 0x0100 + CONFIG_UI_MODE = 0x0200 + CONFIG_SCREEN_SIZE = 0x0400 + CONFIG_SMALLEST_SCREEN_SIZE = 0x0800 + CONFIG_DENSITY = 0x1000 + CONFIG_LAYOUT_DIRECTION = 0x2000 + CONFIG_COLOR_MODE = 0x4000 + + LAUNCH_MULTIPLE = 0 + LAUNCH_SINGLE_TOP = 1 + LAUNCH_SINGLE_TASK = 2 + LAUNCH_SINGLE_INSTANCE = 3 + LAUNCH_SINGLE_INSTANCE_PER_TASK = 4 + + SCREEN_ORIENTATION_UNSPECIFIED = -1 + SCREEN_ORIENTATION_LANDSCAPE = 0 + SCREEN_ORIENTATION_PORTRAIT = 1 + SCREEN_ORIENTATION_USER = 2 + SCREEN_ORIENTATION_BEHIND = 3 + SCREEN_ORIENTATION_SENSOR = 4 + SCREEN_ORIENTATION_NOSENSOR = 5 + SCREEN_ORIENTATION_SENSOR_LANDSCAPE = 6 + SCREEN_ORIENTATION_SENSOR_PORTRAIT = 7 + SCREEN_ORIENTATION_REVERSE_LANDSCAPE = 8 + SCREEN_ORIENTATION_REVERSE_PORTRAIT = 9 + SCREEN_ORIENTATION_FULL_SENSOR = 10 + SCREEN_ORIENTATION_USER_LANDSCAPE = 11 + SCREEN_ORIENTATION_USER_PORTRAIT = 12 + SCREEN_ORIENTATION_FULL_USER = 13 + SCREEN_ORIENTATION_LOCKED = 14 + + def __init__(self, data: Optional[Dict[str, Any]] = None): + super().__init__(data) + data = data or {} + self.launchMode = data.get("launchMode", self.LAUNCH_MULTIPLE) + self.screenOrientation = data.get("screenOrientation", self.SCREEN_ORIENTATION_UNSPECIFIED) + self.configChanges = data.get("configChanges", 0) + self.softInputMode = data.get("softInputMode", 0) + self.theme = data.get("theme", 0) + self.parentActivityName = data.get("parentActivityName", "") + self.permission = data.get("permission", "") + self.taskAffinity = data.get("taskAffinity", "") + self.targetActivity = data.get("targetActivity", "") + + def toString(self) -> str: + return f"ActivityInfo({self.name}, launchMode={self.launchMode})" + + +# ═══════════════════════════════════════════════════════════════ +# ServiceInfo +# ═══════════════════════════════════════════════════════════════ + +class ServiceInfo(ComponentInfo): + """ServiceInfo — Service 组件信息""" + + FLAG_STOP_WITH_TASK = 0x01 + FLAG_ISOLATED_PROCESS = 0x02 + FLAG_EXTERNAL_SERVICE = 0x04 + FLAG_SINGLE_USER = 0x40000000 + FLAG_USE_APP_OP = 0x08 + + def __init__(self, data: Optional[Dict[str, Any]] = None): + super().__init__(data) + data = data or {} + self.flags = data.get("flags", 0) + self.permission = data.get("permission", "") + self.foregroundServiceType = data.get("foregroundServiceType", 0) + + def toString(self) -> str: + return f"ServiceInfo({self.name})" + + +# ═══════════════════════════════════════════════════════════════ +# ProviderInfo +# ═══════════════════════════════════════════════════════════════ + +class ProviderInfo(ComponentInfo): + """ProviderInfo — ContentProvider 组件信息""" + + def __init__(self, data: Optional[Dict[str, Any]] = None): + super().__init__(data) + data = data or {} + self.authority = data.get("authority", "") + self.readPermission = data.get("readPermission", "") + self.writePermission = data.get("writePermission", "") + self.grantUriPermissions = data.get("grantUriPermissions", False) + self.multiprocess = data.get("multiprocess", False) + self.initOrder = data.get("initOrder", 0) + self.flags = data.get("flags", 0) + + def toString(self) -> str: + return f"ProviderInfo({self.name}, authority={self.authority})" + + +# ═══════════════════════════════════════════════════════════════ +# PermissionInfo +# ═══════════════════════════════════════════════════════════════ + +class PermissionInfo(PackageItemInfo): + """PermissionInfo — 权限信息""" + + PROTECTION_NORMAL = 0 + PROTECTION_DANGEROUS = 1 + PROTECTION_SIGNATURE = 2 + PROTECTION_SIGNATURE_OR_SYSTEM = 3 + PROTECTION_INTERNAL = 4 + + FLAG_COSTS_MONEY = 0x01 + FLAG_HARDWARE_RESTRICTED = 0x04 + FLAG_IMMUTABLY_RESTRICTED = 0x08 + FLAG_INSTALLED = 0x10 + + def __init__(self, data: Optional[Dict[str, Any]] = None): + super().__init__(data) + data = data or {} + self.group = data.get("group", "") + self.descriptionRes = data.get("descriptionRes", 0) + self.protectionLevel = data.get("protectionLevel", self.PROTECTION_NORMAL) + self.flags = data.get("flags", 0) + + def loadDescription(self, pm: "PackageManager") -> Optional[str]: + return None + + def toString(self) -> str: + return f"PermissionInfo({self.name}, protectionLevel={self.protectionLevel})" + + +# ═══════════════════════════════════════════════════════════════ +# ResolveInfo +# ═══════════════════════════════════════════════════════════════ + +class ResolveInfo(Stub): + """ResolveInfo — 解析意图的结果""" + + def __init__(self): + super().__init__() + self.activityInfo: Optional[ActivityInfo] = None + self.serviceInfo: Optional[ServiceInfo] = None + self.providerInfo: Optional[ProviderInfo] = None + self.filter: Optional[Any] = None + self.priority = 0 + self.match = 0 + self.preferredOrder = 0 + self.isDefault = False + self.labelRes = 0 + self.nonLocalizedLabel = None + self.icon = 0 + self.resolvePackageName = "" + self.specificIndex = -1 + self.system = False + + def loadLabel(self, pm: "PackageManager") -> str: + if self.activityInfo: + return self.activityInfo.name.split(".")[-1] + if self.serviceInfo: + return self.serviceInfo.name.split(".")[-1] + return "" + + def loadIcon(self, pm: "PackageManager"): + return None + + def getIconResource(self) -> int: + return self.icon + + def toString(self) -> str: + return f"ResolveInfo(priority={self.priority})" + + +# ═══════════════════════════════════════════════════════════════ +# PackageInfo +# ═══════════════════════════════════════════════════════════════ + +class PackageInfo(Stub): + """PackageInfo — 包信息""" + + INSTALL_LOCATION_AUTO = 0 + INSTALL_LOCATION_INTERNAL_ONLY = 1 + INSTALL_LOCATION_PREFER_EXTERNAL = 2 + REQUESTED_PERMISSION_REQUIRED = 0x00100000 + REQUESTED_PERMISSION_GRANTED = 0x01000000 + REQUESTED_PERMISSION_DENIED = 0x02000000 + + def __init__(self): + super().__init__() + self.packageName = "" + self.versionName = "" + self.versionCode = 0 + self.applicationInfo: Optional[ApplicationInfo] = None + self.activities: List[ActivityInfo] = [] + self.services: List[ServiceInfo] = [] + self.receivers: List[ActivityInfo] = [] + self.providers: List[ProviderInfo] = [] + self.permissions: List[PermissionInfo] = [] + self.requestedPermissions: List[str] = [] + self.requestedPermissionsFlags: List[int] = [] + self.sharedUserId = "" + self.sharedUserLabel = 0 + self.firstInstallTime = 0 + self.lastUpdateTime = 0 + self.gids: List[int] = [] + self.installLocation = self.INSTALL_LOCATION_AUTO + self.configPreferences: List = [] + self.featureGroups: List = [] + self.packageName_ = "" + + def toString(self) -> str: + return (f"PackageInfo({self.packageName} v{self.versionName} " + f"code={self.versionCode})") + + +# ═══════════════════════════════════════════════════════════════ +# Signature +# ═══════════════════════════════════════════════════════════════ + +class Signature(Stub): + """Signature — APK 签名""" + + def __init__(self, signature: str = ""): + super().__init__() + self._signature = signature + + def toCharsString(self) -> str: + return self._signature + + def toByteArray(self) -> bytes: + return self._signature.encode("utf-8") if self._signature else b"" + + def equals(self, other) -> bool: + if isinstance(other, Signature): + return self._signature == other._signature + return False + + def hashCode(self) -> int: + return hash(self._signature) & 0x7FFFFFFF + + def toString(self) -> str: + return self._signature[:64] if len(self._signature) > 64 else self._signature + + +# ═══════════════════════════════════════════════════════════════ +# PackageStats +# ═══════════════════════════════════════════════════════════════ + +class PackageStats(Stub): + """PackageStats — 包存储统计""" + + def __init__(self, package_name: str = ""): + super().__init__() + self.packageName = package_name + self.codeSize = 0 + self.dataSize = 0 + self.cacheSize = 0 + self.externalCodeSize = 0 + self.externalDataSize = 0 + self.externalCacheSize = 0 + self.externalMediaSize = 0 + self.externalObbSize = 0 + + def toString(self) -> str: + return (f"PackageStats({self.packageName}, " + f"code={self.codeSize}, data={self.dataSize})") + + +# ═══════════════════════════════════════════════════════════════ +# PackageManager +# ═══════════════════════════════════════════════════════════════ + +class PackageManager(Stub): + """PackageManager — 包管理器""" + + # Flag 常量 + GET_ACTIVITIES = 1 + GET_CONFIGURATIONS = 2 + GET_GIDS = 4 + GET_INSTRUMENTATION = 8 + GET_INTENT_FILTERS = 16 + GET_META_DATA = 128 + GET_PERMISSIONS = 4096 + GET_PROVIDERS = 8 + GET_RECEIVERS = 4 + GET_SERVICES = 2 + GET_SHARED_LIBRARY_FILES = 32 + GET_SIGNATURES = 64 + GET_UNINSTALLED_PACKAGES = 512 + GET_URI_PERMISSION_PATTERNS = 256 + MATCH_ALL = 0x10000 + MATCH_DISABLED_COMPONENTS = 0x200 + MATCH_DISABLED_UNTIL_USED_COMPONENTS = 0x8000 + MATCH_DEFAULT_ONLY = 0x10000 + MATCH_SYSTEM_ONLY = 0x800000 + MATCH_UNINSTALLED_PACKAGES = 0x2000000 + PERMISSION_DENIED = -1 + PERMISSION_GRANTED = 0 + + # 特性常量 + FEATURE_CAMERA = "android.hardware.camera" + FEATURE_CAMERA_AUTOFOCUS = "android.hardware.camera.autofocus" + FEATURE_CAMERA_FLASH = "android.hardware.camera.flash" + FEATURE_CAMERA_FRONT = "android.hardware.camera.front" + FEATURE_LOCATION = "android.hardware.location" + FEATURE_LOCATION_GPS = "android.hardware.location.gps" + FEATURE_LOCATION_NETWORK = "android.hardware.location.network" + FEATURE_MICROPHONE = "android.hardware.microphone" + FEATURE_NFC = "android.hardware.nfc" + FEATURE_SENSOR_ACCELEROMETER = "android.hardware.sensor.accelerometer" + FEATURE_SENSOR_BAROMETER = "android.hardware.sensor.barometer" + FEATURE_SENSOR_COMPASS = "android.hardware.sensor.compass" + FEATURE_SENSOR_GYROSCOPE = "android.hardware.sensor.gyroscope" + FEATURE_SENSOR_LIGHT = "android.hardware.sensor.light" + FEATURE_SENSOR_PROXIMITY = "android.hardware.sensor.proximity" + FEATURE_TELEPHONY = "android.hardware.telephony" + FEATURE_TOUCHSCREEN = "android.hardware.touchscreen" + FEATURE_USB_HOST = "android.hardware.usb.host" + FEATURE_WIFI = "android.hardware.wifi" + FEATURE_BLUETOOTH = "android.hardware.bluetooth" + + def __init__(self): + super().__init__() + self._packages: Dict[str, Dict[str, Any]] = {} + self._load_packages() + + def _load_packages(self): + """从 JSON 文件加载包信息""" + try: + if os.path.exists(_DEFAULT_PACKAGE_INFO_PATH): + with open(_DEFAULT_PACKAGE_INFO_PATH, "r", encoding="utf-8") as f: + data = json.load(f) + if data.get("packageName"): + self._packages[data["packageName"]] = data + else: + # 创建默认信息 + default_info = _get_default_package_info() + self._packages[_package_name] = default_info + os.makedirs(os.path.dirname(_DEFAULT_PACKAGE_INFO_PATH), exist_ok=True) + with open(_DEFAULT_PACKAGE_INFO_PATH, "w", encoding="utf-8") as f: + json.dump(default_info, f, indent=2, ensure_ascii=False) + except (json.JSONDecodeError, OSError): + self._packages[_package_name] = _get_default_package_info() + + def _make_app_info(self, data: Dict) -> ApplicationInfo: + ai_data = data.get("applicationInfo", data) + return ApplicationInfo(ai_data) + + def _make_activity_info(self, data: Dict) -> ActivityInfo: + return ActivityInfo(data) + + def _make_service_info(self, data: Dict) -> ServiceInfo: + return ServiceInfo(data) + + def _make_provider_info(self, data: Dict) -> ProviderInfo: + return ProviderInfo(data) + + def getPackageInfo(self, package_name: str, flags: int) -> Optional[PackageInfo]: + if package_name not in self._packages: + return None + raw = self._packages[package_name] + pi = PackageInfo() + pi.packageName = raw.get("packageName", package_name) + pi.versionName = raw.get("versionName", "1.0.0") + pi.versionCode = raw.get("versionCode", 1) + pi.applicationInfo = self._make_app_info(raw) + + if flags & self.GET_ACTIVITIES: + pi.activities = [self._make_activity_info(a) for a in raw.get("activities", [])] + if flags & self.GET_SERVICES: + pi.services = [self._make_service_info(s) for s in raw.get("services", [])] + if flags & self.GET_RECEIVERS: + pi.receivers = [self._make_activity_info(r) for r in raw.get("receivers", [])] + if flags & self.GET_PROVIDERS: + pi.providers = [self._make_provider_info(p) for p in raw.get("providers", [])] + if flags & self.GET_PERMISSIONS: + pi.permissions = [PermissionInfo(p) for p in raw.get("permissions", [])] + + pi.requestedPermissions = raw.get("requestedPermissions", []) + return pi + + def getApplicationInfo(self, package_name: str, flags: int) -> Optional[ApplicationInfo]: + if package_name not in self._packages: + return None + return self._make_app_info(self._packages[package_name]) + + def getActivityInfo(self, component: Any, flags: int) -> Optional[ActivityInfo]: + cn = component + pkg = getattr(cn, "getPackageName", lambda: "")() + cls = getattr(cn, "getClassName", lambda: "")() + if pkg in self._packages: + for a in self._packages[pkg].get("activities", []): + if a.get("name") == cls: + return ActivityInfo(a) + return ActivityInfo({"name": cls, "packageName": pkg}) + + def getServiceInfo(self, component: Any, flags: int) -> Optional[ServiceInfo]: + cn = component + pkg = getattr(cn, "getPackageName", lambda: "")() + cls = getattr(cn, "getClassName", lambda: "")() + if pkg in self._packages: + for s in self._packages[pkg].get("services", []): + if s.get("name") == cls: + return ServiceInfo(s) + return ServiceInfo({"name": cls, "packageName": pkg}) + + def getInstalledPackages(self, flags: int) -> List[PackageInfo]: + result = [] + for pkg_name in self._packages: + pi = self.getPackageInfo(pkg_name, flags) + if pi: + result.append(pi) + return result + + def getInstalledApplications(self, flags: int) -> List[ApplicationInfo]: + result = [] + for pkg_name in self._packages: + ai = self.getApplicationInfo(pkg_name, flags) + if ai: + result.append(ai) + return result + + def queryIntentActivities(self, intent: Any, flags: int) -> List[ResolveInfo]: + """查询匹配 Intent 的 Activity 列表""" + results = [] + action = getattr(intent, "getAction", lambda: None)() + for pkg_name, raw in self._packages.items(): + for a in raw.get("activities", []): + ri = ResolveInfo() + ri.activityInfo = ActivityInfo(a) + ri.priority = 0 + ri.match = 0 + results.append(ri) + return results + + def queryBroadcastReceivers(self, intent: Any, flags: int) -> List[ResolveInfo]: + results = [] + for pkg_name, raw in self._packages.items(): + for r in raw.get("receivers", []): + ri = ResolveInfo() + ri.activityInfo = ActivityInfo(r) + results.append(ri) + return results + + def queryIntentServices(self, intent: Any, flags: int) -> List[ResolveInfo]: + results = [] + for pkg_name, raw in self._packages.items(): + for s in raw.get("services", []): + ri = ResolveInfo() + ri.serviceInfo = ServiceInfo(s) + results.append(ri) + return results + + def queryIntentContentProviders(self, intent: Any, flags: int) -> List[ResolveInfo]: + results = [] + for pkg_name, raw in self._packages.items(): + for p in raw.get("providers", []): + ri = ResolveInfo() + ri.providerInfo = ProviderInfo(p) + results.append(ri) + return results + + def resolveActivity(self, intent: Any, flags: int) -> Optional[ResolveInfo]: + activities = self.queryIntentActivities(intent, flags) + return activities[0] if activities else None + + def resolveService(self, intent: Any, flags: int) -> Optional[ResolveInfo]: + services = self.queryIntentServices(intent, flags) + return services[0] if services else None + + def checkPermission(self, permission: str, package_name: str) -> int: + if package_name in self._packages: + perms = self._packages[package_name].get("requestedPermissions", []) + if permission in perms: + return self.PERMISSION_GRANTED + return self.PERMISSION_DENIED if permission else self.PERMISSION_GRANTED + + def getPermissionInfo(self, name: str, flags: int) -> Optional[PermissionInfo]: + return PermissionInfo({"name": name, "packageName": "android"}) + + def getDefaultActivityIcon(self) -> Any: + return None + + def getApplicationLabel(self, info: ApplicationInfo) -> str: + return info.name.split(".")[-1] if info.name else "" + + def getApplicationIcon(self, package_name: str) -> Any: + return None + + def hasSystemFeature(self, feature: str) -> bool: + for pkg_name, raw in self._packages.items(): + features = raw.get("features", {}) + if feature in features: + return features[feature] + return False + + def getLaunchIntentForPackage(self, package_name: str) -> Any: + from .app import Intent + if package_name in self._packages: + intent = Intent(Intent.ACTION_MAIN) + intent.setPackage(package_name) + return intent + return None + + def getLeanbackLaunchIntentForPackage(self, package_name: str) -> Any: + return self.getLaunchIntentForPackage(package_name) + + def getPackageSizeInfo(self, package_name: str, observer: Any): + pass + + def getPackageGids(self, package_name: str) -> Optional[List[int]]: + return [] + + def getPackageUid(self, package_name: str, flags: int) -> int: + return 10001 + + def getNameForUid(self, uid: int) -> Optional[str]: + return _package_name + + def getPackagesForUid(self, uid: int) -> Optional[List[str]]: + return [_package_name] + + def getResourcesForActivity(self, component: Any) -> Any: + return None + + def getResourcesForApplication(self, app_info: ApplicationInfo) -> Any: + return None + + def isSafeMode(self) -> bool: + return False + + def addPackageToPreferred(self, package_name: str): + pass + + def removePackageFromPreferred(self, package_name: str): + pass + + def getPreferredPackages(self, flags: int) -> List[PackageInfo]: + return [] + + def setApplicationEnabledSetting(self, package_name: str, new_state: int, flags: int): + pass + + def getApplicationEnabledSetting(self, package_name: str) -> int: + return 0 + + def getComponentEnabledSetting(self, component_name: Any) -> int: + return 1 + + def setComponentEnabledSetting(self, component_name: Any, new_state: int, flags: int): + pass + + def clearInstantAppCookie(self): + pass + + def getInstantAppCookie(self) -> bytes: + return b"" + + def getInstantAppCookieMaxSize(self) -> int: + return 4096 + + def getMimeGroup(self, mime_group: str) -> List[str]: + return [] + + def isInstantApp(self) -> bool: + return False + + def isInstantAppPackageName(self, package_name: str) -> bool: + return False + + def getSyntheticAppDetailsActivityEnabled(self, package_name: str) -> int: + return 1 + + def setSyntheticAppDetailsActivityEnabled(self, package_name: str, enabled: int): + pass + + def canRequestPackageInstalls(self) -> bool: + return True + + def currentToCanonicalPackageNames(self, names: List[str]) -> List[str]: + return list(names) + + def canonicalToCurrentPackageNames(self, names: List[str]) -> List[str]: + return list(names) + + def getInstallerPackageName(self, package_name: str) -> Optional[str]: + return None + + def toString(self) -> str: + return f"PackageManager(packages={len(self._packages)})" + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "PackageManager", + "PackageInfo", + "ApplicationInfo", + "ActivityInfo", + "ServiceInfo", + "ProviderInfo", + "PermissionInfo", + "ResolveInfo", + "PackageItemInfo", + "ComponentInfo", + "Signature", + "PackageStats", +] \ No newline at end of file diff --git a/android_pyapi/android/database.py b/android_pyapi/android/database.py new file mode 100644 index 0000000..cea4c18 --- /dev/null +++ b/android_pyapi/android/database.py @@ -0,0 +1,1076 @@ +""" +Android Database 组件 — Cursor, MatrixCursor, ContentObserver 等 +方法签名完全对齐 Android SDK +""" + +import os +import sys +from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, + _sdcard_root, _app_data_dir, _package_name, +) + + +# ═══════════════════════════════════════════════════════════════ +# SQLException hierarchy +# ═══════════════════════════════════════════════════════════════ + +class SQLException(RuntimeError): + """SQLException — 数据库异常基类""" + + def __init__(self, message: str = ""): + super().__init__(message) + self._error_message = message + + def getMessage(self) -> str: + return self._error_message + + def toString(self) -> str: + return f"SQLException: {self._error_message}" + + +class CursorIndexOutOfBoundsException(SQLException): + """CursorIndexOutOfBoundsException — 游标越界""" + + def __init__(self, message: str = ""): + super().__init__(message) + + +# ═══════════════════════════════════════════════════════════════ +# ContentObserver +# ═══════════════════════════════════════════════════════════════ + +class ContentObserver(Stub): + """ContentObserver — 内容观察者""" + + def __init__(self, handler: Any = None): + super().__init__() + self._handler = handler + self._notify_for_descendants = False + + def onChange(self, self_change: bool = True): + pass + + def onChange(self, self_change: bool, uri: Any = None): # type: ignore + pass + + def deliverSelfNotifications(self) -> bool: + return True + + def getSelfChangeNotify(self) -> bool: + return True + + def dispatchChange(self, self_change: bool, uri: Any = None): + self.onChange(self_change, uri) + + +# ═══════════════════════════════════════════════════════════════ +# DataSetObserver +# ═══════════════════════════════════════════════════════════════ + +class DataSetObserver(Stub): + """DataSetObserver — 数据集观察者""" + + def onChanged(self): + pass + + def onInvalidated(self): + pass + + +# ═══════════════════════════════════════════════════════════════ +# ContentObservable +# ═══════════════════════════════════════════════════════════════ + +class ContentObservable(Stub): + """ContentObservable — 内容可观察对象""" + + def __init__(self): + super().__init__() + self._observers: List[ContentObserver] = [] + + def registerObserver(self, observer: ContentObserver): + if observer not in self._observers: + self._observers.append(observer) + + def unregisterObserver(self, observer: ContentObserver): + self._observers = [o for o in self._observers if o is not observer] + + def dispatchChange(self, self_change: bool, uri: Any = None): + for observer in list(self._observers): + observer.dispatchChange(self_change, uri) + + def notifyChange(self, self_change: bool): + for observer in list(self._observers): + observer.onChange(self_change) + + +# ═══════════════════════════════════════════════════════════════ +# DataSetObservable +# ═══════════════════════════════════════════════════════════════ + +class DataSetObservable(Stub): + """DataSetObservable — 数据集可观察对象""" + + def __init__(self): + super().__init__() + self._observers: List[DataSetObserver] = [] + + def registerObserver(self, observer: DataSetObserver): + if observer not in self._observers: + self._observers.append(observer) + + def unregisterObserver(self, observer: DataSetObserver): + self._observers = [o for o in self._observers if o is not observer] + + def notifyChanged(self): + for observer in list(self._observers): + observer.onChanged() + + def notifyInvalidated(self): + for observer in list(self._observers): + observer.onInvalidated() + + +# ═══════════════════════════════════════════════════════════════ +# CharArrayBuffer +# ═══════════════════════════════════════════════════════════════ + +class CharArrayBuffer(Stub): + """CharArrayBuffer — 字符数组缓冲区""" + + def __init__(self, size: int = 0): + super().__init__() + self.data: List[str] = [""] * size + + +# ═══════════════════════════════════════════════════════════════ +# DatabaseErrorHandler +# ═══════════════════════════════════════════════════════════════ + +class DatabaseErrorHandler(Stub): + """DatabaseErrorHandler — 数据库错误处理器""" + + def onCorruption(self, db_obj: Any): + pass + + +class DefaultDatabaseErrorHandler(DatabaseErrorHandler): + """DefaultDatabaseErrorHandler — 默认数据库错误处理器""" + + def onCorruption(self, db_obj: Any): + import sys + sys.stderr.write(f"[DatabaseError] Corruption detected for {db_obj}\n") + + +# ═══════════════════════════════════════════════════════════════ +# CursorWindow +# ═══════════════════════════════════════════════════════════════ + +class CursorWindow(Stub): + """CursorWindow — 游标窗口""" + + def __init__(self, name: str = "unnamed"): + super().__init__() + self._name = name + self._start_position: int = 0 + self._num_rows: int = 0 + self._num_columns: int = 0 + self._data: List[List[Optional[Any]]] = [] + + def setStartPosition(self, pos: int): + self._start_position = pos + + def getStartPosition(self) -> int: + return self._start_position + + def allocRow(self) -> bool: + self._data.append([None] * self._num_columns) + self._num_rows = len(self._data) + return True + + def freeRow(self, row: int): + if 0 <= row < len(self._data): + self._data[row] = [None] * self._num_columns + + def freeLastRow(self): + if self._data: + self._data.pop() + self._num_rows = len(self._data) + + def getNumRows(self) -> int: + return self._num_rows + + def setNumColumns(self, num_columns: int): + self._num_columns = num_columns + + def getNumColumns(self) -> int: + return self._num_columns + + def writeString(self, value: str, row: int, col: int): + while len(self._data) <= row: + self._data.append([None] * self._num_columns) + while len(self._data[row]) <= col: + self._data[row].append(None) + self._data[row][col] = value + + def writeLong(self, value: int, row: int, col: int): + while len(self._data) <= row: + self._data.append([None] * self._num_columns) + while len(self._data[row]) <= col: + self._data[row].append(None) + self._data[row][col] = value + + def writeDouble(self, value: float, row: int, col: int): + while len(self._data) <= row: + self._data.append([None] * self._num_columns) + while len(self._data[row]) <= col: + self._data[row].append(None) + self._data[row][col] = value + + def writeBlob(self, value: bytes, row: int, col: int): + while len(self._data) <= row: + self._data.append([None] * self._num_columns) + while len(self._data[row]) <= col: + self._data[row].append(None) + self._data[row][col] = value + + def writeNull(self, row: int, col: int): + while len(self._data) <= row: + self._data.append([None] * self._num_columns) + while len(self._data[row]) <= col: + self._data[row].append(None) + self._data[row][col] = None + + def getString(self, row: int, col: int) -> Optional[str]: + try: + v = self._data[row][col] + return str(v) if v is not None else None + except (IndexError, TypeError): + return None + + def getLong(self, row: int, col: int) -> int: + try: + v = self._data[row][col] + return int(v) if v is not None else 0 + except (IndexError, ValueError, TypeError): + return 0 + + def getDouble(self, row: int, col: int) -> float: + try: + v = self._data[row][col] + return float(v) if v is not None else 0.0 + except (IndexError, ValueError, TypeError): + return 0.0 + + def getBlob(self, row: int, col: int) -> Optional[bytes]: + try: + v = self._data[row][col] + if isinstance(v, bytes): + return v + if isinstance(v, str): + return v.encode("utf-8") + return None + except IndexError: + return None + + def isNull(self, row: int, col: int) -> bool: + try: + return self._data[row][col] is None + except IndexError: + return True + + def clear(self): + self._data.clear() + self._num_rows = 0 + + def toString(self) -> str: + return f"CursorWindow(name={self._name}, rows={self._num_rows}, cols={self._num_columns})" + + +# ═══════════════════════════════════════════════════════════════ +# Cursor interface +# ═══════════════════════════════════════════════════════════════ + +class Cursor(Stub): + """Cursor — 游标接口""" + + FIELD_TYPE_NULL = 0 + FIELD_TYPE_INTEGER = 1 + FIELD_TYPE_FLOAT = 2 + FIELD_TYPE_STRING = 3 + FIELD_TYPE_BLOB = 4 + + def __init__(self): + super().__init__() + self._pos: int = -1 + self._closed: bool = False + + def getCount(self) -> int: + return 0 + + def getPosition(self) -> int: + return self._pos + + def moveToFirst(self) -> bool: + return self.moveToPosition(0) + + def moveToLast(self) -> bool: + return self.moveToPosition(self.getCount() - 1) + + def moveToNext(self) -> bool: + return self.moveToPosition(self._pos + 1) + + def moveToPrevious(self) -> bool: + return self.moveToPosition(self._pos - 1) + + def move(self, offset: int) -> bool: + return self.moveToPosition(self._pos + offset) + + def moveToPosition(self, position: int) -> bool: + if position < -1 or position >= self.getCount(): + return False + self._pos = position + return True + + def isFirst(self) -> bool: + return self._pos == 0 + + def isLast(self) -> bool: + return self._pos == self.getCount() - 1 + + def isBeforeFirst(self) -> bool: + return self._pos < 0 + + def isAfterLast(self) -> bool: + return self._pos >= self.getCount() + + def getColumnIndex(self, column_name: str) -> int: + names = self.getColumnNames() + try: + return names.index(column_name) + except ValueError: + return -1 + + def getColumnIndexOrThrow(self, column_name: str) -> int: + idx = self.getColumnIndex(column_name) + if idx < 0: + raise IllegalArgumentException(f"Column '{column_name}' does not exist") + return idx + + def getColumnName(self, column_index: int) -> str: + names = self.getColumnNames() + if 0 <= column_index < len(names): + return names[column_index] + return "" + + def getColumnNames(self) -> List[str]: + return [] + + def getType(self, column_index: int) -> int: + return self.FIELD_TYPE_NULL + + def getString(self, column_index: int) -> Optional[str]: + return None + + def getInt(self, column_index: int) -> int: + return 0 + + def getLong(self, column_index: int) -> int: + return 0 + + def getFloat(self, column_index: int) -> float: + return 0.0 + + def getDouble(self, column_index: int) -> float: + return 0.0 + + def getShort(self, column_index: int) -> int: + return 0 + + def getBlob(self, column_index: int) -> Optional[bytes]: + return None + + def getBytes(self, column_index: int) -> Optional[bytes]: + return self.getBlob(column_index) + + def close(self): + self._closed = True + + def isClosed(self) -> bool: + return self._closed + + def requery(self) -> bool: + return False + + def deactivate(self): + pass + + def registerContentObserver(self, observer: ContentObserver): + pass + + def unregisterContentObserver(self, observer: ContentObserver): + pass + + def registerDataSetObserver(self, observer: DataSetObserver): + pass + + def unregisterDataSetObserver(self, observer: DataSetObserver): + pass + + def getWantsAllOnMoveCalls(self) -> bool: + return False + + def getExtras(self) -> Any: + return None + + def respond(self, extras: Any) -> Any: + return None + + def setNotificationUri(self, cr: Any, uri: Any): + pass + + def getNotificationUri(self) -> Any: + return None + + def fillWindow(self, pos: int, window: CursorWindow): + pass + + def copyStringToBuffer(self, column_index: int, buffer: CharArrayBuffer): + val = self.getString(column_index) + if val is not None: + buffer.data = list(val) + + def isNull(self, column_index: int) -> bool: + return self.getType(column_index) == self.FIELD_TYPE_NULL + + +# ═══════════════════════════════════════════════════════════════ +# AbstractCursor +# ═══════════════════════════════════════════════════════════════ + +class AbstractCursor(Cursor): + """AbstractCursor — 游标抽象基类""" + + def __init__(self): + super().__init__() + self._content_observable = ContentObservable() + self._data_set_observable = DataSetObservable() + self._notification_uri: Any = None + self._self_observer: Optional[ContentObserver] = None + + def getCount(self) -> int: + return 0 + + def getColumnNames(self) -> List[str]: + return [] + + def registerContentObserver(self, observer: ContentObserver): + self._content_observable.registerObserver(observer) + + def unregisterContentObserver(self, observer: ContentObserver): + self._content_observable.unregisterObserver(observer) + + def registerDataSetObserver(self, observer: DataSetObserver): + self._data_set_observable.registerObserver(observer) + + def unregisterDataSetObserver(self, observer: DataSetObserver): + self._data_set_observable.unregisterObserver(observer) + + def setNotificationUri(self, cr: Any, uri: Any): + self._notification_uri = uri + + def getNotificationUri(self) -> Any: + return self._notification_uri + + def onChange(self, self_change: bool): + self._content_observable.dispatchChange(self_change) + + def getWantsAllOnMoveCalls(self) -> bool: + return False + + def getExtras(self) -> Any: + return None + + def respond(self, extras: Any) -> Any: + return None + + def fillWindow(self, pos: int, window: CursorWindow): + pass + + +# ═══════════════════════════════════════════════════════════════ +# AbstractWindowedCursor +# ═══════════════════════════════════════════════════════════════ + +class AbstractWindowedCursor(AbstractCursor): + """AbstractWindowedCursor — 带窗口的游标""" + + def __init__(self): + super().__init__() + self._window: Optional[CursorWindow] = None + + def getWindow(self) -> Optional[CursorWindow]: + return self._window + + def setWindow(self, window: CursorWindow): + self._window = window + + def hasWindow(self) -> bool: + return self._window is not None + + def clearBlobCache(self): + pass + + def fillWindow(self, pos: int, window: CursorWindow): + if self._window: + self._window.clear() + + def getString(self, column_index: int) -> Optional[str]: + if self._window and self._pos >= 0: + return self._window.getString(self._pos, column_index) + return None + + def getInt(self, column_index: int) -> int: + if self._window and self._pos >= 0: + return self._window.getLong(self._pos, column_index) + return 0 + + def getLong(self, column_index: int) -> int: + if self._window and self._pos >= 0: + return self._window.getLong(self._pos, column_index) + return 0 + + def getFloat(self, column_index: int) -> float: + if self._window and self._pos >= 0: + return self._window.getDouble(self._pos, column_index) + return 0.0 + + def getDouble(self, column_index: int) -> float: + if self._window and self._pos >= 0: + return self._window.getDouble(self._pos, column_index) + return 0.0 + + def getBlob(self, column_index: int) -> Optional[bytes]: + if self._window and self._pos >= 0: + return self._window.getBlob(self._pos, column_index) + return None + + def isNull(self, column_index: int) -> bool: + if self._window and self._pos >= 0: + return self._window.isNull(self._pos, column_index) + return True + + +# ═══════════════════════════════════════════════════════════════ +# CursorWrapper +# ═══════════════════════════════════════════════════════════════ + +class CursorWrapper(Cursor): + """CursorWrapper — 游标包装器""" + + def __init__(self, cursor: Cursor): + super().__init__() + self._wrapped_cursor = cursor + + def getWrappedCursor(self) -> Cursor: + return self._wrapped_cursor + + def getCount(self) -> int: + return self._wrapped_cursor.getCount() + + def getPosition(self) -> int: + return self._wrapped_cursor.getPosition() + + def moveToFirst(self) -> bool: + return self._wrapped_cursor.moveToFirst() + + def moveToLast(self) -> bool: + return self._wrapped_cursor.moveToLast() + + def moveToNext(self) -> bool: + return self._wrapped_cursor.moveToNext() + + def moveToPrevious(self) -> bool: + return self._wrapped_cursor.moveToPrevious() + + def move(self, offset: int) -> bool: + return self._wrapped_cursor.move(offset) + + def moveToPosition(self, position: int) -> bool: + return self._wrapped_cursor.moveToPosition(position) + + def getColumnNames(self) -> List[str]: + return self._wrapped_cursor.getColumnNames() + + def getColumnIndex(self, column_name: str) -> int: + return self._wrapped_cursor.getColumnIndex(column_name) + + def getColumnIndexOrThrow(self, column_name: str) -> int: + return self._wrapped_cursor.getColumnIndexOrThrow(column_name) + + def getString(self, column_index: int) -> Optional[str]: + return self._wrapped_cursor.getString(column_index) + + def getInt(self, column_index: int) -> int: + return self._wrapped_cursor.getInt(column_index) + + def getLong(self, column_index: int) -> int: + return self._wrapped_cursor.getLong(column_index) + + def getFloat(self, column_index: int) -> float: + return self._wrapped_cursor.getFloat(column_index) + + def getDouble(self, column_index: int) -> float: + return self._wrapped_cursor.getDouble(column_index) + + def getShort(self, column_index: int) -> int: + return self._wrapped_cursor.getShort(column_index) + + def getBlob(self, column_index: int) -> Optional[bytes]: + return self._wrapped_cursor.getBlob(column_index) + + def close(self): + self._wrapped_cursor.close() + + def isClosed(self) -> bool: + return self._wrapped_cursor.isClosed() + + def registerContentObserver(self, observer: ContentObserver): + self._wrapped_cursor.registerContentObserver(observer) + + def unregisterContentObserver(self, observer: ContentObserver): + self._wrapped_cursor.unregisterContentObserver(observer) + + def registerDataSetObserver(self, observer: DataSetObserver): + self._wrapped_cursor.registerDataSetObserver(observer) + + def unregisterDataSetObserver(self, observer: DataSetObserver): + self._wrapped_cursor.unregisterDataSetObserver(observer) + + def getWantsAllOnMoveCalls(self) -> bool: + return self._wrapped_cursor.getWantsAllOnMoveCalls() + + +# ═══════════════════════════════════════════════════════════════ +# CrossProcessCursor / CrossProcessCursorWrapper +# ═══════════════════════════════════════════════════════════════ + +class CrossProcessCursor(Cursor): + """CrossProcessCursor — 跨进程游标""" + + def fillWindow(self, pos: int, window: CursorWindow): + pass + + def getWindow(self) -> Optional[CursorWindow]: + return None + + def onMove(self, old_position: int, new_position: int) -> bool: + return True + + +class CrossProcessCursorWrapper(CursorWrapper): + """CrossProcessCursorWrapper — 跨进程游标包装器""" + + def __init__(self, cursor: Cursor): + super().__init__(cursor) + self._cursor = cursor + + def fillWindow(self, pos: int, window: CursorWindow): + if isinstance(self._cursor, CrossProcessCursor): + self._cursor.fillWindow(pos, window) + + def getWindow(self) -> Optional[CursorWindow]: + if isinstance(self._cursor, CrossProcessCursor): + return self._cursor.getWindow() + return None + + def onMove(self, old_position: int, new_position: int) -> bool: + if isinstance(self._cursor, CrossProcessCursor): + return self._cursor.onMove(old_position, new_position) + return True + + +# ═══════════════════════════════════════════════════════════════ +# MatrixCursor +# ═══════════════════════════════════════════════════════════════ + +class MatrixCursor(AbstractCursor): + """MatrixCursor — 内存矩阵游标""" + + class RowBuilder(Stub): + """RowBuilder — 行构建器""" + + def __init__(self, cursor: "MatrixCursor", row_index: int): + super().__init__() + self._cursor = cursor + self._row_index = row_index + + def add(self, column_value: Any) -> "MatrixCursor.RowBuilder": + self._cursor._add_row_value(self._row_index, column_value) + return self + + def __init__(self, column_names: List[str], initial_capacity: int = 0): + super().__init__() + self._column_names = list(column_names) + self._rows: List[List[Optional[Any]]] = [] + self._num_columns = len(column_names) + + def _add_row_value(self, row_index: int, value: Any): + while len(self._rows) <= row_index: + self._rows.append([]) + self._rows[row_index].append(value) + + def addRow(self, values: Union[List[Any], Tuple[Any, ...]]) -> None: + row = list(values) + [None] * (self._num_columns - len(values)) + self._rows.append(row[:self._num_columns]) + + def newRow(self) -> RowBuilder: + row_index = len(self._rows) + self._rows.append([]) + return MatrixCursor.RowBuilder(self, row_index) + + def getCount(self) -> int: + return len(self._rows) + + def getColumnNames(self) -> List[str]: + return list(self._column_names) + + def getString(self, column_index: int) -> Optional[str]: + if self._pos < 0 or self._pos >= len(self._rows): + return None + if column_index < 0 or column_index >= len(self._rows[self._pos]): + return None + v = self._rows[self._pos][column_index] + return str(v) if v is not None else None + + def getInt(self, column_index: int) -> int: + v = self.getString(column_index) + if v is None: + return 0 + try: + return int(float(v)) + except (ValueError, TypeError): + return 0 + + def getLong(self, column_index: int) -> int: + return self.getInt(column_index) + + def getFloat(self, column_index: int) -> float: + v = self.getString(column_index) + if v is None: + return 0.0 + try: + return float(v) + except (ValueError, TypeError): + return 0.0 + + def getDouble(self, column_index: int) -> float: + return self.getFloat(column_index) + + def getBlob(self, column_index: int) -> Optional[bytes]: + if self._pos < 0 or self._pos >= len(self._rows): + return None + if column_index < 0 or column_index >= len(self._rows[self._pos]): + return None + v = self._rows[self._pos][column_index] + if isinstance(v, bytes): + return v + if isinstance(v, str): + return v.encode("utf-8") + return None + + def getType(self, column_index: int) -> int: + v = None + if 0 <= self._pos < len(self._rows): + row = self._rows[self._pos] + if 0 <= column_index < len(row): + v = row[column_index] + if v is None: + return Cursor.FIELD_TYPE_NULL + if isinstance(v, int): + return Cursor.FIELD_TYPE_INTEGER + if isinstance(v, float): + return Cursor.FIELD_TYPE_FLOAT + if isinstance(v, bytes): + return Cursor.FIELD_TYPE_BLOB + return Cursor.FIELD_TYPE_STRING + + def isNull(self, column_index: int) -> bool: + return self.getType(column_index) == Cursor.FIELD_TYPE_NULL + + def toString(self) -> str: + return f"MatrixCursor(cols={self._column_names}, rows={len(self._rows)})" + + +# ═══════════════════════════════════════════════════════════════ +# MergeCursor +# ═══════════════════════════════════════════════════════════════ + +class MergeCursor(AbstractCursor): + """MergeCursor — 合并多个游标""" + + def __init__(self, cursors: List[Cursor]): + super().__init__() + self._cursors = cursors + self._cursor_index = 0 + self._current_cursor: Optional[Cursor] = None + + def getCount(self) -> int: + return sum(c.getCount() for c in self._cursors) + + def getColumnNames(self) -> List[str]: + if self._cursors: + return self._cursors[0].getColumnNames() + return [] + + def moveToPosition(self, position: int) -> bool: + if position < -1: + return False + if position >= self.getCount(): + return False + offset = 0 + for i, c in enumerate(self._cursors): + count = c.getCount() + if position < offset + count: + self._cursor_index = i + self._current_cursor = c + return c.moveToPosition(position - offset) + offset += count + return False + + def getString(self, column_index: int) -> Optional[str]: + if self._current_cursor and self._pos >= 0: + return self._current_cursor.getString(column_index) + return None + + def getInt(self, column_index: int) -> int: + if self._current_cursor and self._pos >= 0: + return self._current_cursor.getInt(column_index) + return 0 + + def close(self): + for c in self._cursors: + c.close() + super().close() + + +# ═══════════════════════════════════════════════════════════════ +# CursorJoiner +# ═══════════════════════════════════════════════════════════════ + +class CursorJoiner(Stub): + """CursorJoiner — 游标连接器""" + + class Result(Stub): + BOTH = 0 + LEFT = 1 + RIGHT = 2 + + def __init__(self, cursor_a: Cursor, column_names_a: List[str], + cursor_b: Cursor, column_names_b: List[str]): + super().__init__() + self._cursor_a = cursor_a + self._cursor_b = cursor_b + self._col_names_a = column_names_a + self._col_names_b = column_names_b + self._has_next = False + + def hasNext(self) -> bool: + return self._has_next + + def next(self) -> int: + return self.Result.BOTH + + +# ═══════════════════════════════════════════════════════════════ +# DatabaseUtils +# ═══════════════════════════════════════════════════════════════ + +class DatabaseUtils(Stub): + """DatabaseUtils — 数据库工具""" + + STATEMENT_ABORT = "ABORT" + STATEMENT_FAIL = "FAIL" + STATEMENT_IGNORE = "IGNORE" + STATEMENT_REPLACE = "REPLACE" + STATEMENT_ROLLBACK = "ROLLBACK" + + @staticmethod + def cursorFillWindow(cursor: Cursor, pos: int, window: CursorWindow): + cursor.fillWindow(pos, window) + + @staticmethod + def cursorStringToContentValues(cursor: Cursor, field: str, values: Any): + pass + + @staticmethod + def cursorIntToContentValues(cursor: Cursor, field: str, values: Any): + pass + + @staticmethod + def cursorLongToContentValues(cursor: Cursor, field: str, values: Any): + pass + + @staticmethod + def cursorDoubleToContentValues(cursor: Cursor, field: str, values: Any): + pass + + @staticmethod + def cursorRowToContentValues(cursor: Cursor, values: Any): + for col_name in cursor.getColumnNames(): + idx = cursor.getColumnIndex(col_name) + val = cursor.getString(idx) + if hasattr(values, "put"): + values.put(col_name, val) + + @staticmethod + def dumpCursor(cursor: Cursor): + col_names = cursor.getColumnNames() + sys.stderr.write(f"Rows: {cursor.getCount()}\n") + sys.stderr.write(f"Columns: {col_names}\n") + + @staticmethod + def dumpCursorToString(cursor: Cursor) -> str: + return f"Cursor(count={cursor.getCount()})" + + @staticmethod + def bindObjectToProgram(program: Any, index: int, value: Any): + pass + + @staticmethod + def cursorToContentValues(cursor: Cursor, values: Any): + DatabaseUtils.cursorRowToContentValues(cursor, values) + + @staticmethod + def longForQuery(db: Any, query: str, args: Optional[List[str]] = None) -> int: + return 0 + + @staticmethod + def stringForQuery(db: Any, query: str, args: Optional[List[str]] = None) -> Optional[str]: + return None + + @staticmethod + def blobForQuery(db: Any, query: str, args: Optional[List[str]] = None) -> Optional[bytes]: + return None + + @staticmethod + def sqlEscapeString(value: str) -> str: + return value.replace("'", "''") + + @staticmethod + def appendEscapedSQLString(sb: Any, value: str): + escaped = DatabaseUtils.sqlEscapeString(value) + sb.append(f"'{escaped}'") + + @staticmethod + def appendValueToSql(sb: Any, value: Any): + if value is None: + sb.append("NULL") + elif isinstance(value, bool): + sb.append("1" if value else "0") + elif isinstance(value, (int, float)): + sb.append(str(value)) + else: + DatabaseUtils.appendEscapedSQLString(sb, str(value)) + + @staticmethod + def appendSelectionArgs(original_values: List[str], new_values: List[str]) -> List[str]: + return list(original_values) + list(new_values) + + @staticmethod + def getCollationKey(name: str) -> str: + return name.lower() + + @staticmethod + def getHexCollationKey(name: str) -> str: + return name.lower().encode("utf-8").hex() + + @staticmethod + def createDbFromSqlStatements(context: Any, db_name: str, db_version: int, sql_statements: str): + from .database_sqlite import SQLiteDatabase + db_path = os.path.join(_app_data_dir, "databases", db_name) + os.makedirs(os.path.dirname(db_path), exist_ok=True) + db = SQLiteDatabase.openOrCreateDatabase(db_path, None) + for stmt in sql_statements.split(";"): + stmt = stmt.strip() + if stmt: + try: + db.execSQL(stmt) + except Exception: + pass + return db + + +# ═══════════════════════════════════════════════════════════════ +# DatabaseUtilsInsertHelper +# ═══════════════════════════════════════════════════════════════ + +class DatabaseUtilsInsertHelper(Stub): + """DatabaseUtils.InsertHelper — 插入辅助类""" + + TABLE_INFO_PRAGMA_COLUMNNAME_INDEX = 1 + + def __init__(self, db: Any, table_name: str): + super().__init__() + self._db = db + self._table_name = table_name + + def getTableName(self) -> str: + return self._table_name + + def prepareForInsert(self) -> int: + return 0 + + def prepareForReplace(self) -> int: + return 0 + + def bind(self, index: int, value: Any): + pass + + def execute(self) -> int: + return 0 + + def close(self): + pass + + +# ═══════════════════════════════════════════════════════════════ +# Helper +# ═══════════════════════════════════════════════════════════════ + +class IllegalArgumentException(RuntimeError): + """IllegalArgumentException — 非法参数异常""" + pass + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "Cursor", + "MatrixCursor", + "AbstractCursor", + "AbstractWindowedCursor", + "ContentObservable", + "ContentObserver", + "DataSetObservable", + "DatabaseErrorHandler", + "DatabaseUtils", + "DefaultDatabaseErrorHandler", + "CharArrayBuffer", + "CursorJoiner", + "CursorWindow", + "CursorWrapper", + "CrossProcessCursor", + "CrossProcessCursorWrapper", + "DataSetObserver", + "MergeCursor", + "SQLException", + "CursorIndexOutOfBoundsException", + "DatabaseUtilsInsertHelper", +] \ No newline at end of file diff --git a/android_pyapi/android/database_sqlite.py b/android_pyapi/android/database_sqlite.py new file mode 100644 index 0000000..9b2fa5a --- /dev/null +++ b/android_pyapi/android/database_sqlite.py @@ -0,0 +1,965 @@ +""" +Android SQLite 组件 — SQLiteDatabase, SQLiteOpenHelper, SQLiteStatement 等 +使用 Python sqlite3 模块作为后端 +方法签名完全对齐 Android SDK +""" + +import os +import sys +import threading +import sqlite3 as _sqlite3 +from typing import Any, Dict, List, Optional, Set, Tuple, Union + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, + _sdcard_root, _app_data_dir, _package_name, +) +from .database import ( + Cursor, AbstractCursor, ContentObserver, DataSetObserver, SQLException as BaseSQLException, +) + + +# ═══════════════════════════════════════════════════════════════ +# SQLiteException hierarchy +# ═══════════════════════════════════════════════════════════════ + +class SQLiteException(BaseSQLException): + """SQLiteException — SQLite 异常基类""" + + def __init__(self, message: str = ""): + super().__init__(message) + self._error_message = message + + +class SQLiteAbortException(SQLiteException): + pass + + +class SQLiteAccessPermException(SQLiteException): + pass + + +class SQLiteBindOrColumnIndexOutOfRangeException(SQLiteException): + pass + + +class SQLiteBlobTooBigException(SQLiteException): + pass + + +class SQLiteCantOpenDatabaseException(SQLiteException): + pass + + +class SQLiteConstraintException(SQLiteException): + pass + + +class SQLiteDatabaseCorruptException(SQLiteException): + pass + + +class SQLiteDatabaseLockedException(SQLiteException): + pass + + +class SQLiteDatatypeMismatchException(SQLiteException): + pass + + +class SQLiteDiskIOException(SQLiteException): + pass + + +class SQLiteDoneException(SQLiteException): + pass + + +class SQLiteException_General(SQLiteException): + pass + + +class SQLiteFullException(SQLiteException): + pass + + +class SQLiteMisuseException(SQLiteException): + pass + + +class SQLiteOutOfMemoryException(SQLiteException): + pass + + +class SQLiteReadOnlyDatabaseException(SQLiteException): + pass + + +class SQLiteTableLockedException(SQLiteException): + pass + + +class SQLiteUnsupportedOperationException(SQLiteException): + pass + + +# ═══════════════════════════════════════════════════════════════ +# SQLiteClosable +# ═══════════════════════════════════════════════════════════════ + +class SQLiteClosable(Stub): + """SQLiteClosable — 可关闭资源基类""" + + def __init__(self): + super().__init__() + self._closed = False + self._reference_count = 1 + + def acquireReference(self): + if self._closed: + raise IllegalStateException("already closed") + self._reference_count += 1 + + def releaseReference(self): + self._reference_count -= 1 + if self._reference_count <= 0: + self.onAllReferencesReleased() + + def releaseReferenceFromContainer(self): + self.releaseReference() + + def onAllReferencesReleased(self): + self.close() + + def close(self): + self._closed = True + + def isClosed(self) -> bool: + return self._closed + + +class IllegalStateException(RuntimeError): + pass + + +# ═══════════════════════════════════════════════════════════════ +# SQLiteProgram +# ═══════════════════════════════════════════════════════════════ + +class SQLiteProgram(SQLiteClosable): + """SQLiteProgram — SQL 程序基类""" + + def __init__(self, db: "SQLiteDatabase", sql: str): + super().__init__() + self._db = db + self._sql = sql + self._bindings: Dict[int, Any] = {} + self._next_bind_index = 1 + + def getDatabase(self) -> "SQLiteDatabase": + return self._db + + def getSql(self) -> str: + return self._sql + + def bindNull(self, index: int): + self._bindings[index] = None + + def bindLong(self, index: int, value: int): + self._bindings[index] = value + + def bindDouble(self, index: int, value: float): + self._bindings[index] = value + + def bindString(self, index: int, value: str): + self._bindings[index] = value + + def bindBlob(self, index: int, value: bytes): + self._bindings[index] = value + + def clearBindings(self): + self._bindings.clear() + + def _bind_parameters(self, cursor: _sqlite3.Cursor): + for idx, val in sorted(self._bindings.items()): + cursor.execute(f"PRAGMA dummy={idx}") + + +# ═══════════════════════════════════════════════════════════════ +# SQLiteStatement +# ═══════════════════════════════════════════════════════════════ + +class SQLiteStatement(SQLiteProgram): + """SQLiteStatement — 预编译语句""" + + def __init__(self, db: "SQLiteDatabase", sql: str): + super().__init__(db, sql) + + def execute(self): + try: + conn = self._db._acquire_connection() + cursor = conn.execute(self._sql, list(self._bindings.values())) + conn.commit() + except _sqlite3.DatabaseError as e: + raise _map_sqlite_error(str(e), self._sql) + + def executeUpdateDelete(self) -> int: + try: + conn = self._db._acquire_connection() + cursor = conn.execute(self._sql, list(self._bindings.values())) + conn.commit() + return cursor.rowcount + except _sqlite3.DatabaseError as e: + raise _map_sqlite_error(str(e), self._sql) + + def executeInsert(self) -> int: + try: + conn = self._db._acquire_connection() + cursor = conn.execute(self._sql, list(self._bindings.values())) + conn.commit() + return cursor.lastrowid + except _sqlite3.DatabaseError as e: + raise _map_sqlite_error(str(e), self._sql) + + def simpleQueryForLong(self) -> int: + try: + conn = self._db._acquire_connection() + cursor = conn.execute(self._sql, list(self._bindings.values())) + row = cursor.fetchone() + conn.commit() + if row: + return int(row[0]) if row[0] is not None else 0 + raise SQLiteDoneException("no results") + except _sqlite3.DatabaseError as e: + raise _map_sqlite_error(str(e), self._sql) + + def simpleQueryForString(self) -> Optional[str]: + try: + conn = self._db._acquire_connection() + cursor = conn.execute(self._sql, list(self._bindings.values())) + row = cursor.fetchone() + conn.commit() + if row: + return str(row[0]) if row[0] is not None else None + raise SQLiteDoneException("no results") + except _sqlite3.DatabaseError as e: + raise _map_sqlite_error(str(e), self._sql) + + +# ═══════════════════════════════════════════════════════════════ +# SQLiteQuery +# ═══════════════════════════════════════════════════════════════ + +class SQLiteQuery(SQLiteProgram): + """SQLiteQuery — 查询对象""" + + def __init__(self, db: "SQLiteDatabase", sql: str): + super().__init__(db, sql) + + def toString(self) -> str: + return f"SQLiteQuery: {self._sql}" + + def sql(self) -> str: + return self._sql + + def bind(self, index: int, value: Any): + self._bindings[index] = value + + +# ═══════════════════════════════════════════════════════════════ +# SQLiteCursor +# ═══════════════════════════════════════════════════════════════ + +class SQLiteCursor(AbstractCursor): + """SQLiteCursor — SQLite 游标实现""" + + def __init__(self, db: "SQLiteDatabase", query: SQLiteQuery): + super().__init__() + self._db = db + self._query = query + self._column_names: List[str] = [] + self._rows: List[List[Any]] = [] + self._current_row: Optional[List[Any]] = None + self._loaded = False + self._closed = False + + def _load(self): + if self._loaded or self._closed: + return + self._loaded = True + try: + conn = self._db._acquire_connection() + cursor = conn.execute(self._query.getSql(), list(self._query._bindings.values())) + self._column_names = [desc[0] for desc in cursor.description] if cursor.description else [] + self._rows = cursor.fetchall() + except _sqlite3.DatabaseError as e: + raise _map_sqlite_error(str(e), self._query.getSql()) + + def getCount(self) -> int: + self._load() + return len(self._rows) + + def getColumnNames(self) -> List[str]: + self._load() + return list(self._column_names) + + def getColumnIndex(self, column_name: str) -> int: + self._load() + try: + return self._column_names.index(column_name) + except ValueError: + return -1 + + def moveToPosition(self, position: int) -> bool: + self._load() + if position < -1 or position >= len(self._rows): + return False + self._pos = position + if 0 <= position < len(self._rows): + self._current_row = self._rows[position] + else: + self._current_row = None + return True + + def getString(self, column_index: int) -> Optional[str]: + if self._current_row is None or column_index < 0 or column_index >= len(self._current_row): + return None + v = self._current_row[column_index] + return str(v) if v is not None else None + + def getInt(self, column_index: int) -> int: + if self._current_row is None or column_index < 0 or column_index >= len(self._current_row): + return 0 + v = self._current_row[column_index] + if v is None: + return 0 + try: + return int(v) + except (ValueError, TypeError): + return 0 + + def getLong(self, column_index: int) -> int: + return self.getInt(column_index) + + def getFloat(self, column_index: int) -> float: + if self._current_row is None or column_index < 0 or column_index >= len(self._current_row): + return 0.0 + v = self._current_row[column_index] + if v is None: + return 0.0 + try: + return float(v) + except (ValueError, TypeError): + return 0.0 + + def getDouble(self, column_index: int) -> float: + return self.getFloat(column_index) + + def getShort(self, column_index: int) -> int: + return self.getInt(column_index) + + def getBlob(self, column_index: int) -> Optional[bytes]: + if self._current_row is None or column_index < 0 or column_index >= len(self._current_row): + return None + v = self._current_row[column_index] + if isinstance(v, bytes): + return v + if v is not None: + return bytes(str(v), "utf-8") + return None + + def getType(self, column_index: int) -> int: + self._load() + if self._current_row is None or column_index < 0 or column_index >= len(self._current_row): + return Cursor.FIELD_TYPE_NULL + v = self._current_row[column_index] + if v is None: + return Cursor.FIELD_TYPE_NULL + if isinstance(v, int): + return Cursor.FIELD_TYPE_INTEGER + if isinstance(v, float): + return Cursor.FIELD_TYPE_FLOAT + if isinstance(v, bytes): + return Cursor.FIELD_TYPE_BLOB + return Cursor.FIELD_TYPE_STRING + + def isNull(self, column_index: int) -> bool: + return self.getType(column_index) == Cursor.FIELD_TYPE_NULL + + def close(self): + self._closed = True + self._rows.clear() + self._current_row = None + + def requery(self) -> bool: + self._loaded = False + self._rows.clear() + self._current_row = None + self._pos = -1 + return True + + +# ═══════════════════════════════════════════════════════════════ +# SQLiteQueryBuilder +# ═══════════════════════════════════════════════════════════════ + +class SQLiteQueryBuilder(Stub): + """SQLiteQueryBuilder — 查询构建器""" + + def __init__(self): + super().__init__() + self._tables: str = "" + self._distinct: bool = False + self._where: Optional[str] = None + + def setTables(self, tables: str): + self._tables = tables + + def getTables(self) -> str: + return self._tables + + def appendWhere(self, where: str): + if self._where: + self._where = f"({self._where}) AND ({where})" + else: + self._where = where + + def appendWhereStandalone(self, where: str): + self._where = where + + def setDistinct(self, distinct: bool): + self._distinct = distinct + + def buildQueryString(self, distinct: bool, tables: str, + columns: Optional[List[str]], where: Optional[str], + group_by: Optional[str], having: Optional[str], + order_by: Optional[str], limit: Optional[str]) -> str: + sql = "SELECT " + if distinct: + sql += "DISTINCT " + if columns and len(columns) > 0: + sql += ", ".join(columns) + else: + sql += "*" + sql += f" FROM {tables}" + if where: + sql += f" WHERE ({where})" + if group_by: + sql += f" GROUP BY {group_by}" + if having: + sql += f" HAVING {having}" + if order_by: + sql += f" ORDER BY {order_by}" + if limit: + sql += f" LIMIT {limit}" + return sql + + def buildQuery(self, columns: Optional[List[str]], where: Optional[str], + group_by: Optional[str], having: Optional[str], + order_by: Optional[str], limit: Optional[str]) -> str: + return self.buildQueryString(self._distinct, self._tables, + columns, where or self._where, + group_by, having, order_by, limit) + + def query(self, db: "SQLiteDatabase", columns: Optional[List[str]], + where: Optional[str], group_by: Optional[str], + having: Optional[str], order_by: Optional[str], + limit: Optional[str]) -> SQLiteCursor: + sql = self.buildQuery(columns, where, group_by, having, order_by, limit) + return db.rawQuery(sql, None) + + +# ═══════════════════════════════════════════════════════════════ +# SQLiteDatabase +# ═══════════════════════════════════════════════════════════════ + +def _map_sqlite_error(msg: str, sql: str = "") -> SQLiteException: + msg_lower = msg.lower() + if "constraint" in msg_lower: + return SQLiteConstraintException(msg) + if "locked" in msg_lower: + return SQLiteDatabaseLockedException(msg) + if "corrupt" in msg_lower: + return SQLiteDatabaseCorruptException(msg) + if "readonly" in msg_lower or "read only" in msg_lower: + return SQLiteReadOnlyDatabaseException(msg) + if "disk" in msg_lower or "full" in msg_lower: + return SQLiteDiskIOException(msg) if "disk" in msg_lower else SQLiteFullException(msg) + if "abort" in msg_lower: + return SQLiteAbortException(msg) + if "permission" in msg_lower: + return SQLiteAccessPermException(msg) + if "out of memory" in msg_lower: + return SQLiteOutOfMemoryException(msg) + if "not a database" in msg_lower or "cantopen" in msg_lower: + return SQLiteCantOpenDatabaseException(msg) + if "misuse" in msg_lower: + return SQLiteMisuseException(msg) + return SQLiteException(msg) + + +class SQLiteDatabase(SQLiteClosable): + """SQLiteDatabase — 数据库操作类""" + + CONFLICT_ROLLBACK = 1 + CONFLICT_ABORT = 2 + CONFLICT_FAIL = 3 + CONFLICT_IGNORE = 4 + CONFLICT_REPLACE = 5 + + OPEN_READWRITE = 0 + OPEN_READONLY = 1 + CREATE_IF_NECESSARY = 268435456 + NO_LOCALIZED_COLLATORS = 16 + + _db_registry: Dict[str, "SQLiteDatabase"] = {} + _lock = threading.Lock() + + def __init__(self, path: str, flags: int = 0): + super().__init__() + self._path = path + self._flags = flags + self._conn: Optional[_sqlite3.Connection] = None + self._in_transaction = False + self._transaction_successful = False + self._version: int = 0 + self._max_size: int = 0 + self._page_size: int = 4096 + self._enable_wal = False + self._attached_dbs: List[Dict[str, Any]] = [] + + @staticmethod + def openDatabase(path: str, cursor_factory: Any = None, + flags: int = 0, error_handler: Any = None) -> "SQLiteDatabase": + db = SQLiteDatabase(path, flags) + try: + db._conn = _sqlite3.connect(path) + db._conn.execute("PRAGMA journal_mode=WAL") + conn_cursor = db._conn.execute("PRAGMA schema_version") + row = conn_cursor.fetchone() + if row: + db._version = row[0] + except _sqlite3.DatabaseError as e: + raise _map_sqlite_error(str(e)) + SQLiteDatabase._db_registry[path] = db + return db + + @staticmethod + def openOrCreateDatabase(path: str, cursor_factory: Any = None, + error_handler: Any = None) -> "SQLiteDatabase": + return SQLiteDatabase.openDatabase(path, cursor_factory, + SQLiteDatabase.CREATE_IF_NECESSARY, error_handler) + + @staticmethod + def create(cursor_factory: Any = None, error_handler: Any = None) -> "SQLiteDatabase": + import tempfile + tmp = tempfile.NamedTemporaryFile(suffix=".db", delete=False) + tmp.close() + return SQLiteDatabase.openOrCreateDatabase(tmp.name, cursor_factory, error_handler) + + @staticmethod + def deleteDatabase(path: str) -> bool: + try: + if path in SQLiteDatabase._db_registry: + db = SQLiteDatabase._db_registry[path] + db.close() + del SQLiteDatabase._db_registry[path] + os.remove(path) + wal_path = path + "-wal" + if os.path.exists(wal_path): + os.remove(wal_path) + shm_path = path + "-shm" + if os.path.exists(shm_path): + os.remove(shm_path) + return True + except (OSError, Exception): + return False + + @staticmethod + def databaseList() -> List[str]: + return list(SQLiteDatabase._db_registry.keys()) + + def _acquire_connection(self) -> _sqlite3.Connection: + if self._conn is None: + raise SQLiteCantOpenDatabaseException("Database not open") + return self._conn + + def execSQL(self, sql: str, bind_args: Optional[List[Any]] = None): + self._ensure_open() + try: + conn = self._acquire_connection() + args = bind_args or [] + conn.execute(sql, args) + if not self._in_transaction: + conn.commit() + except _sqlite3.DatabaseError as e: + raise _map_sqlite_error(str(e), sql) + + def rawQuery(self, sql: str, selection_args: Optional[List[Any]] = None) -> SQLiteCursor: + self._ensure_open() + query = SQLiteQuery(self, sql) + if selection_args: + for i, arg in enumerate(selection_args): + query.bind(i + 1, arg) + cursor = SQLiteCursor(self, query) + return cursor + + def insert(self, table: str, null_column_hack: Optional[str], + values: Any) -> int: + self._ensure_open() + if values is None: + return -1 + cols = [] + vals = [] + if hasattr(values, "valueSet"): + items = list(values.valueSet()) + elif hasattr(values, "key_set"): + items = [(k, getattr(values, f"get{k[0].upper()}{k[1:]}", lambda: None)()) + for k in values.key_set()] + elif isinstance(values, dict): + items = list(values.items()) + else: + return -1 + for k, v in items: + cols.append(str(k)) + vals.append(v) + if len(cols) == 0: + cols = ["_id"] + vals = [None] + col_str = ", ".join(cols) + placeholders = ", ".join(["?"] * len(vals)) + sql = f"INSERT INTO {table} ({col_str}) VALUES ({placeholders})" + try: + conn = self._acquire_connection() + cursor = conn.execute(sql, vals) + if not self._in_transaction: + conn.commit() + return cursor.lastrowid + except _sqlite3.DatabaseError as e: + raise _map_sqlite_error(str(e), sql) + + def update(self, table: str, values: Any, + where_clause: Optional[str] = None, + where_args: Optional[List[Any]] = None) -> int: + self._ensure_open() + if values is None: + return 0 + set_pairs = [] + vals = [] + if isinstance(values, dict): + items = list(values.items()) + elif hasattr(values, "valueSet"): + items = list(values.valueSet()) + else: + return 0 + for k, v in items: + set_pairs.append(f"{k} = ?") + vals.append(v) + set_str = ", ".join(set_pairs) + sql = f"UPDATE {table} SET {set_str}" + if where_clause: + sql += f" WHERE {where_clause}" + if where_args: + vals.extend(where_args) + try: + conn = self._acquire_connection() + cursor = conn.execute(sql, vals) + if not self._in_transaction: + conn.commit() + return cursor.rowcount + except _sqlite3.DatabaseError as e: + raise _map_sqlite_error(str(e), sql) + + def delete(self, table: str, where_clause: Optional[str] = None, + where_args: Optional[List[Any]] = None) -> int: + self._ensure_open() + sql = f"DELETE FROM {table}" + vals: List[Any] = [] + if where_clause: + sql += f" WHERE {where_clause}" + if where_args: + vals = list(where_args) + try: + conn = self._acquire_connection() + cursor = conn.execute(sql, vals) + if not self._in_transaction: + conn.commit() + return cursor.rowcount + except _sqlite3.DatabaseError as e: + raise _map_sqlite_error(str(e), sql) + + def query(self, table: str, columns: Optional[List[str]] = None, + selection: Optional[str] = None, + selection_args: Optional[List[Any]] = None, + group_by: Optional[str] = None, having: Optional[str] = None, + order_by: Optional[str] = None, + limit: Optional[str] = None) -> SQLiteCursor: + col_str = ", ".join(columns) if columns else "*" + sql = f"SELECT {col_str} FROM {table}" + if selection: + sql += f" WHERE {selection}" + if group_by: + sql += f" GROUP BY {group_by}" + if having: + sql += f" HAVING {having}" + if order_by: + sql += f" ORDER BY {order_by}" + if limit: + sql += f" LIMIT {limit}" + return self.rawQuery(sql, selection_args) + + def compileStatement(self, sql: str) -> SQLiteStatement: + return SQLiteStatement(self, sql) + + def beginTransaction(self): + self._ensure_open() + try: + conn = self._acquire_connection() + conn.execute("BEGIN TRANSACTION") + self._in_transaction = True + self._transaction_successful = False + except _sqlite3.DatabaseError as e: + raise _map_sqlite_error(str(e)) + + def endTransaction(self): + if self._in_transaction and self._conn: + try: + if not self._transaction_successful: + self._conn.rollback() + else: + self._conn.commit() + except _sqlite3.DatabaseError: + pass + self._in_transaction = False + + def setTransactionSuccessful(self): + if not self._in_transaction: + raise IllegalStateException("Not in transaction") + self._transaction_successful = True + + def inTransaction(self) -> bool: + return self._in_transaction + + def isOpen(self) -> bool: + return self._conn is not None + + def getPath(self) -> str: + return self._path + + def getVersion(self) -> int: + return self._version + + def setVersion(self, version: int): + self._version = version + if self._conn: + try: + self._conn.execute(f"PRAGMA schema_version = {version}") + except _sqlite3.DatabaseError: + pass + + def onCreate(self, db: "SQLiteDatabase"): + pass + + def onConfigure(self, db: "SQLiteDatabase"): + pass + + def enableWriteAheadLogging(self) -> bool: + self._ensure_open() + try: + self._conn.execute("PRAGMA journal_mode=WAL") + self._enable_wal = True + return True + except _sqlite3.DatabaseError: + return False + + def disableWriteAheadLogging(self): + try: + self._conn.execute("PRAGMA journal_mode=DELETE") + self._enable_wal = False + except _sqlite3.DatabaseError: + pass + + def isWriteAheadLoggingEnabled(self) -> bool: + return self._enable_wal + + def getMaximumSize(self) -> int: + return self._max_size + + def getPageSize(self) -> int: + return self._page_size + + def setMaximumSize(self, size: int) -> int: + self._max_size = size + return size + + def setPageSize(self, size: int): + self._page_size = size + if self._conn: + try: + self._conn.execute(f"PRAGMA page_size = {size}") + except _sqlite3.DatabaseError: + pass + + def getPageCount(self) -> int: + if self._conn: + try: + cursor = self._conn.execute("PRAGMA page_count") + row = cursor.fetchone() + if row: + return row[0] + except _sqlite3.DatabaseError: + pass + return 0 + + def yieldIfContendedSafely(self, sleep_time: int = 0) -> bool: + return True + + def needUpgrade(self, new_version: int) -> bool: + return new_version > self._version + + def getAttachedDbs(self) -> Optional[List[Dict[str, Any]]]: + return self._attached_dbs + + def isReadOnly(self) -> bool: + return bool(self._flags & self.OPEN_READONLY) + + def close(self): + if self._conn: + try: + self._conn.close() + except Exception: + pass + self._conn = None + super().close() + + def _ensure_open(self): + if self._conn is None: + raise SQLiteCantOpenDatabaseException("Database not open") + + def toString(self) -> str: + return f"SQLiteDatabase(path={self._path})" + + +# ═══════════════════════════════════════════════════════════════ +# SQLiteOpenHelper +# ═══════════════════════════════════════════════════════════════ + +class SQLiteOpenHelper(Stub): + """SQLiteOpenHelper — 数据库打开辅助类""" + + def __init__(self, context: Any, name: Optional[str], + factory: Any, version: int, + error_handler: Any = None): + super().__init__() + self._context = context + self._name = name + self._factory = factory + self._version = version + self._error_handler = error_handler + self._readable_db: Optional[SQLiteDatabase] = None + self._writable_db: Optional[SQLiteDatabase] = None + self._database_path: Optional[str] = None + self._is_initialized = False + + def _get_database_path(self) -> str: + if self._database_path: + return self._database_path + db_dir = os.path.join(_app_data_dir, "databases") + os.makedirs(db_dir, exist_ok=True) + if self._name: + self._database_path = os.path.join(db_dir, self._name) + else: + import tempfile + tmp = tempfile.NamedTemporaryFile(suffix=".db", delete=False) + tmp.close() + self._database_path = tmp.name + return self._database_path + + def getWritableDatabase(self) -> SQLiteDatabase: + if self._writable_db and self._writable_db.isOpen(): + return self._writable_db + path = self._get_database_path() + db = SQLiteDatabase.openOrCreateDatabase(path, self._factory, self._error_handler) + if not self._is_initialized: + self._is_initialized = True + current_version = db.getVersion() + if current_version == 0: + self.onCreate(db) + db.setVersion(self._version) + elif current_version < self._version: + self.onUpgrade(db, current_version, self._version) + elif current_version > self._version: + self.onDowngrade(db, current_version, self._version) + self.onOpen(db) + self._writable_db = db + self._readable_db = db + return db + + def getReadableDatabase(self) -> SQLiteDatabase: + return self.getWritableDatabase() + + def onCreate(self, db: SQLiteDatabase): + pass + + def onUpgrade(self, db: SQLiteDatabase, old_version: int, new_version: int): + pass + + def onDowngrade(self, db: SQLiteDatabase, old_version: int, new_version: int): + pass + + def onOpen(self, db: SQLiteDatabase): + pass + + def close(self): + if self._writable_db: + self._writable_db.close() + self._writable_db = None + if self._readable_db: + self._readable_db = None + + def getDatabaseName(self) -> Optional[str]: + return self._name + + def getReadableDB(self) -> Optional[SQLiteDatabase]: + return self._readable_db + + def getWriteableDB(self) -> Optional[SQLiteDatabase]: + return self._writable_db + + def toString(self) -> str: + return f"SQLiteOpenHelper(name={self._name}, version={self._version})" + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "SQLiteDatabase", + "SQLiteOpenHelper", + "SQLiteStatement", + "SQLiteCursor", + "SQLiteQuery", + "SQLiteQueryBuilder", + "SQLiteClosable", + "SQLiteProgram", + "SQLiteAbortException", + "SQLiteAccessPermException", + "SQLiteBindOrColumnIndexOutOfRangeException", + "SQLiteBlobTooBigException", + "SQLiteCantOpenDatabaseException", + "SQLiteConstraintException", + "SQLiteDatabaseCorruptException", + "SQLiteDatabaseLockedException", + "SQLiteDatatypeMismatchException", + "SQLiteDiskIOException", + "SQLiteDoneException", + "SQLiteException", + "SQLiteFullException", + "SQLiteMisuseException", + "SQLiteOutOfMemoryException", + "SQLiteReadOnlyDatabaseException", + "SQLiteTableLockedException", + "SQLiteUnsupportedOperationException", +] \ No newline at end of file diff --git a/android_pyapi/android/graphics.py b/android_pyapi/android/graphics.py new file mode 100644 index 0000000..26b866a --- /dev/null +++ b/android_pyapi/android/graphics.py @@ -0,0 +1,2792 @@ +""" +Android Graphics 组件 — Bitmap, Canvas, Paint, Color, Path, Rect 等 +方法签名完全对齐 Android SDK +""" + +import array +import math +import struct +import io +import os +from enum import IntEnum +from typing import Any, Dict, List, Optional, Sequence, Tuple, Union + +from .._core import Stub, AndroidOnlyError, android_context, HAS_PIL, resolve_android_path + +# Re-export Typeface from text module +from .text import Typeface + + +# ═══════════════════════════════════════════════════════════════ +# Color +# ═══════════════════════════════════════════════════════════════ + +class Color(Stub): + """Color — 颜色工具类""" + + BLACK = 0xFF000000 + DKGRAY = 0xFF444444 + GRAY = 0xFF888888 + LTGRAY = 0xFFCCCCCC + WHITE = 0xFFFFFFFF + RED = 0xFFFF0000 + GREEN = 0xFF00FF00 + BLUE = 0xFF0000FF + YELLOW = 0xFFFFFF00 + CYAN = 0xFF00FFFF + MAGENTA = 0xFFFF00FF + TRANSPARENT = 0 + + @staticmethod + def alpha(color: int) -> int: + return (color >> 24) & 0xFF + + @staticmethod + def red(color: int) -> int: + return (color >> 16) & 0xFF + + @staticmethod + def green(color: int) -> int: + return (color >> 8) & 0xFF + + @staticmethod + def blue(color: int) -> int: + return color & 0xFF + + @staticmethod + def rgb(r: int, g: int, b: int) -> int: + return 0xFF000000 | ((r & 0xFF) << 16) | ((g & 0xFF) << 8) | (b & 0xFF) + + @staticmethod + def argb(a: int, r: int, g: int, b: int) -> int: + return ((a & 0xFF) << 24) | ((r & 0xFF) << 16) | ((g & 0xFF) << 8) | (b & 0xFF) + + @staticmethod + def parseColor(colorString: str) -> int: + s = colorString.strip() + if s.startswith("#"): + s = s[1:] + if len(s) == 3: + s = "".join(c * 2 for c in s) + if len(s) == 6: + s = "FF" + s + return int(s, 16) & 0xFFFFFFFF + if s.startswith("0x"): + return int(s, 16) & 0xFFFFFFFF + name_map = { + "black": Color.BLACK, "white": Color.WHITE, "red": Color.RED, + "green": Color.GREEN, "blue": Color.BLUE, "yellow": Color.YELLOW, + "cyan": Color.CYAN, "magenta": Color.MAGENTA, "transparent": Color.TRANSPARENT, + "dkgray": Color.DKGRAY, "gray": Color.GRAY, "ltgray": Color.LTGRAY, + "darkgray": Color.DKGRAY, "lightgray": Color.LTGRAY, + } + return name_map.get(s.lower(), Color.BLACK) + + @staticmethod + def RGBToHSV(red: int, green: int, blue: int, hsv: List[float]): + r, g, b = red / 255.0, green / 255.0, blue / 255.0 + mx = max(r, g, b) + mn = min(r, g, b) + df = mx - mn + if df == 0: + h = 0.0 + elif mx == r: + h = ((g - b) / df) % 6.0 + elif mx == g: + h = (b - r) / df + 2.0 + else: + h = (r - g) / df + 4.0 + h = h * 60.0 + if h < 0: + h += 360.0 + s = 0.0 if mx == 0 else (df / mx) + v = mx + hsv[0] = h + hsv[1] = s + hsv[2] = v + + @staticmethod + def HSVToColor(hsv: List[float]) -> int: + return Color.HSVToColor(255, hsv) + + @staticmethod + def HSVToColor(alpha: int, hsv: List[float]) -> int: + h, s, v = hsv[0], hsv[1], hsv[2] + hi = int(h / 60.0) % 6 + f = (h / 60.0) - hi + p = v * (1.0 - s) + q = v * (1.0 - f * s) + t = v * (1.0 - (1.0 - f) * s) + if hi == 0: + r, g, b = v, t, p + elif hi == 1: + r, g, b = q, v, p + elif hi == 2: + r, g, b = p, v, t + elif hi == 3: + r, g, b = p, q, v + elif hi == 4: + r, g, b = t, p, v + else: + r, g, b = v, p, q + return Color.argb(alpha, int(r * 255 + 0.5), int(g * 255 + 0.5), int(b * 255 + 0.5)) + + @staticmethod + def ColorToHSV(color: int, hsv: List[float]): + Color.RGBToHSV(Color.red(color), Color.green(color), Color.blue(color), hsv) + + @staticmethod + def getHue(color: int) -> float: + hsv = [0.0, 0.0, 0.0] + Color.ColorToHSV(color, hsv) + return hsv[0] + + @staticmethod + def getSaturation(color: int) -> float: + hsv = [0.0, 0.0, 0.0] + Color.ColorToHSV(color, hsv) + return hsv[1] + + @staticmethod + def getBrightness(color: int) -> float: + hsv = [0.0, 0.0, 0.0] + Color.ColorToHSV(color, hsv) + return hsv[2] + + @staticmethod + def HSLToColor(hsl: List[float], alpha: float = 1.0) -> int: + h, s, l = hsl[0] / 360.0, hsl[1], hsl[2] + if s == 0: + r = g = b = l + else: + def hue2rgb(p, q, t): + if t < 0: + t += 1 + if t > 1: + t -= 1 + if t < 1.0 / 6.0: + return p + (q - p) * 6.0 * t + if t < 1.0 / 2.0: + return q + if t < 2.0 / 3.0: + return p + (q - p) * (2.0 / 3.0 - t) * 6.0 + return p + q = l * (1 + s) if l < 0.5 else l + s - l * s + p = 2 * l - q + r = hue2rgb(p, q, h + 1.0 / 3.0) + g = hue2rgb(p, q, h) + b = hue2rgb(p, q, h - 1.0 / 3.0) + a = max(0, min(255, int(alpha * 255))) + return Color.argb(a, int(r * 255), int(g * 255), int(b * 255)) + + @staticmethod + def ColorToHSL(color: int, hsl: List[float]): + r, g, b = Color.red(color) / 255.0, Color.green(color) / 255.0, Color.blue(color) / 255.0 + mx = max(r, g, b) + mn = min(r, g, b) + l = (mx + mn) / 2.0 + if mx == mn: + h = 0.0 + s = 0.0 + else: + d = mx - mn + s = d / (1 - abs(2 * l - 1)) + if mx == r: + h = ((g - b) / d) % 6.0 + elif mx == g: + h = (b - r) / d + 2.0 + else: + h = (r - g) / d + 4.0 + h = h * 60.0 + if h < 0: + h += 360.0 + hsl[0] = h + hsl[1] = s + hsl[2] = l + + +# ═══════════════════════════════════════════════════════════════ +# Rect +# ═══════════════════════════════════════════════════════════════ + +class Rect(Stub): + """Rect — 矩形 (int 坐标)""" + + def __init__(self, left: int = 0, top: int = 0, right: int = 0, bottom: int = 0): + super().__init__() + self.left = left + self.top = top + self.right = right + self.bottom = bottom + + def width(self) -> int: + return self.right - self.left + + def height(self) -> int: + return self.bottom - self.top + + def centerX(self) -> int: + return (self.left + self.right) // 2 + + def centerY(self) -> int: + return (self.top + self.bottom) // 2 + + def exactCenterX(self) -> float: + return (self.left + self.right) * 0.5 + + def exactCenterY(self) -> float: + return (self.top + self.bottom) * 0.5 + + def set(self, left: int, top: int, right: int, bottom: int): + self.left, self.top, self.right, self.bottom = left, top, right, bottom + + def offset(self, dx: int, dy: int): + self.left += dx + self.top += dy + self.right += dx + self.bottom += dy + + def offsetTo(self, newLeft: int, newTop: int): + self.right += newLeft - self.left + self.bottom += newTop - self.top + self.left = newLeft + self.top = newTop + + def inset(self, dx: int, dy: int): + self.left += dx + self.top += dy + self.right -= dx + self.bottom -= dy + + def contains(self, x: int, y: int) -> bool: + return self.left < self.right and self.top < self.bottom \ + and x >= self.left and x < self.right and y >= self.top and y < self.bottom + + def contains(self, left: int, top: int, right: int, bottom: int) -> bool: + return self.left < self.right and self.top < self.bottom \ + and self.left <= left and self.top <= top \ + and self.right >= right and self.bottom >= bottom + + def intersect(self, left: int, top: int, right: int, bottom: int) -> bool: + nL = max(self.left, left) + nT = max(self.top, top) + nR = min(self.right, right) + nB = min(self.bottom, bottom) + if nL < nR and nT < nB: + self.left, self.top, self.right, self.bottom = nL, nT, nR, nB + return True + return False + + def intersects(self, left: int, top: int, right: int, bottom: int) -> bool: + return self.left < right and self.right > left \ + and self.top < bottom and self.bottom > top + + @staticmethod + def intersects(a: "Rect", b: "Rect") -> bool: + return a.left < b.right and a.right > b.left \ + and a.top < b.bottom and a.bottom > b.top + + def union(self, left: int, top: int, right: int, bottom: int): + if self.isEmpty(): + self.set(left, top, right, bottom) + else: + self.left = min(self.left, left) + self.top = min(self.top, top) + self.right = max(self.right, right) + self.bottom = max(self.bottom, bottom) + + def sort(self): + if self.left > self.right: + self.left, self.right = self.right, self.left + if self.top > self.bottom: + self.top, self.bottom = self.bottom, self.top + + def isEmpty(self) -> bool: + return self.left >= self.right or self.top >= self.bottom + + def setEmpty(self): + self.left = self.top = self.right = self.bottom = 0 + + def toShortString(self) -> str: + return f"[{self.left},{self.top}][{self.right},{self.bottom}]" + + def flattenToString(self) -> str: + return f"{self.left} {self.top} {self.right} {self.bottom}" + + @staticmethod + def unflattenFromString(s: str) -> "Rect": + parts = s.split() + if len(parts) >= 4: + return Rect(int(parts[0]), int(parts[1]), int(parts[2]), int(parts[3])) + return Rect() + + def toString(self) -> str: + return f"Rect({self.left}, {self.top}, {self.right}, {self.bottom})" + + +# ═══════════════════════════════════════════════════════════════ +# RectF +# ═══════════════════════════════════════════════════════════════ + +class RectF(Stub): + """RectF — 矩形 (float 坐标)""" + + def __init__(self, left: float = 0.0, top: float = 0.0, right: float = 0.0, bottom: float = 0.0): + super().__init__() + self.left = left + self.top = top + self.right = right + self.bottom = bottom + + def width(self) -> float: + return self.right - self.left + + def height(self) -> float: + return self.bottom - self.top + + def centerX(self) -> float: + return (self.left + self.right) * 0.5 + + def centerY(self) -> float: + return (self.top + self.bottom) * 0.5 + + def set(self, left: float, top: float, right: float, bottom: float): + self.left, self.top, self.right, self.bottom = left, top, right, bottom + + def offset(self, dx: float, dy: float): + self.left += dx + self.top += dy + self.right += dx + self.bottom += dy + + def offsetTo(self, newLeft: float, newTop: float): + self.right += newLeft - self.left + self.bottom += newTop - self.top + self.left = newLeft + self.top = newTop + + def inset(self, dx: float, dy: float): + self.left += dx + self.top += dy + self.right -= dx + self.bottom -= dy + + def contains(self, x: float, y: float) -> bool: + return self.left < self.right and self.top < self.bottom \ + and x >= self.left and x < self.right and y >= self.top and y < self.bottom + + def intersect(self, left: float, top: float, right: float, bottom: float) -> bool: + nL = max(self.left, left) + nT = max(self.top, top) + nR = min(self.right, right) + nB = min(self.bottom, bottom) + if nL < nR and nT < nB: + self.left, self.top, self.right, self.bottom = nL, nT, nR, nB + return True + return False + + def intersects(self, left: float, top: float, right: float, bottom: float) -> bool: + return self.left < right and self.right > left \ + and self.top < bottom and self.bottom > top + + @staticmethod + def intersects(a: "RectF", b: "RectF") -> bool: + return a.left < b.right and a.right > b.left \ + and a.top < b.bottom and a.bottom > b.top + + def union(self, left: float, top: float, right: float, bottom: float): + if self.isEmpty(): + self.set(left, top, right, bottom) + else: + self.left = min(self.left, left) + self.top = min(self.top, top) + self.right = max(self.right, right) + self.bottom = max(self.bottom, bottom) + + def round(self, r: Rect): + r.left = int(self.left + 0.5) + r.top = int(self.top + 0.5) + r.right = int(self.right + 0.5) + r.bottom = int(self.bottom + 0.5) + + def roundOut(self, r: Rect): + r.left = int(math.floor(self.left)) + r.top = int(math.floor(self.top)) + r.right = int(math.ceil(self.right)) + r.bottom = int(math.ceil(self.bottom)) + + def sort(self): + if self.left > self.right: + self.left, self.right = self.right, self.left + if self.top > self.bottom: + self.top, self.bottom = self.bottom, self.top + + def isEmpty(self) -> bool: + return self.left >= self.right or self.top >= self.bottom + + def setEmpty(self): + self.left = self.top = self.right = self.bottom = 0.0 + + def toShortString(self) -> str: + return f"[{self.left:.1f},{self.top:.1f}][{self.right:.1f},{self.bottom:.1f}]" + + def toString(self) -> str: + return f"RectF({self.left}, {self.top}, {self.right}, {self.bottom})" + + +# ═══════════════════════════════════════════════════════════════ +# Point / PointF +# ═══════════════════════════════════════════════════════════════ + +class Point(Stub): + """Point — 整数坐标点""" + + def __init__(self, x: int = 0, y: int = 0): + super().__init__() + self.x = x + self.y = y + + def set(self, x: int, y: int): + self.x, self.y = x, y + + def offset(self, dx: int, dy: int): + self.x += dx + self.y += dy + + def equals(self, other) -> bool: + if isinstance(other, Point): + return self.x == other.x and self.y == other.y + return False + + def hashCode(self) -> int: + return self.x * 32713 + self.y + + def toString(self) -> str: + return f"Point({self.x}, {self.y})" + + +class PointF(Stub): + """PointF — 浮点坐标点""" + + def __init__(self, x: float = 0.0, y: float = 0.0): + super().__init__() + self.x = x + self.y = y + + def set(self, x: float, y: float): + self.x, self.y = x, y + + def offset(self, dx: float, dy: float): + self.x += dx + self.y += dy + + def equals(self, other) -> bool: + if isinstance(other, PointF): + return self.x == other.x and self.y == other.y + return False + + def hashCode(self) -> int: + return int(self.x * 32713 + self.y) + + def toString(self) -> str: + return f"PointF({self.x}, {self.y})" + + +# ═══════════════════════════════════════════════════════════════ +# Path +# ═══════════════════════════════════════════════════════════════ + +class Path(Stub): + """Path — 路径""" + + class Direction: + CW = 0 + CCW = 1 + + class FillType: + WINDING = 0 + EVEN_ODD = 1 + INVERSE_WINDING = 2 + INVERSE_EVEN_ODD = 3 + + class Op: + DIFFERENCE = 0 + INTERSECT = 1 + UNION = 2 + XOR = 3 + REVERSE_DIFFERENCE = 4 + + def __init__(self): + super().__init__() + self._segments: List[dict] = [] + self._fill_type = Path.FillType.WINDING + self._start_x = 0.0 + self._start_y = 0.0 + self._current_x = 0.0 + self._current_y = 0.0 + + def moveTo(self, x: float, y: float): + self._segments.append({"type": "move", "x": x, "y": y}) + self._current_x = x + self._current_y = y + + def lineTo(self, x: float, y: float): + self._segments.append({"type": "line", "x": x, "y": y}) + self._current_x = x + self._current_y = y + + def quadTo(self, x1: float, y1: float, x2: float, y2: float): + self._segments.append({"type": "quad", "x1": x1, "y1": y1, "x2": x2, "y2": y2}) + self._current_x = x2 + self._current_y = y2 + + def cubicTo(self, x1: float, y1: float, x2: float, y2: float, x3: float, y3: float): + self._segments.append({"type": "cubic", "x1": x1, "y1": y1, "x2": x2, "y2": y2, "x3": x3, "y3": y3}) + self._current_x = x3 + self._current_y = y3 + + def rMoveTo(self, dx: float, dy: float): + self.moveTo(self._current_x + dx, self._current_y + dy) + + def rLineTo(self, dx: float, dy: float): + self.lineTo(self._current_x + dx, self._current_y + dy) + + def rQuadTo(self, dx1: float, dy1: float, dx2: float, dy2: float): + self.quadTo(self._current_x + dx1, self._current_y + dy1, + self._current_x + dx2, self._current_y + dy2) + + def rCubicTo(self, dx1: float, dy1: float, dx2: float, dy2: float, dx3: float, dy3: float): + self.cubicTo(self._current_x + dx1, self._current_y + dy1, + self._current_x + dx2, self._current_y + dy2, + self._current_x + dx3, self._current_y + dy3) + + def addRect(self, left: float, top: float, right: float, bottom: float, + dir: int = Direction.CW): + self.moveTo(left, top) + self.lineTo(right, top) + self.lineTo(right, bottom) + self.lineTo(left, bottom) + self.close() + + def addRoundRect(self, rect: Union["RectF", tuple], rx: float, ry: float, + dir: int = Direction.CW): + if isinstance(rect, RectF): + l, t, r, b = rect.left, rect.top, rect.right, rect.bottom + else: + l, t, r, b = rect + self.moveTo(l + rx, t) + self.lineTo(r - rx, t) + self.quadTo(r, t, r, t + ry) + self.lineTo(r, b - ry) + self.quadTo(r, b, r - rx, b) + self.lineTo(l + rx, b) + self.quadTo(l, b, l, b - ry) + self.lineTo(l, t + ry) + self.quadTo(l, t, l + rx, t) + self.close() + + def addCircle(self, x: float, y: float, radius: float, dir: int = Direction.CW): + k = 0.5522847498 + self.moveTo(x + radius, y) + self.cubicTo(x + radius, y + radius * k, x + radius * k, y + radius, x, y + radius) + self.cubicTo(x - radius * k, y + radius, x - radius, y + radius * k, x - radius, y) + self.cubicTo(x - radius, y - radius * k, x - radius * k, y - radius, x, y - radius) + self.cubicTo(x + radius * k, y - radius, x + radius, y - radius * k, x + radius, y) + self.close() + + def addOval(self, rect: Union["RectF", tuple], dir: int = Direction.CW): + if isinstance(rect, RectF): + l, t, r, b = rect.left, rect.top, rect.right, rect.bottom + else: + l, t, r, b = rect + cx = (l + r) / 2.0 + cy = (t + b) / 2.0 + rx = (r - l) / 2.0 + ry = (b - t) / 2.0 + kx = rx * 0.5522847498 + ky = ry * 0.5522847498 + self.moveTo(cx + rx, cy) + self.cubicTo(cx + rx, cy + ky, cx + kx, cy + ry, cx, cy + ry) + self.cubicTo(cx - kx, cy + ry, cx - rx, cy + ky, cx - rx, cy) + self.cubicTo(cx - rx, cy - ky, cx - kx, cy - ry, cx, cy - ry) + self.cubicTo(cx + kx, cy - ry, cx + rx, cy - ky, cx + rx, cy) + self.close() + + def addArc(self, rect: Union["RectF", tuple], startAngle: float, sweepAngle: float): + if isinstance(rect, RectF): + l, t, r, b = rect.left, rect.top, rect.right, rect.bottom + else: + l, t, r, b = rect + cx = (l + r) / 2.0 + cy = (t + b) / 2.0 + rx = (r - l) / 2.0 + ry = (b - t) / 2.0 + start_rad = math.radians(startAngle) + end_rad = math.radians(startAngle + sweepAngle) + segments = 4 + da = (end_rad - start_rad) / segments + for i in range(segments + 1): + a = start_rad + i * da + px = cx + rx * math.cos(a) + py = cy + ry * math.sin(a) + if i == 0: + self.moveTo(px, py) + else: + self.lineTo(px, py) + + def addPath(self, path: "Path", dx: float = 0.0, dy: float = 0.0): + for seg in path._segments: + s = dict(seg) + if "x" in s: + s["x"] = s["x"] + dx + if "y" in s: + s["y"] = s["y"] + dy + if "x1" in s: + s["x1"] = s["x1"] + dx + if "y1" in s: + s["y1"] = s["y1"] + dy + if "x2" in s: + s["x2"] = s["x2"] + dx + if "y2" in s: + s["y2"] = s["y2"] + dy + if "x3" in s: + s["x3"] = s["x3"] + dx + if "y3" in s: + s["y3"] = s["y3"] + dy + self._segments.append(s) + self._current_x = path._current_x + dx + self._current_y = path._current_y + dy + + def arcTo(self, rect: Union["RectF", tuple], startAngle: float, sweepAngle: float, + forceMoveTo: bool = False): + if isinstance(rect, RectF): + l, t, r, b = rect.left, rect.top, rect.right, rect.bottom + else: + l, t, r, b = rect + cx = (l + r) / 2.0 + cy = (t + b) / 2.0 + rx = (r - l) / 2.0 + ry = (b - t) / 2.0 + start_rad = math.radians(startAngle) + end_rad = math.radians(startAngle + sweepAngle) + segments = 4 + da = (end_rad - start_rad) / segments + for i in range(segments + 1): + a = start_rad + i * da + px = cx + rx * math.cos(a) + py = cy + ry * math.sin(a) + if i == 0 and forceMoveTo: + self.moveTo(px, py) + elif i == 0: + self.lineTo(px, py) + else: + self.lineTo(px, py) + + def close(self): + self._segments.append({"type": "close"}) + + def reset(self): + self._segments.clear() + self._current_x = 0.0 + self._current_y = 0.0 + + def rewind(self): + self._segments.clear() + self._current_x = 0.0 + self._current_y = 0.0 + + def set(self, src: "Path"): + self._segments = list(src._segments) + self._fill_type = src._fill_type + self._current_x = src._current_x + self._current_y = src._current_y + + def computeBounds(self, exact: bool = False) -> RectF: + if not self._segments: + return RectF(0, 0, 0, 0) + min_x = float("inf") + min_y = float("inf") + max_x = float("-inf") + max_y = float("-inf") + for seg in self._segments: + for key in ("x", "x1", "x2", "x3"): + if key in seg: + if seg[key] < min_x: + min_x = seg[key] + if seg[key] > max_x: + max_x = seg[key] + for key in ("y", "y1", "y2", "y3"): + if key in seg: + if seg[key] < min_y: + min_y = seg[key] + if seg[key] > max_y: + max_y = seg[key] + if min_x == float("inf"): + return RectF(0, 0, 0, 0) + return RectF(min_x, min_y, max_x, max_y) + + def incReserve(self, extraPtCount: int): + pass + + def op(self, other: "Path", op: int) -> bool: + return False + + def isRect(self) -> bool: + if len(self._segments) != 5: + return False + types = [s["type"] for s in self._segments] + return types == ["move", "line", "line", "line", "close"] + + def isConvex(self) -> bool: + return True + + def setFillType(self, ft: int): + self._fill_type = ft + + def getFillType(self) -> int: + return self._fill_type + + def toggleReverseFillType(self): + mapping = { + Path.FillType.WINDING: Path.FillType.INVERSE_WINDING, + Path.FillType.EVEN_ODD: Path.FillType.INVERSE_EVEN_ODD, + Path.FillType.INVERSE_WINDING: Path.FillType.WINDING, + Path.FillType.INVERSE_EVEN_ODD: Path.FillType.EVEN_ODD, + } + self._fill_type = mapping.get(self._fill_type, Path.FillType.WINDING) + + +# ═══════════════════════════════════════════════════════════════ +# PathMeasure +# ═══════════════════════════════════════════════════════════════ + +class PathMeasure(Stub): + """PathMeasure — 路径测量""" + + def __init__(self, path: Path = None, forceClosed: bool = False): + super().__init__() + self._path = path + self._force_closed = forceClosed + + def setPath(self, path: Path, forceClosed: bool): + self._path = path + self._force_closed = forceClosed + + def getLength(self) -> float: + if not self._path: + return 0.0 + bounds = self._path.computeBounds() + return math.sqrt(bounds.width() ** 2 + bounds.height() ** 2) + + def getPosTan(self, distance: float, pos: List[float], tan: List[float]) -> bool: + if not self._path: + return False + if len(pos) >= 2: + pos[0] = 0.0 + pos[1] = 0.0 + if len(tan) >= 2: + tan[0] = 1.0 + tan[1] = 0.0 + return True + + def getMatrix(self, distance: float, matrix: "Matrix", flags: int) -> bool: + return False + + def getSegment(self, startD: float, stopD: float, dst: Path, startWithMoveTo: bool) -> bool: + return False + + def isClosed(self) -> bool: + return self._force_closed + + def nextContour(self) -> bool: + return False + + +# ═══════════════════════════════════════════════════════════════ +# PorterDuff +# ═══════════════════════════════════════════════════════════════ + +class PorterDuff(Stub): + """PorterDuff — 图形混合模式""" + + class Mode: + CLEAR = 0 + SRC = 1 + DST = 2 + SRC_OVER = 3 + DST_OVER = 4 + SRC_IN = 5 + DST_IN = 6 + SRC_OUT = 7 + DST_OUT = 8 + SRC_ATOP = 9 + DST_ATOP = 10 + XOR = 11 + ADD = 12 + MULTIPLY = 13 + SCREEN = 14 + OVERLAY = 15 + DARKEN = 16 + LIGHTEN = 17 + + +# ═══════════════════════════════════════════════════════════════ +# ClipOp +# ═══════════════════════════════════════════════════════════════ + +class ClipOp(Stub): + """ClipOp — 裁剪操作""" + DIFFERENCE = 0 + INTERSECT = 1 + REPLACE = 2 + + +# ═══════════════════════════════════════════════════════════════ +# BlendMode +# ═══════════════════════════════════════════════════════════════ + +class BlendMode(Stub): + """BlendMode — Android 29+ 混合模式""" + CLEAR = 0 + SRC = 1 + DST = 2 + SRC_OVER = 3 + DST_OVER = 4 + SRC_IN = 5 + DST_IN = 6 + SRC_OUT = 7 + DST_OUT = 8 + SRC_ATOP = 9 + DST_ATOP = 10 + XOR = 11 + PLUS = 12 + MODULATE = 13 + SCREEN = 14 + OVERLAY = 15 + DARKEN = 16 + LIGHTEN = 17 + + +# ═══════════════════════════════════════════════════════════════ +# BlendModeColorFilter +# ═══════════════════════════════════════════════════════════════ + +class BlendModeColorFilter(Stub): + """BlendModeColorFilter — 混合模式颜色过滤器""" + + def __init__(self, color: int, mode): + super().__init__() + self._color = color + self._mode = mode + + def getColor(self) -> int: + return self._color + + def getMode(self): + return self._mode + + +# ═══════════════════════════════════════════════════════════════ +# ColorFilter +# ═══════════════════════════════════════════════════════════════ + +class ColorFilter(Stub): + """ColorFilter — 颜色过滤器的抽象基类""" + pass + + +# ═══════════════════════════════════════════════════════════════ +# PorterDuffColorFilter +# ═══════════════════════════════════════════════════════════════ + +class PorterDuffColorFilter(ColorFilter): + """PorterDuffColorFilter — PorterDuff 颜色过滤器""" + + def __init__(self, color: int, mode): + super().__init__() + self._color = color + self._mode = mode + + def getColor(self) -> int: + return self._color + + def getMode(self): + return self._mode + + +# ═══════════════════════════════════════════════════════════════ +# LightingColorFilter +# ═══════════════════════════════════════════════════════════════ + +class LightingColorFilter(ColorFilter): + """LightingColorFilter — 光照颜色过滤器""" + + def __init__(self, mul: int, add: int): + super().__init__() + self._mul = mul + self._add = add + + def getMultiply(self) -> int: + return self._mul + + def getAdd(self) -> int: + return self._add + + +# ═══════════════════════════════════════════════════════════════ +# ComposeColorFilter +# ═══════════════════════════════════════════════════════════════ + +class ComposeColorFilter(ColorFilter): + """ComposeColorFilter — 组合颜色过滤器""" + + def __init__(self, cf1: ColorFilter, cf2: ColorFilter): + super().__init__() + self._cf1 = cf1 + self._cf2 = cf2 + + def getColorFilters(self) -> Tuple[ColorFilter, ColorFilter]: + return (self._cf1, self._cf2) + + +# ═══════════════════════════════════════════════════════════════ +# ColorMatrix +# ═══════════════════════════════════════════════════════════════ + +class ColorMatrix(Stub): + """ColorMatrix — 4x5 颜色变换矩阵""" + + def __init__(self, src: "ColorMatrix" = None): + super().__init__() + if src: + self._array = list(src._array) + else: + self._array = [1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0] + + def getArray(self) -> List[float]: + return self._array + + def set(self, src: "ColorMatrix"): + self._array = list(src._array) + + def reset(self): + self._array = [1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0] + + def setSaturation(self, sat: float): + R_lum = 0.213 + G_lum = 0.715 + B_lum = 0.072 + one_minus = 1.0 - sat + self._array = [ + R_lum * one_minus + sat, G_lum * one_minus, B_lum * one_minus, 0, 0, + R_lum * one_minus, G_lum * one_minus + sat, B_lum * one_minus, 0, 0, + R_lum * one_minus, G_lum * one_minus, B_lum * one_minus + sat, 0, 0, + 0, 0, 0, 1, 0, + ] + + def setRotate(self, axis: int, degrees: float): + rad = math.radians(degrees) + c = math.cos(rad) + s = math.sin(rad) + self.reset() + if axis == 0: + self._array[5] = c + self._array[6] = s + self._array[9] = -s + self._array[10] = c + elif axis == 1: + self._array[0] = c + self._array[2] = -s + self._array[8] = s + self._array[10] = c + elif axis == 2: + self._array[0] = c + self._array[1] = s + self._array[4] = -s + self._array[5] = c + + def setConcat(self, a: "ColorMatrix", b: "ColorMatrix"): + a_arr = a._array + b_arr = b._array + result = [0.0] * 20 + for i in range(4): + for j in range(5): + s = 0.0 + for k in range(4): + s += a_arr[i * 5 + k] * b_arr[k * 5 + j] + result[i * 5 + j] = s + self._array = result + + def preConcat(self, other: "ColorMatrix"): + new = ColorMatrix() + new.setConcat(self, other) + self._array = new._array + + def postConcat(self, other: "ColorMatrix"): + new = ColorMatrix() + new.setConcat(other, self) + self._array = new._array + + def setScale(self, rScale: float, gScale: float, bScale: float, aScale: float): + self._array = [ + rScale, 0, 0, 0, 0, + 0, gScale, 0, 0, 0, + 0, 0, bScale, 0, 0, + 0, 0, 0, aScale, 0, + ] + + +# ═══════════════════════════════════════════════════════════════ +# ColorMatrixColorFilter +# ═══════════════════════════════════════════════════════════════ + +class ColorMatrixColorFilter(ColorFilter): + """ColorMatrixColorFilter — 颜色矩阵过滤器""" + + def __init__(self, matrix: ColorMatrix): + super().__init__() + self._matrix = matrix + + def getMatrix(self) -> ColorMatrix: + return self._matrix + + +# ═══════════════════════════════════════════════════════════════ +# Matrix +# ═══════════════════════════════════════════════════════════════ + +class Matrix(Stub): + """Matrix — 3x3 变换矩阵""" + + IDENTITY_MATRIX: "Matrix" = None + + MPERSP_0 = 6 + MPERSP_1 = 7 + MPERSP_2 = 8 + MSCALE_X = 0 + MSCALE_Y = 4 + MSKEW_X = 1 + MSKEW_Y = 3 + MTRANS_X = 2 + MTRANS_Y = 5 + + def __init__(self, src: "Matrix" = None): + super().__init__() + if src: + self._values = list(src._values) + else: + self._values = [1, 0, 0, + 0, 1, 0, + 0, 0, 1] + + def getValues(self) -> List[float]: + return self._values + + def setValues(self, values: List[float]): + self._values = list(values) + + def reset(self): + self._values = [1, 0, 0, 0, 1, 0, 0, 0, 1] + + def isIdentity(self) -> bool: + return self._values == [1, 0, 0, 0, 1, 0, 0, 0, 1] + + def invert(self, inverse: "Matrix") -> bool: + v = self._values + det = v[0] * (v[4] * v[8] - v[5] * v[7]) \ + - v[1] * (v[3] * v[8] - v[5] * v[6]) \ + + v[2] * (v[3] * v[7] - v[4] * v[6]) + if abs(det) < 1e-10: + return False + inv_det = 1.0 / det + inv = [ + (v[4] * v[8] - v[5] * v[7]) * inv_det, + (v[2] * v[7] - v[1] * v[8]) * inv_det, + (v[1] * v[5] - v[2] * v[4]) * inv_det, + (v[5] * v[6] - v[3] * v[8]) * inv_det, + (v[0] * v[8] - v[2] * v[6]) * inv_det, + (v[2] * v[3] - v[0] * v[5]) * inv_det, + (v[3] * v[7] - v[4] * v[6]) * inv_det, + (v[1] * v[6] - v[0] * v[7]) * inv_det, + (v[0] * v[4] - v[1] * v[3]) * inv_det, + ] + inverse._values = inv + return True + + def setTranslate(self, dx: float, dy: float): + self._values = [1, 0, dx, 0, 1, dy, 0, 0, 1] + + def setScale(self, sx: float, sy: float, px: float = 0.0, py: float = 0.0): + self._values = [sx, 0, px - sx * px, 0, sy, py - sy * py, 0, 0, 1] + + def setRotate(self, degrees: float, px: float = 0.0, py: float = 0.0): + rad = math.radians(degrees) + c = math.cos(rad) + s = math.sin(rad) + tx = px - px * c + py * s + ty = py - px * s - py * c + self._values = [c, -s, tx, s, c, ty, 0, 0, 1] + + def setSkew(self, kx: float, ky: float, px: float = 0.0, py: float = 0.0): + self._values = [1, kx, -kx * px, ky, 1, -ky * py, 0, 0, 1] + + def setConcat(self, a: "Matrix", b: "Matrix"): + va, vb = a._values, b._values + self._values = [ + va[0] * vb[0] + va[1] * vb[3] + va[2] * vb[6], + va[0] * vb[1] + va[1] * vb[4] + va[2] * vb[7], + va[0] * vb[2] + va[1] * vb[5] + va[2] * vb[8], + va[3] * vb[0] + va[4] * vb[3] + va[5] * vb[6], + va[3] * vb[1] + va[4] * vb[4] + va[5] * vb[7], + va[3] * vb[2] + va[4] * vb[5] + va[5] * vb[8], + va[6] * vb[0] + va[7] * vb[3] + va[8] * vb[6], + va[6] * vb[1] + va[7] * vb[4] + va[8] * vb[7], + va[6] * vb[2] + va[7] * vb[5] + va[8] * vb[8], + ] + + def preConcat(self, other: "Matrix"): + new = Matrix() + new.setConcat(self, other) + self._values = new._values + + def postConcat(self, other: "Matrix"): + new = Matrix() + new.setConcat(other, self) + self._values = new._values + + def preTranslate(self, dx: float, dy: float): + m = Matrix() + m.setTranslate(dx, dy) + self.preConcat(m) + + def preScale(self, sx: float, sy: float, px: float = 0.0, py: float = 0.0): + m = Matrix() + m.setScale(sx, sy, px, py) + self.preConcat(m) + + def preRotate(self, degrees: float, px: float = 0.0, py: float = 0.0): + m = Matrix() + m.setRotate(degrees, px, py) + self.preConcat(m) + + def preSkew(self, kx: float, ky: float, px: float = 0.0, py: float = 0.0): + m = Matrix() + m.setSkew(kx, ky, px, py) + self.preConcat(m) + + def postTranslate(self, dx: float, dy: float): + m = Matrix() + m.setTranslate(dx, dy) + self.postConcat(m) + + def postScale(self, sx: float, sy: float, px: float = 0.0, py: float = 0.0): + m = Matrix() + m.setScale(sx, sy, px, py) + self.postConcat(m) + + def postRotate(self, degrees: float, px: float = 0.0, py: float = 0.0): + m = Matrix() + m.setRotate(degrees, px, py) + self.postConcat(m) + + def postSkew(self, kx: float, ky: float, px: float = 0.0, py: float = 0.0): + m = Matrix() + m.setSkew(kx, ky, px, py) + self.postConcat(m) + + def setRectToRect(self, src: RectF, dst: RectF, stf: int) -> bool: + if src.isEmpty() or dst.isEmpty(): + return False + sx = dst.width() / src.width() + sy = dst.height() / src.height() + tx = dst.left - src.left * sx + ty = dst.top - src.top * sy + self._values = [sx, 0, tx, 0, sy, ty, 0, 0, 1] + return True + + def mapRect(self, src: RectF, dst: RectF = None) -> RectF: + pts = [src.left, src.top, src.right, src.bottom] + self.mapPoints(pts) + if dst: + dst.set(pts[0], pts[1], pts[2], pts[3]) + return dst + return RectF(pts[0], pts[1], pts[2], pts[3]) + + def mapPoints(self, pts: List[float], offset: int = 0, count: int = -1): + if count < 0: + count = len(pts) - offset + v = self._values + for i in range(offset, offset + count, 2): + x = pts[i] + y = pts[i + 1] + pts[i] = x * v[0] + y * v[1] + v[2] + pts[i + 1] = x * v[3] + y * v[4] + v[5] + + def mapVectors(self, vecs: List[float]): + v = self._values + for i in range(0, len(vecs), 2): + x = vecs[i] + y = vecs[i + 1] + vecs[i] = x * v[0] + y * v[1] + vecs[i + 1] = x * v[3] + y * v[4] + + def mapRadius(self, radius: float) -> float: + v = self._values + sx = math.sqrt(v[0] * v[0] + v[3] * v[3]) + sy = math.sqrt(v[1] * v[1] + v[4] * v[4]) + return radius * max(sx, sy) + + def toString(self) -> str: + return f"Matrix({self._values})" + + +Matrix.IDENTITY_MATRIX = Matrix() + + +# ═══════════════════════════════════════════════════════════════ +# Shader +# ═══════════════════════════════════════════════════════════════ + +class Shader(Stub): + """Shader — 着色器基类""" + + class TileMode: + CLAMP = 0 + REPEAT = 1 + MIRROR = 2 + + def __init__(self): + super().__init__() + self._local_matrix = None + + def setLocalMatrix(self, matrix: Matrix): + self._local_matrix = matrix + + def getLocalMatrix(self) -> Optional[Matrix]: + return self._local_matrix + + +# ═══════════════════════════════════════════════════════════════ +# LinearGradient +# ═══════════════════════════════════════════════════════════════ + +class LinearGradient(Shader): + """LinearGradient — 线性渐变""" + + def __init__(self, x0: float, y0: float, x1: float, y1: float, + colors: Sequence[int], positions: Sequence[float], + tile: int = Shader.TileMode.CLAMP): + super().__init__() + self._x0, self._y0 = x0, y0 + self._x1, self._y1 = x1, y1 + self._colors = list(colors) + self._positions = list(positions) if positions else None + self._tile = tile + + +# ═══════════════════════════════════════════════════════════════ +# RadialGradient +# ═══════════════════════════════════════════════════════════════ + +class RadialGradient(Shader): + """RadialGradient — 径向渐变""" + + CENTER_COLOR = 0 + EDGE_COLOR = 1 + + def __init__(self, x: float, y: float, radius: float, + colors: Sequence[int], positions: Sequence[float], + tile: int = Shader.TileMode.CLAMP, + centerColor: int = Shader.TileMode.CLAMP): + """centerColor is ignored, kept for API compatibility""" + super().__init__() + self._x, self._y = x, y + self._radius = radius + self._colors = list(colors) + self._positions = list(positions) if positions else None + self._tile = tile + + def getX(self) -> float: + return self._x + + def getY(self) -> float: + return self._y + + def getRadius(self) -> float: + return self._radius + + +# ═══════════════════════════════════════════════════════════════ +# SweepGradient +# ═══════════════════════════════════════════════════════════════ + +class SweepGradient(Shader): + """SweepGradient — 扫描渐变""" + + def __init__(self, x: float, y: float, + colors: Sequence[int], positions: Sequence[float]): + super().__init__() + self._x, self._y = x, y + self._colors = list(colors) + self._positions = list(positions) if positions else None + + def getX(self) -> float: + return self._x + + def getY(self) -> float: + return self._y + + +# ═══════════════════════════════════════════════════════════════ +# BitmapShader +# ═══════════════════════════════════════════════════════════════ + +class BitmapShader(Shader): + """BitmapShader — 位图着色器""" + + def __init__(self, bitmap: "Bitmap", tileX: int, tileY: int): + super().__init__() + self._bitmap = bitmap + self._tile_x = tileX + self._tile_y = tileY + + def getBitmap(self) -> "Bitmap": + return self._bitmap + + +# ═══════════════════════════════════════════════════════════════ +# ComposeShader +# ═══════════════════════════════════════════════════════════════ + +class ComposeShader(Shader): + """ComposeShader — 组合着色器""" + + def __init__(self, shaderA: Shader, shaderB: Shader, mode): + super().__init__() + self._shader_a = shaderA + self._shader_b = shaderB + self._mode = mode + + +# ═══════════════════════════════════════════════════════════════ +# MaskFilter / BlurMaskFilter / EmbossMaskFilter +# ═══════════════════════════════════════════════════════════════ + +class MaskFilter(Stub): + """MaskFilter — 遮罩过滤器基类""" + pass + + +class BlurMaskFilter(MaskFilter): + """BlurMaskFilter — 模糊遮罩过滤器""" + + NORMAL = 0 + SOLID = 1 + OUTER = 2 + INNER = 3 + + def __init__(self, radius: float, style: int): + super().__init__() + self._radius = radius + self._style = style + + def getRadius(self) -> float: + return self._radius + + def getStyle(self) -> int: + return self._style + + +class EmbossMaskFilter(MaskFilter): + """EmbossMaskFilter — 浮雕遮罩过滤器""" + + def __init__(self, direction: List[float], ambient: float, specular: float, blurRadius: float): + super().__init__() + self._direction = list(direction) + self._ambient = ambient + self._specular = specular + self._blur_radius = blurRadius + + +# ═══════════════════════════════════════════════════════════════ +# PathEffect hierarchy +# ═══════════════════════════════════════════════════════════════ + +class PathEffect(Stub): + """PathEffect — 路径效果基类""" + pass + + +class ComposePathEffect(PathEffect): + """ComposePathEffect — 组合路径效果""" + + def __init__(self, outerpe: PathEffect, innerpe: PathEffect): + super().__init__() + self._outer = outerpe + self._inner = innerpe + + +class CornerPathEffect(PathEffect): + """CornerPathEffect — 圆角路径效果""" + + def __init__(self, radius: float): + super().__init__() + self._radius = radius + + +class DashPathEffect(PathEffect): + """DashPathEffect — 虚线路径效果""" + + def __init__(self, intervals: List[float], phase: float): + super().__init__() + self._intervals = list(intervals) + self._phase = phase + + +class DiscretePathEffect(PathEffect): + """DiscretePathEffect — 离散路径效果""" + + def __init__(self, segmentLength: float, deviation: float): + super().__init__() + self._segment_length = segmentLength + self._deviation = deviation + + +class PathDashPathEffect(PathEffect): + """PathDashPathEffect — 路径虚线效果""" + + ROTATE = 0 + MORPH = 1 + TRANSLATE = 2 + + def __init__(self, shape: Path, advance: float, phase: float, style: int): + super().__init__() + self._shape = shape + self._advance = advance + self._phase = phase + self._style = style + + +class SumPathEffect(PathEffect): + """SumPathEffect — 求和路径效果""" + + def __init__(self, first: PathEffect, second: PathEffect): + super().__init__() + self._first = first + self._second = second + + +# ═══════════════════════════════════════════════════════════════ +# Xfermode hierarchy +# ═══════════════════════════════════════════════════════════════ + +class Xfermode(Stub): + """Xfermode — 传输模式基类""" + pass + + +class PorterDuffXfermode(Xfermode): + """PorterDuffXfermode — PorterDuff 传输模式""" + + def __init__(self, mode): + super().__init__() + self._mode = mode + + def getMode(self): + return self._mode + + +class AvoidXfermode(Xfermode): + """AvoidXfermode — deprecated, kept for API compatibility""" + + TARGET = 0 + AVOID = 1 + + def __init__(self, opColor: int, tolerance: int, mode: int): + super().__init__() + self._op_color = opColor + self._tolerance = tolerance + self._mode = mode + + +class PixelXorXfermode(Xfermode): + """PixelXorXfermode — deprecated, kept for API compatibility""" + + def __init__(self, opColor: int): + super().__init__() + self._op_color = opColor + + +# ═══════════════════════════════════════════════════════════════ +# DrawFilter +# ═══════════════════════════════════════════════════════════════ + +class DrawFilter(Stub): + """DrawFilter — 绘制过滤器基类""" + pass + + +class PaintFlagsDrawFilter(DrawFilter): + """PaintFlagsDrawFilter — 画笔标志绘制过滤器""" + + def __init__(self, clearBits: int, setBits: int): + super().__init__() + self._clear_bits = clearBits + self._set_bits = setBits + + +# ═══════════════════════════════════════════════════════════════ +# Camera +# ═══════════════════════════════════════════════════════════════ + +class Camera(Stub): + """Camera — 3D 相机变换""" + + def __init__(self): + super().__init__() + self._location_x = 0.0 + self._location_y = 0.0 + self._location_z = -8.0 + + def save(self): + pass + + def restore(self): + pass + + def translate(self, x: float, y: float, z: float): + self._location_x += x + self._location_y += y + self._location_z += z + + def rotateX(self, deg: float): + pass + + def rotateY(self, deg: float): + pass + + def rotateZ(self, deg: float): + pass + + def rotate(self, x: float, y: float, z: float): + pass + + def getMatrix(self, matrix: Matrix): + matrix.reset() + + def applyToCanvas(self, canvas: "Canvas"): + pass + + def setLocation(self, x: float, y: float, z: float): + self._location_x = x + self._location_y = y + self._location_z = z + + def dotWithNormal(self, dx: float, dy: float, dz: float) -> float: + return 0.0 + + +# ═══════════════════════════════════════════════════════════════ +# LayerRasterizer / Rasterizer +# ═══════════════════════════════════════════════════════════════ + +class Rasterizer(Stub): + """Rasterizer — 光栅化基类 (deprecated)""" + pass + + +class LayerRasterizer(Rasterizer): + """LayerRasterizer — 分层光栅化 (deprecated)""" + + def __init__(self): + super().__init__() + + def addLayer(self, paint: "Paint", dx: float = 0.0, dy: float = 0.0): + pass + + +# ═══════════════════════════════════════════════════════════════ +# NinePatch +# ═══════════════════════════════════════════════════════════════ + +class NinePatch(Stub): + """NinePatch — 九宫格图片""" + + def __init__(self, bitmap: "Bitmap", chunk: bytes): + super().__init__() + self._bitmap = bitmap + self._chunk = chunk if chunk else b"" + + def getBitmap(self) -> "Bitmap": + return self._bitmap + + def getWidth(self) -> int: + return self._bitmap.getWidth() if self._bitmap else 0 + + def getHeight(self) -> int: + return self._bitmap.getHeight() if self._bitmap else 0 + + @staticmethod + def isNinePatchChunk(chunk: bytes) -> bool: + return bool(chunk and len(chunk) > 0) + + +# ═══════════════════════════════════════════════════════════════ +# Picture / PictureDrawable +# ═══════════════════════════════════════════════════════════════ + +class Picture(Stub): + """Picture — 图画录制与回放""" + + def __init__(self): + super().__init__() + self._recorded = [] + + def beginRecording(self, width: int, height: int) -> "Canvas": + canvas = Canvas(width, height) + self._canvas = canvas + return canvas + + def endRecording(self): + self._canvas = None + + def draw(self, canvas: "Canvas"): + for cmd in self._recorded: + pass + + def getWidth(self) -> int: + return self._canvas.getWidth() if hasattr(self, "_canvas") and self._canvas else 0 + + def getHeight(self) -> int: + return self._canvas.getHeight() if hasattr(self, "_canvas") and self._canvas else 0 + + def createFromStream(self, stream) -> "Picture": + return Picture() + + def writeToStream(self, stream) -> bool: + return True + + +class PictureDrawable(Stub): + """PictureDrawable — 图画 Drawable""" + + def __init__(self, picture: Picture): + super().__init__() + self._picture = picture + + def getPicture(self) -> Picture: + return self._picture + + def setPicture(self, picture: Picture): + self._picture = picture + + def draw(self, canvas: "Canvas"): + pass + + +# ═══════════════════════════════════════════════════════════════ +# SurfaceTexture +# ═══════════════════════════════════════════════════════════════ + +class SurfaceTexture(Stub): + """SurfaceTexture — 表面纹理""" + + def __init__(self, texName: int = 0): + super().__init__() + self._tex_name = texName + self._timestamp = 0 + + def getTimestamp(self) -> int: + return self._timestamp + + def updateTexImage(self): + self._timestamp = int(time.time() * 1e9) + + def release(self): + pass + + def setDefaultBufferSize(self, width: int, height: int): + pass + + def attachToGLContext(self, texName: int): + pass + + def detachFromGLContext(self): + pass + + +# ═══════════════════════════════════════════════════════════════ +# Region / RegionIterator +# ═══════════════════════════════════════════════════════════════ + +class Region(Stub): + """Region — 区域""" + + OP_DIFFERENCE = 0 + OP_INTERSECT = 1 + OP_UNION = 2 + OP_XOR = 3 + OP_REVERSE_DIFFERENCE = 4 + OP_REPLACE = 5 + + def __init__(self, *args): + super().__init__() + if len(args) == 4: + self._rect = Rect(args[0], args[1], args[2], args[3]) + elif len(args) == 1 and isinstance(args[0], Rect): + self._rect = Rect(args[0].left, args[0].top, args[0].right, args[0].bottom) + else: + self._rect = Rect() + + def set(self, *args) -> bool: + if len(args) == 4: + self._rect.set(args[0], args[1], args[2], args[3]) + elif len(args) == 1 and isinstance(args[0], Rect): + r = args[0] + self._rect.set(r.left, r.top, r.right, r.bottom) + return True + + def getBounds(self, r: Rect = None) -> Rect: + if r: + r.set(self._rect.left, self._rect.top, self._rect.right, self._rect.bottom) + return r + return Rect(self._rect.left, self._rect.top, self._rect.right, self._rect.bottom) + + def isEmpty(self) -> bool: + return self._rect.isEmpty() + + def contains(self, x: int, y: int) -> bool: + return self._rect.contains(x, y) + + def op(self, *args) -> bool: + return False + + def isRect(self) -> bool: + return True + + def isComplex(self) -> bool: + return False + + def toString(self) -> str: + return f"Region({self._rect})" + + +class RegionIterator(Stub): + """RegionIterator — 区域迭代器""" + + def __init__(self, region: Region): + super().__init__() + self._region = region + self._done = False + + def next(self, r: Rect) -> bool: + if self._done: + return False + r.set(self._region._rect.left, self._region._rect.top, + self._region._rect.right, self._region._rect.bottom) + self._done = True + return True + + +# ═══════════════════════════════════════════════════════════════ +# Paint +# ═══════════════════════════════════════════════════════════════ + +class Paint(Stub): + """Paint — 画笔""" + + class Style: + FILL = 0 + STROKE = 1 + FILL_AND_STROKE = 2 + + class Cap: + BUTT = 0 + ROUND = 1 + SQUARE = 2 + + class Join: + MITER = 0 + ROUND = 1 + BEVEL = 2 + + class Align: + LEFT = 0 + CENTER = 1 + RIGHT = 2 + + ANTI_ALIAS_FLAG = 0x01 + FILTER_BITMAP_FLAG = 0x02 + DITHER_FLAG = 0x04 + UNDERLINE_TEXT_FLAG = 0x08 + STRIKE_THRU_TEXT_FLAG = 0x10 + FAKE_BOLD_TEXT_FLAG = 0x20 + LINEAR_TEXT_FLAG = 0x40 + SUBPIXEL_TEXT_FLAG = 0x80 + DEV_KERN_TEXT_FLAG = 0x100 + + ALIGN_LEFT = 0 + ALIGN_CENTER = 1 + ALIGN_RIGHT = 2 + + def __init__(self, flags: int = 0): + super().__init__() + self._flags = flags + self._color = 0xFF000000 + self._alpha = 255 + self._style = Paint.Style.FILL + self._stroke_width = 0.0 + self._text_size = 12.0 + self._typeface = None + self._anti_alias = bool(flags & Paint.ANTI_ALIAS_FLAG) + self._color_filter = None + self._mask_filter = None + self._shader = None + self._path_effect = None + self._xfermode = None + self._filter_bitmap = bool(flags & Paint.FILTER_BITMAP_FLAG) + self._dither = bool(flags & Paint.DITHER_FLAG) + self._subpixel_text = bool(flags & Paint.SUBPIXEL_TEXT_FLAG) + self._underline_text = bool(flags & Paint.UNDERLINE_TEXT_FLAG) + self._strike_thru_text = bool(flags & Paint.STRIKE_THRU_TEXT_FLAG) + self._text_align = Paint.Align.LEFT + self._text_scale_x = 1.0 + self._text_skew_x = 0.0 + self._shadow_layer = None + + def setColor(self, color: int): + self._color = color + self._alpha = (color >> 24) & 0xFF + + def getColor(self) -> int: + return self._color + + def setARGB(self, a: int, r: int, g: int, b: int): + self.setColor(Color.argb(a, r, g, b)) + + def setAlpha(self, alpha: int): + self._alpha = max(0, min(255, alpha)) + self._color = (self._color & 0x00FFFFFF) | (self._alpha << 24) + + def getAlpha(self) -> int: + return self._alpha + + def setStyle(self, style: int): + self._style = style + + def getStyle(self) -> int: + return self._style + + def setStrokeWidth(self, width: float): + self._stroke_width = width + + def getStrokeWidth(self) -> float: + return self._stroke_width + + def setTextSize(self, textSize: float): + self._text_size = textSize + + def getTextSize(self) -> float: + return self._text_size + + def setTypeface(self, typeface: Optional[Typeface]): + self._typeface = typeface + + def getTypeface(self) -> Optional[Typeface]: + return self._typeface + + def setAntiAlias(self, aa: bool): + self._anti_alias = aa + + def isAntiAlias(self) -> bool: + return self._anti_alias + + def setColorFilter(self, filter: Optional[ColorFilter]): + self._color_filter = filter + + def getColorFilter(self) -> Optional[ColorFilter]: + return self._color_filter + + def setMaskFilter(self, maskfilter: Optional[MaskFilter]): + self._mask_filter = maskfilter + + def getMaskFilter(self) -> Optional[MaskFilter]: + return self._mask_filter + + def setShader(self, shader: Optional[Shader]): + self._shader = shader + + def getShader(self) -> Optional[Shader]: + return self._shader + + def setPathEffect(self, effect: Optional[PathEffect]): + self._path_effect = effect + + def getPathEffect(self) -> Optional[PathEffect]: + return self._path_effect + + def setXfermode(self, xfermode: Optional[Xfermode]): + self._xfermode = xfermode + + def getXfermode(self) -> Optional[Xfermode]: + return self._xfermode + + def setFlags(self, flags: int): + self._flags = flags + + def getFlags(self) -> int: + return self._flags + + def setFilterBitmap(self, filter: bool): + self._filter_bitmap = filter + + def isFilterBitmap(self) -> bool: + return self._filter_bitmap + + def setDither(self, dither: bool): + self._dither = dither + + def isDither(self) -> bool: + return self._dither + + def setSubpixelText(self, subpixel: bool): + self._subpixel_text = subpixel + + def isSubpixelText(self) -> bool: + return self._subpixel_text + + def setUnderlineText(self, underline: bool): + self._underline_text = underline + + def isUnderlineText(self) -> bool: + return self._underline_text + + def setStrikeThruText(self, strike: bool): + self._strike_thru_text = strike + + def isStrikeThruText(self) -> bool: + return self._strike_thru_text + + def setTextScaleX(self, scaleX: float): + self._text_scale_x = scaleX + + def getTextScaleX(self) -> float: + return self._text_scale_x + + def setTextSkewX(self, skewX: float): + self._text_skew_x = skewX + + def getTextSkewX(self) -> float: + return self._text_skew_x + + def setTextAlign(self, align: int): + self._text_align = align + + def getTextAlign(self) -> int: + return self._text_align + + def setTextLocales(self, locales): + pass + + def setShadowLayer(self, radius: float, dx: float, dy: float, color: int): + self._shadow_layer = (radius, dx, dy, color) + + def clearShadowLayer(self): + self._shadow_layer = None + + def measureText(self, text: str) -> float: + return len(text) * self._text_size * 0.5 + + def breakText(self, text: str, maxWidth: float, measuredWidth: List[float]) -> int: + width = 0.0 + count = 0 + for i, ch in enumerate(text): + cw = self._text_size * 0.5 + if width + cw > maxWidth: + break + width += cw + count += 1 + measuredWidth[0] = width + return count + + def getTextWidths(self, text: str, widths: List[float]) -> int: + cw = self._text_size * 0.5 + for i, ch in enumerate(text): + widths[i] = cw + return len(text) + + def getTextPath(self, text: str, start: int, end: int, x: float, y: float, path: Path): + path.moveTo(x, y) + for i in range(start, end): + path.lineTo(x + (i - start + 1) * self._text_size * 0.3, y) + + def getFontMetrics(self) -> Dict[str, float]: + size = self._text_size + return { + "ascent": -size * 0.8, + "descent": size * 0.2, + "top": -size * 0.95, + "bottom": size * 0.25, + "leading": 0.0, + } + + def getFontMetricsInt(self) -> Dict[str, int]: + fm = self.getFontMetrics() + return {k: int(v) for k, v in fm.items()} + + def ascent(self) -> float: + return -self._text_size * 0.8 + + def descent(self) -> float: + return self._text_size * 0.2 + + +# ═══════════════════════════════════════════════════════════════ +# Bitmap +# ═══════════════════════════════════════════════════════════════ + +class Bitmap(Stub): + """Bitmap — 位图""" + + class Config: + ALPHA_8 = "ALPHA_8" + ARGB_4444 = "ARGB_4444" + ARGB_8888 = "ARGB_8888" + RGB_565 = "RGB_565" + RGBA_F16 = "RGBA_F16" + + class CompressFormat: + JPEG = "JPEG" + PNG = "PNG" + WEBP = "WEBP" + WEBP_LOSSY = "WEBP_LOSSY" + WEBP_LOSSLESS = "WEBP_LOSSLESS" + + def __init__(self, width: int, height: int, config: str = Config.ARGB_8888): + super().__init__() + self._width = width + self._height = height + self._config = config + self._recycled = False + self._has_alpha = config in (Bitmap.Config.ARGB_8888, Bitmap.Config.ARGB_4444, + Bitmap.Config.ALPHA_8, Bitmap.Config.RGBA_F16) + self._generation_id = 1 + + if HAS_PIL: + from PIL import Image + if config == Bitmap.Config.ALPHA_8: + mode = "L" + elif config == Bitmap.Config.RGB_565: + mode = "RGB" + else: + mode = "RGBA" + self._image = Image.new(mode, (width, height), (0, 0, 0, 0)) + else: + bpp = 4 if config == Bitmap.Config.ARGB_8888 else ( + 2 if config in (Bitmap.Config.ARGB_4444, Bitmap.Config.RGB_565) else 1 + ) + self._pixels = bytearray(width * height * bpp) + + @staticmethod + def createBitmap(width, height=None, config=None): + if isinstance(width, Bitmap): + src = width + dst = Bitmap(src._width, src._height, src._config) + if HAS_PIL and hasattr(src, "_image"): + from PIL import Image + dst._image = src._image.copy() + elif hasattr(src, "_pixels"): + dst._pixels = bytearray(src._pixels) + return dst + return Bitmap(width, height, config) + + @staticmethod + def createScaledBitmap(src: "Bitmap", dstWidth: int, dstHeight: int, + filter: bool = True) -> "Bitmap": + if HAS_PIL and hasattr(src, "_image"): + from PIL import Image + dst = Bitmap(dstWidth, dstHeight, src._config) + dst._image = src._image.resize((dstWidth, dstHeight), Image.LANCZOS if filter else Image.NEAREST) + return dst + dst = Bitmap(dstWidth, dstHeight, src._config) + return dst + + def copy(self, config: str, isMutable: bool) -> "Bitmap": + dst = Bitmap(self._width, self._height, config) + if HAS_PIL and hasattr(self, "_image"): + from PIL import Image + if config != self._config: + mode_map = {Bitmap.Config.ARGB_8888: "RGBA", Bitmap.Config.RGB_565: "RGB", + Bitmap.Config.ALPHA_8: "L"} + dst._image = self._image.convert(mode_map.get(config, "RGBA")) + else: + dst._image = self._image.copy() + elif hasattr(self, "_pixels"): + dst._pixels = bytearray(self._pixels) + return dst + + def compress(self, format: str, quality: int, stream) -> bool: + if self._recycled: + return False + if HAS_PIL and hasattr(self, "_image"): + pil_fmt = format.lower() + if pil_fmt == "jpeg": + pil_fmt = "jpeg" + elif pil_fmt == "webp": + pil_fmt = "webp" + else: + pil_fmt = "png" + if pil_fmt == "jpeg" and self._image.mode == "RGBA": + self._image = self._image.convert("RGB") + self._image.save(stream, format=pil_fmt.upper(), quality=quality) + return True + return False + + def recycle(self): + self._recycled = True + if HAS_PIL and hasattr(self, "_image"): + self._image = None + if hasattr(self, "_pixels"): + self._pixels = None + + def isRecycled(self) -> bool: + return self._recycled + + def getWidth(self) -> int: + return self._width + + def getHeight(self) -> int: + return self._height + + def getConfig(self) -> str: + return self._config + + def getRowBytes(self) -> int: + bpp = {"ALPHA_8": 1, "ARGB_4444": 2, "ARGB_8888": 4, "RGB_565": 2, "RGBA_F16": 8} + return self._width * bpp.get(self._config, 4) + + def getByteCount(self) -> int: + return self.getRowBytes() * self._height + + def getAllocationByteCount(self) -> int: + return self.getByteCount() + + def getPixel(self, x: int, y: int) -> int: + if self._recycled: + return 0 + if HAS_PIL and hasattr(self, "_image"): + p = self._image.getpixel((x, y)) + if self._image.mode == "RGBA": + return Color.argb(p[3], p[0], p[1], p[2]) + elif self._image.mode == "RGB": + return Color.rgb(p[0], p[1], p[2]) + elif self._image.mode == "L": + return Color.argb(255, p, p, p) + return 0 + + def getPixels(self, pixels: List[int], offset: int, stride: int, + x: int, y: int, width: int, height: int): + if self._recycled: + return + for row in range(height): + for col in range(width): + px = x + col + py = y + row + idx = offset + row * stride + col + if 0 <= idx < len(pixels) and 0 <= px < self._width and 0 <= py < self._height: + pixels[idx] = self.getPixel(px, py) + + def setPixel(self, x: int, y: int, color: int): + if self._recycled: + return + if HAS_PIL and hasattr(self, "_image"): + if self._image.mode == "RGBA": + self._image.putpixel((x, y), ( + Color.red(color), Color.green(color), + Color.blue(color), Color.alpha(color) + )) + elif self._image.mode == "RGB": + self._image.putpixel((x, y), ( + Color.red(color), Color.green(color), Color.blue(color) + )) + elif self._image.mode == "L": + self._image.putpixel((x, y), Color.red(color)) + else: + pass + + def setPixels(self, pixels: List[int], offset: int, stride: int, + x: int, y: int, width: int, height: int): + for row in range(height): + for col in range(width): + idx = offset + row * stride + col + if idx < len(pixels): + self.setPixel(x + col, y + row, pixels[idx]) + + def eraseColor(self, color: int): + if self._recycled: + return + if HAS_PIL and hasattr(self, "_image"): + from PIL import Image + w, h = self._image.size + if self._image.mode == "RGBA": + self._image = Image.new("RGBA", (w, h), + (Color.red(color), Color.green(color), + Color.blue(color), Color.alpha(color))) + elif self._image.mode == "RGB": + self._image = Image.new("RGB", (w, h), + (Color.red(color), Color.green(color), Color.blue(color))) + + def extractAlpha(self, paint: Paint = None) -> "Bitmap": + return Bitmap(self._width, self._height, Bitmap.Config.ALPHA_8) + + def sameAs(self, other: "Bitmap") -> bool: + if not isinstance(other, Bitmap): + return False + if self._width != other._width or self._height != other._height: + return False + return True + + def prepareToDraw(self): + pass + + def hasAlpha(self) -> bool: + return self._has_alpha + + def setHasAlpha(self, hasAlpha: bool): + self._has_alpha = hasAlpha + + def getGenerationId(self) -> int: + return self._generation_id + + def describeContents(self) -> int: + return 0 + + def writeToParcel(self, dest, flags: int): + pass + + def copyPixelsToBuffer(self, dst): + if HAS_PIL and hasattr(self, "_image"): + buf = self._image.tobytes() + dst.write(buf) + + def copyPixelsFromBuffer(self, src): + if HAS_PIL and hasattr(self, "_image"): + data = src.read() + import io as _io + buf = _io.BytesIO(data) + from PIL import Image + self._image = Image.open(buf) + self._image = self._image.resize((self._width, self._height)) + + def asMutable(self) -> "Bitmap": + return Bitmap.createBitmap(self) + + def toString(self) -> str: + return f"Bitmap({self._width}x{self._height}, config={self._config})" + + +# ═══════════════════════════════════════════════════════════════ +# BitmapFactory +# ═══════════════════════════════════════════════════════════════ + +class BitmapFactory(Stub): + """BitmapFactory — 位图工厂""" + + class Options(Stub): + """BitmapFactory.Options — 解码选项""" + + def __init__(self): + super().__init__() + self.inJustDecodeBounds = False + self.outWidth = 0 + self.outHeight = 0 + self.inSampleSize = 1 + self.inPreferredConfig = Bitmap.Config.ARGB_8888 + self.inDensity = 0 + self.inTargetDensity = 0 + self.inScaled = True + self.inMutable = False + self.outMimeType = "" + self.inPurgeable = False + self.inInputShareable = False + + @staticmethod + def decodeFile(pathName: str, opts: Options = None) -> Optional[Bitmap]: + resolved = resolve_android_path(pathName) + if not os.path.exists(resolved): + return None + if HAS_PIL: + from PIL import Image + try: + img = Image.open(resolved) + if opts and opts.inJustDecodeBounds: + opts.outWidth, opts.outHeight = img.size + opts.outMimeType = f"image/{img.format.lower() if img.format else 'png'}" + return None + w, h = img.size + bm = Bitmap(w, h, opts.inPreferredConfig if opts else Bitmap.Config.ARGB_8888) + if img.mode != "RGBA": + img = img.convert("RGBA") + bm._image = img + return bm + except Exception: + return None + return Bitmap(100, 100, Bitmap.Config.ARGB_8888) + + @staticmethod + def decodeResource(res, resId: int, opts: Options = None) -> Optional[Bitmap]: + return Bitmap(100, 100, Bitmap.Config.ARGB_8888) + + @staticmethod + def decodeStream(stream, outPadding: "Rect" = None, opts: Options = None) -> Optional[Bitmap]: + if stream is None: + return None + if HAS_PIL: + from PIL import Image + try: + img = Image.open(stream) + if opts and opts.inJustDecodeBounds: + opts.outWidth, opts.outHeight = img.size + return None + w, h = img.size + bm = Bitmap(w, h, opts.inPreferredConfig if opts else Bitmap.Config.ARGB_8888) + if img.mode != "RGBA": + img = img.convert("RGBA") + bm._image = img + return bm + except Exception: + return None + return Bitmap(100, 100, Bitmap.Config.ARGB_8888) + + @staticmethod + def decodeByteArray(data: bytes, offset: int, length: int, opts: Options = None) -> Optional[Bitmap]: + if not data: + return None + if HAS_PIL: + from PIL import Image + import io as _io + try: + buf = _io.BytesIO(data[offset:offset + length]) + img = Image.open(buf) + if opts and opts.inJustDecodeBounds: + opts.outWidth, opts.outHeight = img.size + return None + w, h = img.size + bm = Bitmap(w, h, opts.inPreferredConfig if opts else Bitmap.Config.ARGB_8888) + if img.mode != "RGBA": + img = img.convert("RGBA") + bm._image = img + return bm + except Exception: + return None + return Bitmap(100, 100, Bitmap.Config.ARGB_8888) + + @staticmethod + def decodeResourceStream(res, value, stream, pad: "Rect", opts: Options = None) -> Optional[Bitmap]: + return BitmapFactory.decodeStream(stream, pad, opts) + + +# ═══════════════════════════════════════════════════════════════ +# Canvas +# ═══════════════════════════════════════════════════════════════ + +class Canvas(Stub): + """Canvas — 画布""" + + ALL_SAVE_FLAG = 0x1F + + def __init__(self, width: int = 0, height: int = 0): + super().__init__() + if HAS_PIL: + from PIL import Image, ImageDraw + self._width = width + self._height = height + if width > 0 and height > 0: + self._image = Image.new("RGBA", (width, height), (0, 0, 0, 0)) + self._draw = ImageDraw.Draw(self._image) + else: + self._image = None + self._draw = None + else: + self._width = width + self._height = height + self._pixels = None + self._bitmap = None + self._save_count = 0 + self._matrix_stack = [Matrix()] + self._clip_stack = [Rect(0, 0, width, height)] + self._matrix = Matrix() + + def setBitmap(self, bitmap: Bitmap): + self._bitmap = bitmap + self._width = bitmap.getWidth() + self._height = bitmap.getHeight() + if HAS_PIL: + from PIL import ImageDraw + if hasattr(bitmap, "_image") and bitmap._image: + self._image = bitmap._image + self._draw = ImageDraw.Draw(self._image) + + def getBitmap(self) -> Optional[Bitmap]: + return self._bitmap + + def getWidth(self) -> int: + return self._width + + def getHeight(self) -> int: + return self._height + + def save(self) -> int: + self._save_count += 1 + self._matrix_stack.append(Matrix(self._matrix)) + self._clip_stack.append(Rect( + self._clip_stack[-1].left, self._clip_stack[-1].top, + self._clip_stack[-1].right, self._clip_stack[-1].bottom + )) + return self._save_count + + def restore(self): + if len(self._matrix_stack) > 1: + self._matrix = self._matrix_stack.pop() + self._clip_stack.pop() + self._save_count -= 1 + + def saveLayer(self, bounds: RectF, paint: Paint = None, saveFlags: int = ALL_SAVE_FLAG) -> int: + return self.save() + + def getSaveCount(self) -> int: + return self._save_count + + def restoreToCount(self, saveCount: int): + while self._save_count > saveCount: + self.restore() + + def translate(self, dx: float, dy: float): + self._matrix.postTranslate(dx, dy) + + def scale(self, sx: float, sy: float, px: float = 0.0, py: float = 0.0): + self._matrix.postScale(sx, sy, px, py) + + def rotate(self, degrees: float, px: float = 0.0, py: float = 0.0): + self._matrix.postRotate(degrees, px, py) + + def skew(self, sx: float, sy: float): + self._matrix.postSkew(sx, sy) + + def concat(self, matrix: Matrix): + self._matrix.postConcat(matrix) + + def setMatrix(self, matrix: Matrix): + self._matrix = Matrix(matrix) + + def getMatrix(self, ctm: Matrix = None) -> Matrix: + if ctm: + ctm._values = list(self._matrix._values) + return ctm + return Matrix(self._matrix) + + def getLocalTransform(self, transform: Matrix = None) -> Matrix: + return self.getMatrix(transform) + + def getDeviceTransform(self, transform: Matrix = None) -> Matrix: + if transform: + transform.reset() + return transform + return Matrix() + + def clipRect(self, left: float, top: float, right: float, bottom: float, + op: int = ClipOp.INTERSECT): + r = self._clip_stack[-1] + if op == ClipOp.INTERSECT: + self._clip_stack[-1] = Rect( + max(r.left, int(left)), max(r.top, int(top)), + min(r.right, int(right)), min(r.bottom, int(bottom)) + ) + elif op == ClipOp.DIFFERENCE: + pass + + def clipPath(self, path: Path, op: int = ClipOp.INTERSECT): + bounds = path.computeBounds() + self.clipRect(bounds.left, bounds.top, bounds.right, bounds.bottom, op) + + def clipRegion(self, region: Region, op: int = ClipOp.INTERSECT): + r = region._rect + self.clipRect(float(r.left), float(r.top), float(r.right), float(r.bottom), op) + + def getClipBounds(self, bounds: Rect = None) -> Rect: + r = self._clip_stack[-1] + if bounds: + bounds.set(r.left, r.top, r.right, r.bottom) + return bounds + return Rect(r.left, r.top, r.right, r.bottom) + + def quickReject(self, *args) -> bool: + return False + + def drawColor(self, color: int): + if HAS_PIL and self._draw is not None: + r, g, b = Color.red(color), Color.green(color), Color.blue(color) + a = Color.alpha(color) + self._draw.rectangle([0, 0, self._width, self._height], + fill=(r, g, b, a)) + + def drawARGB(self, a: int, r: int, g: int, b: int): + self.drawColor(Color.argb(a, r, g, b)) + + def drawRGB(self, r: int, g: int, b: int): + self.drawARGB(255, r, g, b) + + def drawPaint(self, paint: Paint): + self.drawColor(paint.getColor()) + + def drawPoint(self, x: float, y: float, paint: Paint): + if HAS_PIL and self._draw is not None: + c = paint.getColor() + self._draw.point([(x, y)], fill=( + Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c) + )) + + def drawPoints(self, pts: List[float], offset: int = 0, count: int = -1, paint: Paint = None): + if paint is None: + paint = Paint() + if count < 0: + count = len(pts) - offset + for i in range(offset, offset + count, 2): + self.drawPoint(pts[i], pts[i + 1], paint) + + def drawLine(self, startX: float, startY: float, stopX: float, stopY: float, paint: Paint): + if HAS_PIL and self._draw is not None: + c = paint.getColor() + w = paint.getStrokeWidth() if paint.getStyle() != Paint.Style.FILL else 1 + self._draw.line([(startX, startY), (stopX, stopY)], + fill=(Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)), + width=max(1, int(w))) + + def drawLines(self, pts: List[float], offset: int = 0, count: int = -1, paint: Paint = None): + if paint is None: + paint = Paint() + if count < 0: + count = len(pts) - offset + for i in range(offset, offset + count, 4) if count >= 4 else []: + self.drawLine(pts[i], pts[i + 1], pts[i + 2], pts[i + 3], paint) + + def drawRect(self, rect: Union[Rect, RectF, tuple], paint: Paint): + if isinstance(rect, Rect): + l, t, r, b = rect.left, rect.top, rect.right, rect.bottom + elif isinstance(rect, RectF): + l, t, r, b = rect.left, rect.top, rect.right, rect.bottom + else: + l, t, r, b = rect + if HAS_PIL and self._draw is not None: + c = paint.getColor() + fill_color = (Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)) + if paint.getStyle() == Paint.Style.FILL: + self._draw.rectangle([l, t, r, b], fill=fill_color) + elif paint.getStyle() == Paint.Style.STROKE: + w = max(1, int(paint.getStrokeWidth())) + self._draw.rectangle([l, t, r, b], outline=fill_color, width=w) + else: + self._draw.rectangle([l, t, r, b], fill=fill_color) + + def drawRoundRect(self, rect: Union[RectF, tuple], rx: float, ry: float, paint: Paint): + if isinstance(rect, RectF): + l, t, r, b = rect.left, rect.top, rect.right, rect.bottom + else: + l, t, r, b = rect + if HAS_PIL and self._draw is not None: + c = paint.getColor() + fill_color = (Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)) + self._draw.rounded_rectangle( + [l, t, r, b], radius=rx, + fill=fill_color if paint.getStyle() != Paint.Style.STROKE else None, + outline=fill_color if paint.getStyle() != Paint.Style.FILL else None, + width=max(1, int(paint.getStrokeWidth())) if paint.getStyle() != Paint.Style.FILL else 1 + ) + + def drawCircle(self, cx: float, cy: float, radius: float, paint: Paint): + if HAS_PIL and self._draw is not None: + c = paint.getColor() + fill_color = (Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)) + bbox = [cx - radius, cy - radius, cx + radius, cy + radius] + if paint.getStyle() == Paint.Style.FILL: + self._draw.ellipse(bbox, fill=fill_color) + elif paint.getStyle() == Paint.Style.STROKE: + w = max(1, int(paint.getStrokeWidth())) + self._draw.ellipse(bbox, outline=fill_color, width=w) + else: + self._draw.ellipse(bbox, fill=fill_color) + + def drawOval(self, rect: Union[RectF, tuple], paint: Paint): + if isinstance(rect, RectF): + l, t, r, b = rect.left, rect.top, rect.right, rect.bottom + else: + l, t, r, b = rect + if HAS_PIL and self._draw is not None: + c = paint.getColor() + fill_color = (Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)) + self._draw.ellipse([l, t, r, b], fill=fill_color) + + def drawArc(self, rect: Union[RectF, tuple], startAngle: float, sweepAngle: float, + useCenter: bool, paint: Paint): + if isinstance(rect, RectF): + l, t, r, b = rect.left, rect.top, rect.right, rect.bottom + else: + l, t, r, b = rect + if HAS_PIL and self._draw is not None: + c = paint.getColor() + fill_color = (Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)) + if not HAS_PIL: + return + from PIL import ImageDraw + self._draw.pieslice( + [l, t, r, b], start=startAngle, end=startAngle + sweepAngle, + fill=fill_color if useCenter or paint.getStyle() != Paint.Style.STROKE else None, + outline=fill_color if paint.getStyle() != Paint.Style.FILL else None, + width=max(1, int(paint.getStrokeWidth())) if paint.getStyle() != Paint.Style.FILL else 1 + ) + + def drawPath(self, path: Path, paint: Paint): + if HAS_PIL and self._draw is not None: + pil_path = [] + for seg in path._segments: + if seg["type"] == "move": + pil_path.append(("M", seg["x"], seg["y"])) + elif seg["type"] == "line": + pil_path.append(("L", seg["x"], seg["y"])) + elif seg["type"] == "close": + pil_path.append(("Z",)) + elif seg["type"] in ("quad", "cubic"): + pass + if pil_path: + from PIL import ImageDraw + c = paint.getColor() + fill_color = (Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)) + try: + if paint.getStyle() == Paint.Style.FILL: + self._draw.polygon( + [(s[1], s[2]) for s in pil_path if s[0] in ("M", "L")], + fill=fill_color + ) + else: + w = max(1, int(paint.getStrokeWidth())) + if len(pil_path) > 1: + pts = [(s[1], s[2]) for s in pil_path if s[0] in ("M", "L")] + for i in range(len(pts) - 1): + self._draw.line([pts[i], pts[i + 1]], fill=fill_color, width=w) + except Exception: + pass + + def drawBitmap(self, bitmap: Bitmap, left: float, top: float, paint: Paint = None): + if HAS_PIL and self._draw is not None and hasattr(bitmap, "_image") and bitmap._image: + self._image.paste(bitmap._image, (int(left), int(top))) + elif HAS_PIL and self._image is not None: + pass + + def drawBitmap(self, bitmap: Bitmap, src: Rect, dst: RectF, paint: Paint = None): + if HAS_PIL and self._image is not None and hasattr(bitmap, "_image") and bitmap._image: + if src: + cropped = bitmap._image.crop((src.left, src.top, src.right, src.bottom)) + resized = cropped.resize((int(dst.width()), int(dst.height()))) + self._image.paste(resized, (int(dst.left), int(dst.top))) + else: + resized = bitmap._image.resize((int(dst.width()), int(dst.height()))) + self._image.paste(resized, (int(dst.left), int(dst.top))) + + def drawText(self, text: str, x: float, y: float, paint: Paint): + if HAS_PIL and self._draw is not None: + c = paint.getColor() + fill_color = (Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)) + self._draw.text((x, y), text, fill=fill_color) + + def drawTextOnPath(self, text: str, path: Path, hOffset: float, vOffset: float, paint: Paint): + pass + + def drawPosText(self, text: str, pos: List[float], paint: Paint): + if HAS_PIL and self._draw is not None: + c = paint.getColor() + fill_color = (Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)) + for i, ch in enumerate(text): + if i * 2 + 1 < len(pos): + self._draw.text((pos[i * 2], pos[i * 2 + 1]), ch, fill=fill_color) + + def drawPicture(self, picture: Picture, dst: Union[Rect, RectF] = None): + pass + + def drawPatch(self, patch: NinePatch, dst: Rect, paint: Paint = None): + pass + + def drawDoubleRoundRect(self, outer: RectF, outerRx: float, outerRy: float, + inner: RectF, innerRx: float, innerRy: float, paint: Paint): + pass + + def drawBitmapMesh(self, bitmap: Bitmap, meshWidth: int, meshHeight: int, + verts: List[float], vertOffset: int, colors: List[int], + colorOffset: int, paint: Paint = None): + pass + + def drawVertices(self, mode: int, vertexCount: int, verts: List[float], + vertOffset: int, texs: List[float], texOffset: int, + colors: List[int], colorOffset: int, indices: List[int], + indexOffset: int, indexCount: int, paint: Paint): + pass + + def isHardwareAccelerated(self) -> bool: + return False + + def isOpaque(self) -> bool: + return False + + def setDensity(self, density: int): + pass + + def getDensity(self) -> int: + return 0 + + def toString(self) -> str: + return f"Canvas({self._width}x{self._height})" + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + # Core + "Bitmap", "BitmapFactory", "Canvas", "Paint", "Color", "ColorFilter", + "PorterDuffColorFilter", "LightingColorFilter", "ComposeColorFilter", + "ColorMatrix", "ColorMatrixColorFilter", "Path", "PathMeasure", + "Rect", "RectF", "Point", "PointF", "Typeface", "Matrix", + + # Shader hierarchy + "Shader", "LinearGradient", "RadialGradient", "SweepGradient", + "BitmapShader", "ComposeShader", + + # MaskFilter hierarchy + "MaskFilter", "BlurMaskFilter", "EmbossMaskFilter", + + # PorterDuff + "PorterDuff", "PorterDuffXfermode", "Xfermode", + "AvoidXfermode", "PixelXorXfermode", + + # DrawFilter + "DrawFilter", "PaintFlagsDrawFilter", + + # PathEffect hierarchy + "PathEffect", "SumPathEffect", "CornerPathEffect", "DashPathEffect", + "DiscretePathEffect", "PathDashPathEffect", "ComposePathEffect", + + # Misc + "Camera", "SurfaceTexture", "Region", "RegionIterator", + "NinePatch", "Picture", "PictureDrawable", + "Rasterizer", "LayerRasterizer", + + # BlendMode + "BlendMode", "BlendModeColorFilter", + "ClipOp", +] \ No newline at end of file diff --git a/android_pyapi/android/graphics_drawable.py b/android_pyapi/android/graphics_drawable.py new file mode 100644 index 0000000..ea929de --- /dev/null +++ b/android_pyapi/android/graphics_drawable.py @@ -0,0 +1,1128 @@ +""" +Android Graphics Drawable 组件 — Drawable, BitmapDrawable, ColorDrawable 等 +方法签名完全对齐 Android SDK +""" + +import math +from typing import Any, Dict, List, Optional, Sequence, Tuple, Union + +from .._core import Stub, AndroidOnlyError, android_context, HAS_PIL, resolve_android_path +from .graphics import ( + Bitmap, Canvas, Color, ColorFilter, Paint, PorterDuff, PorterDuffColorFilter, + Rect, RectF, Matrix, Path, Shader, Rect, + BlendMode, BlendModeColorFilter, +) + + +# ═══════════════════════════════════════════════════════════════ +# ColorStateList +# ═══════════════════════════════════════════════════════════════ + +class ColorStateList(Stub): + """ColorStateList — 颜色状态列表""" + + def __init__(self, states: List[List[int]], colors: List[int]): + super().__init__() + self._states = list(states) + self._colors = list(colors) + self._default_color = colors[-1] if colors else 0 + + def getColorForState(self, stateSet: List[int], defaultColor: int = 0) -> int: + return self._default_color + + def getDefaultColor(self) -> int: + return self._default_color + + def isStateful(self) -> bool: + return len(self._states) > 0 + + def withAlpha(self, alpha: int) -> "ColorStateList": + new_colors = [] + for c in self._colors: + a = Color.alpha(c) + new_a = int(a * alpha / 255) + new_colors.append(Color.argb(new_a, Color.red(c), Color.green(c), Color.blue(c))) + return ColorStateList(self._states, new_colors) + + @staticmethod + def valueOf(color: int) -> "ColorStateList": + return ColorStateList([[]], [color]) + + def toString(self) -> str: + return f"ColorStateList({len(self._states)} states)" + + +# ═══════════════════════════════════════════════════════════════ +# Drawable +# ═══════════════════════════════════════════════════════════════ + +class Drawable(Stub): + """Drawable — 可绘制对象的抽象基类""" + + def __init__(self): + super().__init__() + self._bounds = Rect(0, 0, 0, 0) + self._alpha = 255 + self._color_filter = None + self._callback = None + self._visible = True + self._level = 0 + self._intrinsic_width = -1 + self._intrinsic_height = -1 + + def setBounds(self, left: int, top: int, right: int, bottom: int): + self._bounds.set(left, top, right, bottom) + + def setBounds(self, bounds: Rect): + self._bounds.set(bounds.left, bounds.top, bounds.right, bounds.bottom) + + def getBounds(self) -> Rect: + return self._bounds + + def copyBounds(self) -> Rect: + return Rect(self._bounds.left, self._bounds.top, + self._bounds.right, self._bounds.bottom) + + def copyBounds(self, out: Rect) -> Rect: + out.set(self._bounds.left, self._bounds.top, + self._bounds.right, self._bounds.bottom) + return out + + def getIntrinsicWidth(self) -> int: + return self._intrinsic_width + + def getIntrinsicHeight(self) -> int: + return self._intrinsic_height + + def setAlpha(self, alpha: int): + self._alpha = alpha + + def getAlpha(self) -> int: + return self._alpha + + def setColorFilter(self, colorFilter: Optional[ColorFilter]): + self._color_filter = colorFilter + + def getColorFilter(self) -> Optional[ColorFilter]: + return self._color_filter + + def getOpacity(self) -> int: + return 0 # PixelFormat.UNKNOWN + + def invalidateSelf(self): + if self._callback: + self._callback.invalidateDrawable(self) + + def setCallback(self, cb): + self._callback = cb + + def getCallback(self): + return self._callback + + def scheduleDrawable(self, what, who, when: int): + if self._callback: + self._callback.scheduleDrawable(what, who, when) + + def unscheduleDrawable(self, what, who): + if self._callback: + self._callback.unscheduleDrawable(what, who) + + def draw(self, canvas: Canvas): + pass + + def setVisible(self, visible: bool, restart: bool = False) -> bool: + old = self._visible + self._visible = visible + return old + + def isVisible(self) -> bool: + return self._visible + + def setLevel(self, level: int) -> bool: + self._level = level + return True + + def getLevel(self) -> int: + return self._level + + def getConstantState(self) -> Optional["DrawableConstantState"]: + return None + + def getCurrent(self) -> "Drawable": + return self + + def mutate(self) -> "Drawable": + return self + + def getMinimumWidth(self) -> int: + return 0 + + def getMinimumHeight(self) -> int: + return 0 + + def setDither(self, dither: bool): + pass + + def setFilterBitmap(self, filter: bool): + pass + + def setHotspot(self, x: float, y: float): + pass + + def setHotspotBounds(self, left: int, top: int, right: int, bottom: int): + pass + + def getHotspotBounds(self, outRect: Rect): + outRect.set(0, 0, 0, 0) + + def isStateful(self) -> bool: + return False + + def setState(self, stateSet: List[int]) -> bool: + return False + + def getState(self) -> List[int]: + return [] + + def jumpToCurrentState(self): + pass + + def clearColorFilter(self): + self._color_filter = None + + def getTransparentRegion(self): + from .graphics import Region + return Region(self._bounds) + + def onBoundsChange(self, bounds: Rect): + pass + + def onLevelChange(self, level: int) -> bool: + return False + + def onStateChange(self, stateSet: List[int]) -> bool: + return False + + def toString(self) -> str: + return f"{self.__class__.__name__}({self._bounds})" + + +class DrawableConstantState(Stub): + """DrawableConstantState — Drawable 常量状态""" + pass + + +# ═══════════════════════════════════════════════════════════════ +# BitmapDrawable +# ═══════════════════════════════════════════════════════════════ + +class BitmapDrawable(Drawable): + """BitmapDrawable — 位图 Drawable""" + + def __init__(self, res=None, bitmap: Bitmap = None): + super().__init__() + self._bitmap = bitmap if bitmap else Bitmap(0, 0, Bitmap.Config.ARGB_8888) + self._paint = Paint() + self._target_density = 160 + self._gravity = 0x33 # Gravity.FILL + self._tile_mode_x = None + self._tile_mode_y = None + self._mutated = False + if self._bitmap: + self._intrinsic_width = self._bitmap.getWidth() + self._intrinsic_height = self._bitmap.getHeight() + + def getBitmap(self) -> Bitmap: + return self._bitmap + + def getPaint(self) -> Paint: + return self._paint + + def setAntiAlias(self, aa: bool): + self._paint.setAntiAlias(aa) + + def setFilterBitmap(self, filter: bool): + self._paint.setFilterBitmap(filter) + + def setDither(self, dither: bool): + self._paint.setDither(dither) + + def setTileModeX(self, mode): + self._tile_mode_x = mode + + def setTileModeY(self, mode): + self._tile_mode_y = mode + + def getTileModeX(self): + return self._tile_mode_x + + def getTileModeY(self): + return self._tile_mode_y + + def setGravity(self, gravity: int): + self._gravity = gravity + + def getGravity(self) -> int: + return self._gravity + + def setTargetDensity(self, density: int): + self._target_density = density + + def getTargetDensity(self) -> int: + return self._target_density + + def draw(self, canvas: Canvas): + if self._bitmap: + bounds = self._bounds + if HAS_PIL and hasattr(canvas, "_image") and hasattr(self._bitmap, "_image"): + bm_img = self._bitmap._image + if bm_img: + resized = bm_img.resize((bounds.width(), bounds.height())) + canvas._image.paste(resized, (bounds.left, bounds.top)) + + def getIntrinsicWidth(self) -> int: + return self._bitmap.getWidth() if self._bitmap else -1 + + def getIntrinsicHeight(self) -> int: + return self._bitmap.getHeight() if self._bitmap else -1 + + def getOpacity(self) -> int: + if self._bitmap: + return 1 if self._bitmap.hasAlpha() else -1 + return 0 + + def mutate(self) -> "BitmapDrawable": + if not self._mutated: + self._bitmap = Bitmap.createBitmap(self._bitmap) + self._paint = Paint() + self._mutated = True + return self + + +# ═══════════════════════════════════════════════════════════════ +# ColorDrawable +# ═══════════════════════════════════════════════════════════════ + +class ColorDrawable(Drawable): + """ColorDrawable — 纯色 Drawable""" + + def __init__(self, color: int = 0): + super().__init__() + self._color = color + self._paint = Paint() + self._paint.setColor(color) + + def getColor(self) -> int: + return self._color + + def setColor(self, color: int): + self._color = color + self._paint.setColor(color) + + def setAlpha(self, alpha: int): + self._paint.setAlpha(alpha) + + def getAlpha(self) -> int: + return self._paint.getAlpha() + + def draw(self, canvas: Canvas): + canvas.drawRect(self._bounds, self._paint) + + def getOpacity(self) -> int: + if Color.alpha(self._color) == 255: + return -1 # OPAQUE + return -3 # TRANSLUCENT + + def mutate(self) -> "ColorDrawable": + self._paint = Paint() + self._paint.setColor(self._color) + return self + + +# ═══════════════════════════════════════════════════════════════ +# GradientDrawable +# ═══════════════════════════════════════════════════════════════ + +class GradientDrawable(Drawable): + """GradientDrawable — 渐变 Drawable""" + + RECTANGLE = 0 + OVAL = 1 + LINE = 2 + RING = 3 + + class Orientation: + TOP_BOTTOM = 0 + TR_BL = 1 + RIGHT_LEFT = 2 + BR_TL = 3 + BOTTOM_TOP = 4 + BL_TR = 5 + LEFT_RIGHT = 6 + TL_BR = 7 + + def __init__(self, orientation: int = Orientation.TOP_BOTTOM, colors: List[int] = None): + super().__init__() + self._orientation = orientation + self._colors = colors if colors else [Color.BLACK, Color.WHITE] + self._shape = GradientDrawable.RECTANGLE + self._corner_radius = 0.0 + self._corner_radii = None + self._stroke_width = 0 + self._stroke_color = 0 + self._gradient_type = 0 # LINEAR_GRADIENT + self._gradient_center_x = 0.5 + self._gradient_center_y = 0.5 + self._use_level = False + self._width = -1 + self._height = -1 + self._color = None + + def setShape(self, shape: int): + self._shape = shape + + def getShape(self) -> int: + return self._shape + + def setSize(self, width: int, height: int): + self._width = width + self._height = height + + def setStroke(self, width: int, color: int, dashWidth: float = 0, dashGap: float = 0): + self._stroke_width = width + self._stroke_color = color + + def setCornerRadius(self, radius: float): + self._corner_radius = radius + self._corner_radii = None + + def setCornerRadii(self, radii: List[float]): + self._corner_radii = radii + self._corner_radius = radii[0] if radii else 0 + + def setColors(self, colors: List[int]): + self._colors = list(colors) + self._color = None + + def setColor(self, color: int): + self._color = color + self._colors = None + + def setGradientType(self, gradientType: int): + self._gradient_type = gradientType + + def setGradientCenter(self, x: float, y: float): + self._gradient_center_x = x + self._gradient_center_y = y + + def setOrientation(self, orientation: int): + self._orientation = orientation + + def setUseLevel(self, useLevel: bool): + self._use_level = useLevel + + def getIntrinsicWidth(self) -> int: + return self._width if self._width > 0 else super().getIntrinsicWidth() + + def getIntrinsicHeight(self) -> int: + return self._height if self._height > 0 else super().getIntrinsicHeight() + + def draw(self, canvas: Canvas): + bounds = self._bounds + if HAS_PIL and hasattr(canvas, "_draw") and canvas._draw: + if self._color is not None: + c = self._color + fill_color = (Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)) + elif self._colors: + c = self._colors[0] + fill_color = (Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)) + else: + fill_color = (0, 0, 0, 255) + + if self._shape == GradientDrawable.OVAL: + canvas._draw.ellipse([bounds.left, bounds.top, bounds.right, bounds.bottom], + fill=fill_color) + elif self._shape == GradientDrawable.RECTANGLE and self._corner_radius > 0: + canvas._draw.rounded_rectangle( + [bounds.left, bounds.top, bounds.right, bounds.bottom], + radius=self._corner_radius, fill=fill_color) + else: + canvas._draw.rectangle([bounds.left, bounds.top, bounds.right, bounds.bottom], + fill=fill_color) + + +# ═══════════════════════════════════════════════════════════════ +# LayerDrawable +# ═══════════════════════════════════════════════════════════════ + +class LayerDrawable(Drawable): + """LayerDrawable — 图层 Drawable""" + + def __init__(self, layers: List[Drawable]): + super().__init__() + self._layers = list(layers) + self._ids = list(range(len(layers))) + self._layer_insets = [Rect(0, 0, 0, 0) for _ in layers] + + def findDrawableByLayerId(self, id: int) -> Optional[Drawable]: + for i, lid in enumerate(self._ids): + if lid == id: + return self._layers[i] + return None + + def setId(self, index: int, id: int): + if 0 <= index < len(self._ids): + self._ids[index] = id + + def getNumberOfLayers(self) -> int: + return len(self._layers) + + def getDrawable(self, index: int) -> Optional[Drawable]: + if 0 <= index < len(self._layers): + return self._layers[index] + return None + + def setDrawableByLayerId(self, id: int, drawable: Drawable) -> bool: + for i, lid in enumerate(self._ids): + if lid == id: + self._layers[i] = drawable + return True + return False + + def setLayerInset(self, index: int, l: int, t: int, r: int, b: int): + if 0 <= index < len(self._layer_insets): + self._layer_insets[index].set(l, t, r, b) + + def setLayerInsetLeft(self, index: int, left: int): + if 0 <= index < len(self._layer_insets): + self._layer_insets[index].left = left + + def setLayerInsetTop(self, index: int, top: int): + if 0 <= index < len(self._layer_insets): + self._layer_insets[index].top = top + + def setLayerInsetRight(self, index: int, right: int): + if 0 <= index < len(self._layer_insets): + self._layer_insets[index].right = right + + def setLayerInsetBottom(self, index: int, bottom: int): + if 0 <= index < len(self._layer_insets): + self._layer_insets[index].bottom = bottom + + def draw(self, canvas: Canvas): + for i, layer in enumerate(self._layers): + ins = self._layer_insets[i] if i < len(self._layer_insets) else Rect(0, 0, 0, 0) + b = self._bounds + layer.setBounds(b.left + ins.left, b.top + ins.top, + b.right - ins.right, b.bottom - ins.bottom) + layer.draw(canvas) + + def mutate(self) -> "LayerDrawable": + return self + + def getOpacity(self) -> int: + return 0 + + def isStateful(self) -> bool: + return any(d.isStateful() for d in self._layers) + + def setVisible(self, visible: bool, restart: bool = False) -> bool: + old = super().setVisible(visible, restart) + for d in self._layers: + d.setVisible(visible, restart) + return old + + +# ═══════════════════════════════════════════════════════════════ +# StateListDrawable +# ═══════════════════════════════════════════════════════════════ + +class StateListDrawable(Drawable): + """StateListDrawable — 状态列表 Drawable""" + + def __init__(self): + super().__init__() + self._state_sets: List[List[int]] = [] + self._drawables: List[Drawable] = [] + self._current_index = -1 + + def addState(self, stateSet: List[int], drawable: Drawable): + self._state_sets.append(stateSet) + self._drawables.append(drawable) + + def selectDrawable(self, index: int) -> bool: + if 0 <= index < len(self._drawables): + self._current_index = index + return True + return False + + def getCurrent(self) -> Drawable: + if 0 <= self._current_index < len(self._drawables): + return self._drawables[self._current_index] + if self._drawables: + return self._drawables[0] + return self + + def draw(self, canvas: Canvas): + d = self.getCurrent() + d.setBounds(self._bounds) + d.draw(canvas) + + def isStateful(self) -> bool: + return True + + def setState(self, stateSet: List[int]) -> bool: + for i, ss in enumerate(self._state_sets): + if not ss or all(s in stateSet for s in ss): + self._current_index = i + return True + return False + + def mutate(self) -> "StateListDrawable": + self._drawables = [d.mutate() for d in self._drawables] + return self + + +# ═══════════════════════════════════════════════════════════════ +# LevelListDrawable +# ═══════════════════════════════════════════════════════════════ + +class LevelListDrawable(Drawable): + """LevelListDrawable — 级别列表 Drawable""" + + def __init__(self): + super().__init__() + self._levels: List[Tuple[int, int, Drawable]] = [] + self._current_index = -1 + + def addLevel(self, low: int, high: int, drawable: Drawable): + self._levels.append((low, high, drawable)) + + def onLevelChange(self, level: int) -> bool: + for i, (low, high, d) in enumerate(self._levels): + if low <= level <= high: + self._current_index = i + return True + return False + + def getCurrent(self) -> Drawable: + if 0 <= self._current_index < len(self._levels): + return self._levels[self._current_index][2] + if self._levels: + return self._levels[0][2] + return self + + def draw(self, canvas: Canvas): + d = self.getCurrent() + d.setBounds(self._bounds) + d.draw(canvas) + + +# ═══════════════════════════════════════════════════════════════ +# TransitionDrawable +# ═══════════════════════════════════════════════════════════════ + +class TransitionDrawable(Drawable): + """TransitionDrawable — 过渡 Drawable""" + + def __init__(self, layers: List[Drawable]): + super().__init__() + self._layers = list(layers) + self._transition_progress = 0.0 + self._reverse = False + + def startTransition(self, durationMillis: int): + self._transition_progress = 0.0 + self._reverse = False + + def resetTransition(self): + self._transition_progress = 0.0 + self._reverse = False + + def reverse(self, durationMillis: int): + self._transition_progress = 1.0 + self._reverse = True + + def startReverse(self, durationMillis: int = 0): + self._transition_progress = 1.0 + self._reverse = True + + def draw(self, canvas: Canvas): + for layer in self._layers: + layer.setBounds(self._bounds) + layer.draw(canvas) + + def getNumberOfLayers(self) -> int: + return len(self._layers) + + def getDrawable(self, index: int) -> Optional[Drawable]: + if 0 <= index < len(self._layers): + return self._layers[index] + return None + + def isCrossFadeEnabled(self) -> bool: + return True + + def setCrossFadeEnabled(self, enabled: bool): + pass + + +# ═══════════════════════════════════════════════════════════════ +# RotateDrawable +# ═══════════════════════════════════════════════════════════════ + +class RotateDrawable(Drawable): + """RotateDrawable — 旋转 Drawable""" + + def __init__(self): + super().__init__() + self._drawable = None + self._from_degrees = 0.0 + self._to_degrees = 360.0 + self._pivot_x = 0.5 + self._pivot_y = 0.5 + self._current_degrees = 0.0 + + def setDrawable(self, drawable: Drawable): + self._drawable = drawable + + def getDrawable(self) -> Optional[Drawable]: + return self._drawable + + def setFromDegrees(self, fromDegrees: float): + self._from_degrees = fromDegrees + + def setToDegrees(self, toDegrees: float): + self._to_degrees = toDegrees + + def setPivotX(self, pivotX: float): + self._pivot_x = pivotX + + def setPivotY(self, pivotY: float): + self._pivot_y = pivotY + + def draw(self, canvas: Canvas): + if self._drawable: + self._drawable.setBounds(self._bounds) + self._drawable.draw(canvas) + + +# ═══════════════════════════════════════════════════════════════ +# ScaleDrawable +# ═══════════════════════════════════════════════════════════════ + +class ScaleDrawable(Drawable): + """ScaleDrawable — 缩放 Drawable""" + + def __init__(self, drawable: Drawable = None, gravity: int = 0x33, scaleWidth: float = 0.0, + scaleHeight: float = 0.0): + super().__init__() + self._drawable = drawable + self._gravity = gravity + self._scale_width = scaleWidth + self._scale_height = scaleHeight + self._level = 0 + + def getDrawable(self) -> Optional[Drawable]: + return self._drawable + + def setLevel(self, level: int) -> bool: + self._level = level + if self._drawable: + self._drawable.setLevel(level) + return True + + def draw(self, canvas: Canvas): + if self._drawable: + self._drawable.setBounds(self._bounds) + self._drawable.draw(canvas) + + +# ═══════════════════════════════════════════════════════════════ +# ClipDrawable +# ═══════════════════════════════════════════════════════════════ + +class ClipDrawable(Drawable): + """ClipDrawable — 裁剪 Drawable""" + + HORIZONTAL = 1 + VERTICAL = 2 + + def __init__(self, drawable: Drawable = None, gravity: int = 0x33, orientation: int = HORIZONTAL): + super().__init__() + self._drawable = drawable + self._gravity = gravity + self._orientation = orientation + self._level = 0 + + def setLevel(self, level: int) -> bool: + self._level = level + if self._drawable: + self._drawable.setLevel(level) + return True + + def draw(self, canvas: Canvas): + if self._drawable: + self._drawable.setBounds(self._bounds) + self._drawable.draw(canvas) + + +# ═══════════════════════════════════════════════════════════════ +# InsetDrawable +# ═══════════════════════════════════════════════════════════════ + +class InsetDrawable(Drawable): + """InsetDrawable — 内嵌 Drawable""" + + def __init__(self, drawable: Drawable, inset: float): + super().__init__() + self._drawable = drawable + self._inset = int(inset) + self._inset_left = int(inset) + self._inset_top = int(inset) + self._inset_right = int(inset) + self._inset_bottom = int(inset) + + def getDrawable(self) -> Optional[Drawable]: + return self._drawable + + def getInset(self) -> int: + return self._inset + + def draw(self, canvas: Canvas): + if self._drawable: + b = self._bounds + self._drawable.setBounds( + b.left + self._inset_left, b.top + self._inset_top, + b.right - self._inset_right, b.bottom - self._inset_bottom + ) + self._drawable.draw(canvas) + + +# ═══════════════════════════════════════════════════════════════ +# ShapeDrawable +# ═══════════════════════════════════════════════════════════════ + +class ShapeDrawable(Drawable): + """ShapeDrawable — 形状 Drawable""" + + def __init__(self, shape: "Shape" = None): + super().__init__() + self._shape = shape + self._paint = Paint() + self._intrinsic_width = -1 + self._intrinsic_height = -1 + + def getShape(self): + return self._shape + + def setShape(self, shape): + self._shape = shape + + def getPaint(self) -> Paint: + return self._paint + + def setIntrinsicWidth(self, width: int): + self._intrinsic_width = width + + def setIntrinsicHeight(self, height: int): + self._intrinsic_height = height + + def getIntrinsicWidth(self) -> int: + return self._intrinsic_width if self._intrinsic_width > 0 else super().getIntrinsicWidth() + + def getIntrinsicHeight(self) -> int: + return self._intrinsic_height if self._intrinsic_height > 0 else super().getIntrinsicHeight() + + def draw(self, canvas: Canvas): + if self._shape: + self._shape.draw(canvas, self._paint) + + +class Shape(Stub): + """Shape — 形状基类""" + def draw(self, canvas: Canvas, paint: Paint): + pass + + +class ArcShape(Shape): + """ArcShape — 弧形""" + def __init__(self, startAngle: float, sweepAngle: float): + super().__init__() + self._start_angle = startAngle + self._sweep_angle = sweepAngle + + +class OvalShape(Shape): + """OvalShape — 椭圆""" + def draw(self, canvas: Canvas, paint: Paint): + if HAS_PIL and hasattr(canvas, "_draw"): + c = paint.getColor() + fill_color = (Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)) + b = canvas.getClipBounds() + canvas._draw.ellipse([b.left, b.top, b.right, b.bottom], fill=fill_color) + + +class RectShape(Shape): + """RectShape — 矩形""" + def draw(self, canvas: Canvas, paint: Paint): + if HAS_PIL and hasattr(canvas, "_draw"): + c = paint.getColor() + fill_color = (Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)) + b = canvas.getClipBounds() + canvas._draw.rectangle([b.left, b.top, b.right, b.bottom], fill=fill_color) + + +class RoundRectShape(Shape): + """RoundRectShape — 圆角矩形""" + def __init__(self, outerRadii: List[float], inset: RectF, innerRadii: List[float]): + super().__init__() + self._outer_radii = outerRadii + self._inset = inset + self._inner_radii = innerRadii + + def draw(self, canvas: Canvas, paint: Paint): + if HAS_PIL and hasattr(canvas, "_draw"): + c = paint.getColor() + fill_color = (Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)) + b = canvas.getClipBounds() + radius = self._outer_radii[0] if self._outer_radii else 0 + canvas._draw.rounded_rectangle([b.left, b.top, b.right, b.bottom], + radius=radius, fill=fill_color) + + +class PaintDrawable(ShapeDrawable): + """PaintDrawable — 画笔 Drawable (ShapeDrawable 子类)""" + + def __init__(self, color: int = 0): + super().__init__(RectShape()) + self.getPaint().setColor(color) + + def setCornerRadius(self, radius: float): + self.setShape(RoundRectShape([radius, radius, radius, radius], None, None)) + + +# ═══════════════════════════════════════════════════════════════ +# VectorDrawable +# ═══════════════════════════════════════════════════════════════ + +class VectorDrawable(Drawable): + """VectorDrawable — 矢量 Drawable""" + + def __init__(self): + super().__init__() + self._alpha = 255 + + def setAlpha(self, alpha: int): + self._alpha = alpha + + def getAlpha(self) -> int: + return self._alpha + + def draw(self, canvas: Canvas): + pass + + @staticmethod + def createFromXml(res, parser) -> "VectorDrawable": + return VectorDrawable() + + +# ═══════════════════════════════════════════════════════════════ +# RippleDrawable +# ═══════════════════════════════════════════════════════════════ + +class RippleDrawable(Drawable): + """RippleDrawable — 水波纹 Drawable (API 21+)""" + + def __init__(self, colorStates: ColorStateList, content: Drawable = None, + mask: Drawable = None): + super().__init__() + self._color_states = colorStates + self._content = content + self._mask = mask + self._radius = -1 + + def setRadius(self, radius: int): + self._radius = radius + + def getRadius(self) -> int: + return self._radius + + def draw(self, canvas: Canvas): + if self._content: + self._content.setBounds(self._bounds) + self._content.draw(canvas) + + def setColor(self, color: ColorStateList): + self._color_states = color + + def getColor(self) -> Optional[ColorStateList]: + return self._color_states + + def mutate(self) -> "RippleDrawable": + return self + + +# ═══════════════════════════════════════════════════════════════ +# AnimatedVectorDrawable +# ═══════════════════════════════════════════════════════════════ + +class AnimatedVectorDrawable(Drawable): + """AnimatedVectorDrawable — 动画矢量 Drawable (API 21+)""" + + def __init__(self): + super().__init__() + self._running = False + + def start(self): + self._running = True + + def stop(self): + self._running = False + + def isRunning(self) -> bool: + return self._running + + def reset(self): + self._running = False + + def draw(self, canvas: Canvas): + pass + + @staticmethod + def createFromXml(res, parser) -> "AnimatedVectorDrawable": + return AnimatedVectorDrawable() + + +# ═══════════════════════════════════════════════════════════════ +# AnimationDrawable +# ═══════════════════════════════════════════════════════════════ + +class AnimationDrawable(Drawable): + """AnimationDrawable — 帧动画 Drawable""" + + def __init__(self): + super().__init__() + self._frames: List[Tuple[Drawable, int]] = [] + self._current_frame = 0 + self._oneshot = False + self._running = False + + def addFrame(self, frame: Drawable, duration: int): + self._frames.append((frame, duration)) + + def getFrame(self, index: int) -> Optional[Drawable]: + if 0 <= index < len(self._frames): + return self._frames[index][0] + return None + + def getNumberOfFrames(self) -> int: + return len(self._frames) + + def getDuration(self, index: int) -> int: + if 0 <= index < len(self._frames): + return self._frames[index][1] + return 0 + + def setOneShot(self, oneshot: bool): + self._oneshot = oneshot + + def isOneShot(self) -> bool: + return self._oneshot + + def start(self): + self._running = True + + def stop(self): + self._running = False + + def isRunning(self) -> bool: + return self._running + + def run(self): + pass + + def selectDrawable(self, index: int) -> bool: + if 0 <= index < len(self._frames): + self._current_frame = index + return True + return False + + def getCurrent(self) -> Drawable: + if self._frames: + return self._frames[self._current_frame][0] + return self + + def draw(self, canvas: Canvas): + d = self.getCurrent() + d.setBounds(self._bounds) + d.draw(canvas) + + def setVisible(self, visible: bool, restart: bool = False) -> bool: + old = super().setVisible(visible, restart) + if visible and restart: + self._current_frame = 0 + return old + + +# ═══════════════════════════════════════════════════════════════ +# DrawableContainer +# ═══════════════════════════════════════════════════════════════ + +class DrawableContainer(Drawable): + """DrawableContainer — Drawable 容器""" + + def __init__(self): + super().__init__() + self._drawables: List[Drawable] = [] + self._current_index = 0 + + def selectDrawable(self, index: int) -> bool: + if 0 <= index < len(self._drawables): + self._current_index = index + return True + return False + + def getCurrent(self) -> Drawable: + if self._drawables: + return self._drawables[self._current_index] + return self + + def draw(self, canvas: Canvas): + d = self.getCurrent() + d.setBounds(self._bounds) + d.draw(canvas) + + def setAlpha(self, alpha: int): + for d in self._drawables: + d.setAlpha(alpha) + + def setColorFilter(self, cf: Optional[ColorFilter]): + for d in self._drawables: + d.setColorFilter(cf) + + def getOpacity(self) -> int: + return 0 + + def isStateful(self) -> bool: + return any(d.isStateful() for d in self._drawables) + + def mutate(self) -> "DrawableContainer": + return self + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "Drawable", "BitmapDrawable", "ColorDrawable", "GradientDrawable", + "LayerDrawable", "StateListDrawable", "LevelListDrawable", + "TransitionDrawable", "RotateDrawable", "ScaleDrawable", + "ClipDrawable", "InsetDrawable", "ShapeDrawable", "PaintDrawable", + "VectorDrawable", "RippleDrawable", "AnimatedVectorDrawable", + "AnimationDrawable", "DrawableContainer", "DrawableConstantState", + "ColorStateList", + # Shapes + "Shape", "ArcShape", "OvalShape", "RectShape", "RoundRectShape", +] \ No newline at end of file diff --git a/android_pyapi/android/graphics_pdf.py b/android_pyapi/android/graphics_pdf.py new file mode 100644 index 0000000..ea06db5 --- /dev/null +++ b/android_pyapi/android/graphics_pdf.py @@ -0,0 +1,335 @@ +""" +Android Graphics PDF 组件 — PdfDocument, PdfRenderer, ParcelFileDescriptor +方法签名完全对齐 Android SDK +""" + +import os +import io +import tempfile +from typing import Any, Dict, List, Optional, Tuple + +from .._core import Stub, AndroidOnlyError, android_context, HAS_PIL, HAS_PYMUPDF, HAS_PDF2IMAGE, resolve_android_path + + +# ═══════════════════════════════════════════════════════════════ +# ParcelFileDescriptor +# ═══════════════════════════════════════════════════════════════ + +class ParcelFileDescriptor(Stub): + """ParcelFileDescriptor — 文件描述符""" + + MODE_READ_ONLY = 0x10000000 + MODE_WRITE_ONLY = 0x20000000 + MODE_READ_WRITE = 0x30000000 + MODE_CREATE = 0x08000000 + MODE_TRUNCATE = 0x04000000 + MODE_APPEND = 0x02000000 + + def __init__(self, fd: int = -1, file_path: str = ""): + super().__init__() + self._fd = fd + self._file_path = file_path + self._closed = False + self._file_obj = None + if file_path and fd < 0: + resolved = resolve_android_path(file_path) + self._file_path = resolved + + @staticmethod + def open(file_path: str, mode: int) -> "ParcelFileDescriptor": + resolved = resolve_android_path(file_path) + fmode = "rb" + if mode & ParcelFileDescriptor.MODE_WRITE_ONLY: + fmode = "wb" + elif mode & ParcelFileDescriptor.MODE_READ_WRITE: + fmode = "r+b" + if mode & ParcelFileDescriptor.MODE_CREATE: + if not os.path.exists(os.path.dirname(resolved)): + os.makedirs(os.path.dirname(resolved), exist_ok=True) + if not os.path.exists(resolved): + open(resolved, "w").close() + return ParcelFileDescriptor(-1, file_path) + + @staticmethod + def parseFromFd(fd: int) -> "ParcelFileDescriptor": + return ParcelFileDescriptor(fd) + + @staticmethod + def parseFromString(path: str) -> "ParcelFileDescriptor": + resolved = resolve_android_path(path) + return ParcelFileDescriptor(-1, resolved) + + @staticmethod + def adoptFd(fd: int) -> "ParcelFileDescriptor": + return ParcelFileDescriptor(fd) + + @staticmethod + def createPipe() -> List["ParcelFileDescriptor"]: + r, w = os.pipe() + return [ParcelFileDescriptor(r), ParcelFileDescriptor(w)] + + def getFileDescriptor(self) -> int: + return self._fd + + def getStatSize(self) -> int: + if self._file_path and os.path.exists(self._file_path): + return os.path.getsize(self._file_path) + return 0 + + def getFd(self) -> int: + return self._fd + + def close(self): + if not self._closed: + self._closed = True + if self._file_obj: + self._file_obj.close() + elif self._fd >= 0: + try: + os.close(self._fd) + except OSError: + pass + + def getFilePath(self) -> str: + return self._file_path + + def toString(self) -> str: + return f"ParcelFileDescriptor(fd={self._fd})" + + +# ═══════════════════════════════════════════════════════════════ +# PdfDocument +# ═══════════════════════════════════════════════════════════════ + +class PdfDocument(Stub): + """PdfDocument — PDF 文档""" + + class Page(Stub): + """PdfDocument.Page — PDF 页面""" + + def __init__(self, page_number: int, width: int, height: int): + super().__init__() + self._page_number = page_number + self._width = width + self._height = height + self._canvas = None + + def getCanvas(self) -> "Canvas": + from .graphics import Canvas + if self._canvas is None: + self._canvas = Canvas(self._width, self._height) + return self._canvas + + def getWidth(self) -> int: + return self._width + + def getHeight(self) -> int: + return self._height + + def start(self): + pass + + def finish(self): + pass + + def __init__(self): + super().__init__() + self._pages: List[PdfDocument.Page] = [] + + def startPage(self, page_size: "Page") -> "Canvas": + width = page_size.getWidth() if hasattr(page_size, "getWidth") else 595 + height = page_size.getHeight() if hasattr(page_size, "getHeight") else 842 + page = PdfDocument.Page(len(self._pages), width, height) + self._pages.append(page) + return page.getCanvas() + + def finishPage(self, page: "Page"): + page.finish() + + def getPages(self) -> List["Page"]: + return list(self._pages) + + def writeTo(self, out_stream, close: bool = True): + if HAS_PYMUPDF: + import fitz + doc = fitz.open() + for p in self._pages: + page = doc.new_page(width=p._width, height=p._height) + if HAS_PIL and hasattr(p._canvas, "_image") and p._canvas._image: + img_bytes = io.BytesIO() + p._canvas._image.save(img_bytes, format="PNG") + img_bytes.seek(0) + rect = page.rect + page.insert_image(rect, stream=img_bytes.read()) + doc.save(out_stream) + doc.close() + elif HAS_PIL: + from PIL import Image + images = [] + for p in self._pages: + if hasattr(p._canvas, "_image") and p._canvas._image: + images.append(p._canvas._image.convert("RGB")) + if images: + images[0].save(out_stream, format="PDF", save_all=True, + append_images=images[1:]) + else: + blank = Image.new("RGB", (595, 842), (255, 255, 255)) + blank.save(out_stream, format="PDF") + else: + if close: + out_stream.close() + + def close(self): + self._pages.clear() + + def __enter__(self): + return self + + def __exit__(self, *args): + self.close() + + +# ═══════════════════════════════════════════════════════════════ +# PdfRenderer +# ═══════════════════════════════════════════════════════════════ + +class PdfRenderer(Stub): + """PdfRenderer — PDF 渲染器""" + + RENDER_MODE_FOR_DISPLAY = 1 + RENDER_MODE_FOR_PRINT = 2 + RENDER_MODE_FOR_ALL = 3 + + class Page(Stub): + """PdfRenderer.Page — PDF 渲染页面""" + + def __init__(self, renderer: "PdfRenderer", index: int): + super().__init__() + self._renderer = renderer + self._index = index + self._opened = True + if renderer._doc: + self._fitz_page = renderer._doc[index] + rect = self._fitz_page.rect + self._width = int(rect.width) + self._height = int(rect.height) + else: + self._fitz_page = None + self._width = 595 + self._height = 842 + + def getWidth(self) -> int: + return self._width + + def getHeight(self) -> int: + return self._height + + def getIndex(self) -> int: + return self._index + + def render(self, canvas: "Canvas", destLeft: int, destTop: int, + destRight: int, destBottom: int, flags: int = 0): + if not self._opened: + return + if HAS_PYMUPDF and self._fitz_page: + from .graphics import Bitmap + mat = fitz.Matrix(2, 2) # 2x zoom for quality + pix = self._fitz_page.get_pixmap(matrix=mat) + img_data = pix.tobytes("png") + if HAS_PIL and hasattr(canvas, "_image") and canvas._image: + from PIL import Image + import io as _io + img = Image.open(io.BytesIO(img_data)) + img = img.resize((destRight - destLeft, destBottom - destTop)) + canvas._image.paste(img, (destLeft, destTop)) + elif HAS_PDF2IMAGE and HAS_PIL and hasattr(canvas, "_image"): + from pdf2image import convert_from_bytes + if self._renderer._pdf_bytes: + images = convert_from_bytes( + self._renderer._pdf_bytes, + first_page=self._index + 1, + last_page=self._index + 1 + ) + if images: + img = images[0].resize((destRight - destLeft, destBottom - destTop)) + canvas._image.paste(img.convert("RGBA"), (destLeft, destTop)) + + def start(self): + self._opened = True + + def finish(self): + self._opened = False + + def close(self): + self._opened = False + + def __init__(self, pfd: ParcelFileDescriptor, closePfd: bool = True): + super().__init__() + self._pfd = pfd + self._close_pfd = closePfd + self._page_count = 0 + self._pdf_bytes = None + self._doc = None + + file_path = pfd.getFilePath() + if file_path and os.path.exists(file_path): + with open(file_path, "rb") as f: + self._pdf_bytes = f.read() + elif pfd._fd >= 0: + try: + self._pdf_bytes = os.read(pfd._fd, 10 * 1024 * 1024) + except OSError: + self._pdf_bytes = None + + if HAS_PYMUPDF and self._pdf_bytes: + import fitz + self._doc = fitz.open(stream=self._pdf_bytes, filetype="pdf") + self._page_count = len(self._doc) + elif self._pdf_bytes: + self._page_count = 1 # fallback + else: + self._page_count = 0 + + def openPage(self, index: int) -> "Page": + if 0 <= index < self._page_count: + return PdfRenderer.Page(self, index) + raise IndexError(f"Page index {index} out of range (0-{self._page_count - 1})") + + def close(self): + if self._doc and HAS_PYMUPDF: + self._doc.close() + self._doc = None + if self._close_pfd and self._pfd: + self._pfd.close() + self._pdf_bytes = None + + def getPageCount(self) -> int: + return self._page_count + + def shouldScale(self) -> bool: + return False + + def __enter__(self): + return self + + def __exit__(self, *args): + self.close() + + +# ═══════════════════════════════════════════════════════════════ +# PdfDocumentPage (alias for PdfDocument.Page) +# ═══════════════════════════════════════════════════════════════ + +PdfDocumentPage = PdfDocument.Page + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "PdfDocument", + "PdfDocumentPage", + "PdfRenderer", + "ParcelFileDescriptor", +] \ No newline at end of file diff --git a/android_pyapi/android/hardware.py b/android_pyapi/android/hardware.py new file mode 100644 index 0000000..b855a1a --- /dev/null +++ b/android_pyapi/android/hardware.py @@ -0,0 +1,533 @@ +""" +Android Hardware 组件 — Sensor, SensorManager, SensorEvent, 等 +方法签名完全对齐 Android SDK +""" + +import math +import time +import random +from typing import Any, Callable, Dict, List, Optional, Tuple + +from .._core import Stub, AndroidOnlyError, android_context, HAS_PIL + + +# ═══════════════════════════════════════════════════════════════ +# Sensor +# ═══════════════════════════════════════════════════════════════ + +class Sensor(Stub): + """Sensor — 传感器""" + + TYPE_ACCELEROMETER = 1 + TYPE_MAGNETIC_FIELD = 2 + TYPE_ORIENTATION = 3 + TYPE_GYROSCOPE = 4 + TYPE_LIGHT = 5 + TYPE_PRESSURE = 6 + TYPE_PROXIMITY = 8 + TYPE_GRAVITY = 9 + TYPE_LINEAR_ACCELERATION = 10 + TYPE_ROTATION_VECTOR = 11 + TYPE_RELATIVE_HUMIDITY = 12 + TYPE_AMBIENT_TEMPERATURE = 13 + TYPE_STEP_COUNTER = 19 + TYPE_STEP_DETECTOR = 18 + TYPE_HEART_RATE = 21 + TYPE_LOW_LATENCY_OFFBODY_DETECT = 34 + TYPE_ACCELEROMETER_LIMITED_AXES = 35 + TYPE_DEVICE_ORIENTATION = 27 + TYPE_STATIONARY_DETECT = 28 + + REPORTING_MODE_CONTINUOUS = 0 + REPORTING_MODE_ON_CHANGE = 1 + REPORTING_MODE_ONE_SHOT = 2 + REPORTING_MODE_SPECIAL_TRIGGER = 3 + + def __init__(self, type_: int, name: str = "Simulated Sensor", + vendor: str = "Android-pyApi", version: int = 1, + resolution: float = 1.0, max_range: float = 100.0, + power: float = 0.5, min_delay: int = 10000): + super().__init__() + self._type = type_ + self._name = name + self._vendor = vendor + self._version = version + self._resolution = resolution + self._max_range = max_range + self._power = power + self._min_delay = min_delay + + # Assign default values based on sensor type + type_defaults = { + Sensor.TYPE_ACCELEROMETER: ("Accelerometer", 0.01, 39.24, 3.0, 10000), + Sensor.TYPE_GYROSCOPE: ("Gyroscope", 0.001, 34.91, 6.1, 10000), + Sensor.TYPE_MAGNETIC_FIELD: ("Magnetic Field", 0.01, 2000.0, 4.0, 10000), + Sensor.TYPE_LIGHT: ("Light", 1.0, 40000.0, 0.5, 10000), + Sensor.TYPE_PROXIMITY: ("Proximity", 1.0, 10.0, 0.5, 10000), + Sensor.TYPE_PRESSURE: ("Pressure", 0.01, 1100.0, 1.0, 10000), + Sensor.TYPE_GRAVITY: ("Gravity", 0.01, 39.24, 3.0, 10000), + Sensor.TYPE_LINEAR_ACCELERATION: ("Linear Acceleration", 0.01, 39.24, 3.0, 10000), + Sensor.TYPE_ROTATION_VECTOR: ("Rotation Vector", 0.0001, 1.0, 5.0, 10000), + Sensor.TYPE_RELATIVE_HUMIDITY: ("Relative Humidity", 0.1, 100.0, 0.5, 10000), + Sensor.TYPE_AMBIENT_TEMPERATURE: ("Ambient Temperature", 0.01, 80.0, 0.5, 10000), + Sensor.TYPE_STEP_COUNTER: ("Step Counter", 1.0, 100000.0, 0.1, 100000), + Sensor.TYPE_STEP_DETECTOR: ("Step Detector", 1.0, 1.0, 0.1, 100000), + Sensor.TYPE_HEART_RATE: ("Heart Rate", 1.0, 220.0, 0.5, 100000), + } + + if type_ in type_defaults: + n, res, mr, p, md = type_defaults[type_] + self._name = name if name != "Simulated Sensor" else n + self._resolution = resolution if resolution != 1.0 else res + self._max_range = max_range if max_range != 100.0 else mr + self._power = power if power != 0.5 else p + self._min_delay = min_delay if min_delay != 10000 else md + + def getType(self) -> int: + return self._type + + def getName(self) -> str: + return self._name + + def getVendor(self) -> str: + return self._vendor + + def getVersion(self) -> int: + return self._version + + def getMaximumRange(self) -> float: + return self._max_range + + def getMinDelay(self) -> int: + return self._min_delay + + def getPower(self) -> float: + return self._power + + def getResolution(self) -> float: + return self._resolution + + def getFifoMaxEventCount(self) -> int: + return 0 + + def getFifoReservedEventCount(self) -> int: + return 0 + + def getReportingMode(self) -> int: + return Sensor.REPORTING_MODE_CONTINUOUS + + def isWakeUpSensor(self) -> bool: + return False + + def getStringType(self) -> str: + type_names = { + Sensor.TYPE_ACCELEROMETER: "android.sensor.accelerometer", + Sensor.TYPE_MAGNETIC_FIELD: "android.sensor.magnetic_field", + Sensor.TYPE_GYROSCOPE: "android.sensor.gyroscope", + Sensor.TYPE_LIGHT: "android.sensor.light", + Sensor.TYPE_PRESSURE: "android.sensor.pressure", + Sensor.TYPE_PROXIMITY: "android.sensor.proximity", + Sensor.TYPE_GRAVITY: "android.sensor.gravity", + Sensor.TYPE_LINEAR_ACCELERATION: "android.sensor.linear_acceleration", + Sensor.TYPE_ROTATION_VECTOR: "android.sensor.rotation_vector", + Sensor.TYPE_RELATIVE_HUMIDITY: "android.sensor.relative_humidity", + Sensor.TYPE_AMBIENT_TEMPERATURE: "android.sensor.ambient_temperature", + Sensor.TYPE_STEP_COUNTER: "android.sensor.step_counter", + Sensor.TYPE_STEP_DETECTOR: "android.sensor.step_detector", + Sensor.TYPE_HEART_RATE: "android.sensor.heart_rate", + } + return type_names.get(self._type, "android.sensor.unknown") + + def toString(self) -> str: + return f"{self._name} (type={self._type}, vendor={self._vendor}, ver={self._version})" + + +# ═══════════════════════════════════════════════════════════════ +# SensorEvent +# ═══════════════════════════════════════════════════════════════ + +class SensorEvent(Stub): + """SensorEvent — 传感器事件""" + + def __init__(self, sensor: Sensor, accuracy: int = 3): + super().__init__() + self.sensor = sensor + self.accuracy = accuracy + self.timestamp = int(time.time() * 1_000_000_000) # nanoseconds + self.values: List[float] = [] + + # Generate appropriate values based on sensor type + if sensor.getType() == Sensor.TYPE_ACCELEROMETER: + self.values = [random.uniform(-1, 1), random.uniform(-1, 1), + 9.8 + random.uniform(-0.5, 0.5)] + elif sensor.getType() == Sensor.TYPE_GYROSCOPE: + self.values = [random.uniform(-0.1, 0.1)] * 3 + elif sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD: + self.values = [random.uniform(-50, 50)] * 3 + elif sensor.getType() == Sensor.TYPE_LIGHT: + self.values = [random.uniform(100, 1000)] + elif sensor.getType() == Sensor.TYPE_PROXIMITY: + self.values = [5.0 if random.random() > 0.5 else 0.0] + elif sensor.getType() == Sensor.TYPE_PRESSURE: + self.values = [random.uniform(980, 1050)] + elif sensor.getType() in (Sensor.TYPE_GRAVITY, Sensor.TYPE_LINEAR_ACCELERATION): + self.values = [random.uniform(-1, 1)] * 3 + elif sensor.getType() == Sensor.TYPE_ROTATION_VECTOR: + self.values = [random.uniform(-1, 1)] * 5 + elif sensor.getType() == Sensor.TYPE_RELATIVE_HUMIDITY: + self.values = [random.uniform(30, 70)] + elif sensor.getType() == Sensor.TYPE_AMBIENT_TEMPERATURE: + self.values = [random.uniform(15, 35)] + elif sensor.getType() == Sensor.TYPE_STEP_COUNTER: + self.values = [float(random.randint(0, 10000))] + elif sensor.getType() == Sensor.TYPE_STEP_DETECTOR: + self.values = [1.0 if random.random() > 0.95 else 0.0] + elif sensor.getType() == Sensor.TYPE_HEART_RATE: + self.values = [random.uniform(60, 100)] + else: + self.values = [0.0] + + +# ═══════════════════════════════════════════════════════════════ +# SensorEventListener +# ═══════════════════════════════════════════════════════════════ + +class SensorEventListener(Stub): + """SensorEventListener — 传感器事件监听器""" + + def onSensorChanged(self, event: SensorEvent): + pass + + def onAccuracyChanged(self, sensor: Sensor, accuracy: int): + pass + + +# ═══════════════════════════════════════════════════════════════ +# SensorDelay +# ═══════════════════════════════════════════════════════════════ + +class SensorDelay(Stub): + """SensorDelay — 传感器采样延迟常量""" + FASTEST = 0 + GAME = 1 + UI = 2 + NORMAL = 3 + + +# ═══════════════════════════════════════════════════════════════ +# SensorManager +# ═══════════════════════════════════════════════════════════════ + +class SensorManager(Stub): + """SensorManager — 传感器管理器""" + + SENSOR_DELAY_FASTEST = 0 + SENSOR_DELAY_GAME = 1 + SENSOR_DELAY_UI = 2 + SENSOR_DELAY_NORMAL = 3 + + AXIS_X = 1 + AXIS_Y = 2 + AXIS_Z = 3 + AXIS_MINUS_X = 129 + AXIS_MINUS_Y = 130 + AXIS_MINUS_Z = 131 + + def __init__(self): + super().__init__() + self._sensors: Dict[int, Sensor] = {} + self._listeners: Dict[int, List[Tuple[SensorEventListener, Sensor, int]]] = {} + + # Create default sensors + for type_ in [ + Sensor.TYPE_ACCELEROMETER, Sensor.TYPE_GYROSCOPE, + Sensor.TYPE_MAGNETIC_FIELD, Sensor.TYPE_LIGHT, + Sensor.TYPE_PROXIMITY, Sensor.TYPE_PRESSURE, + Sensor.TYPE_GRAVITY, Sensor.TYPE_LINEAR_ACCELERATION, + Sensor.TYPE_ROTATION_VECTOR, Sensor.TYPE_RELATIVE_HUMIDITY, + Sensor.TYPE_AMBIENT_TEMPERATURE, Sensor.TYPE_STEP_COUNTER, + Sensor.TYPE_STEP_DETECTOR, Sensor.TYPE_HEART_RATE, + ]: + self._sensors[type_] = Sensor(type_) + + def getDefaultSensor(self, type_: int) -> Optional[Sensor]: + return self._sensors.get(type_) + + def getSensorList(self, type_: int) -> List[Sensor]: + if type_ == -1: # ALL + return list(self._sensors.values()) + sensor = self._sensors.get(type_) + return [sensor] if sensor else [] + + def getSensors(self) -> List[Sensor]: + return list(self._sensors.values()) + + def registerListener(self, listener: SensorEventListener, sensor: Sensor, + samplingPeriodUs: int, maxReportLatencyUs: int = 0) -> bool: + if sensor.getType() not in self._sensors: + return False + if listener not in self._listeners: + self._listeners[id(listener)] = [] + self._listeners[id(listener)].append((listener, sensor, samplingPeriodUs)) + return True + + def unregisterListener(self, listener: SensorEventListener, sensor: Sensor = None) -> bool: + lid = id(listener) + if lid in self._listeners: + if sensor: + self._listeners[lid] = [ + (l, s, d) for l, s, d in self._listeners[lid] + if s.getType() != sensor.getType() + ] + if not self._listeners[lid]: + del self._listeners[lid] + else: + del self._listeners[lid] + return True + return False + + @staticmethod + def getOrientation(R: List[float], values: List[float]) -> List[float]: + if len(R) >= 9 and len(values) >= 3: + values[0] = math.degrees(math.atan2(R[1], R[4])) # azimuth + values[1] = math.degrees(math.asin(-R[7])) # pitch + values[2] = math.degrees(math.atan2(-R[6], R[8])) # roll + return values + + @staticmethod + def getRotationMatrix(R: List[float], I: List[float], + gravity: List[float], geomagnetic: List[float]) -> bool: + if len(R) < 9: + R.extend([0] * (9 - len(R))) + if len(R) >= 9: + R[0] = 1.0 + R[1] = 0.0 + R[2] = 0.0 + R[3] = 0.0 + R[4] = 1.0 + R[5] = 0.0 + R[6] = 0.0 + R[7] = 0.0 + R[8] = 1.0 + return True + + @staticmethod + def getAltitude(p0: float, p: float) -> float: + return 44330.0 * (1.0 - math.pow(p / p0, 1.0 / 5.255)) + + @staticmethod + def getInclination(I: List[float]) -> float: + return 0.0 + + @staticmethod + def remapCoordinateSystem(inR: List[float], X: int, Y: int, + outR: List[float]) -> bool: + if len(inR) >= 9 and len(outR) >= 9: + for i in range(9): + outR[i] = inR[i] + return True + + def getDeviceId(self) -> str: + return "sensor_hub_0" + + +# ═══════════════════════════════════════════════════════════════ +# HardwareBuffer +# ═══════════════════════════════════════════════════════════════ + +class HardwareBuffer(Stub): + """HardwareBuffer — 硬件缓冲 (API 26+)""" + + USAGE_CPU_READ_OFTEN = 0x00000003 + USAGE_CPU_WRITE_OFTEN = 0x00000030 + USAGE_GPU_SAMPLED_IMAGE = 0x00000100 + USAGE_GPU_COLOR_OUTPUT = 0x00000200 + USAGE_GPU_DATA_BUFFER = 0x00001000 + USAGE_SENSOR_DIRECT_DATA = 0x00400000 + USAGE_PROTECTED_CONTENT = 0x00004000 + USAGE_VIDEO_ENCODE = 0x00010000 + USAGE_GPU_FRAMEBUFFER = 0x00020000 + USAGE_COMPOSER_OVERLAY = 0x00000800 + USAGE_FRONT_BUFFER_QUEUE = 0x00008000 + + BLOB = 0x21 + RGBA_8888 = 1 + RGBA_FP16 = 22 + RGBA_1010102 = 43 + RGBX_8888 = 2 + RGB_888 = 3 + RGB_565 = 4 + YCBCR_420_888 = 35 + + def __init__(self, width: int, height: int, format: int, layers: int, + usage: int, buffer_size: int = 0): + super().__init__() + self._width = width + self._height = height + self._format = format + self._layers = layers + self._usage = usage + self._buffer_size = buffer_size + self._closed = False + + @property + def width(self) -> int: + return self._width + + @property + def height(self) -> int: + return self._height + + @property + def format(self) -> int: + return self._format + + @property + def layers(self) -> int: + return self._layers + + @property + def usage(self) -> int: + return self._usage + + def destroy(self): + self.close() + + def close(self): + self._closed = True + + def isClosed(self) -> bool: + return self._closed + + def isEmpty(self) -> bool: + return self._width == 0 or self._height == 0 + + def getWidth(self) -> int: + return self._width + + def getHeight(self) -> int: + return self._height + + def getFormat(self) -> int: + return self._format + + def getLayers(self) -> int: + return self._layers + + def getUsage(self) -> int: + return self._usage + + def getStride(self) -> int: + return self._width + + +# ═══════════════════════════════════════════════════════════════ +# BatteryManager (Constants) +# ═══════════════════════════════════════════════════════════════ + +class BatteryManager(Stub): + """BatteryManager — 电池管理器常量 (实际实现在 android.os)""" + + BATTERY_PROPERTY_CHARGE_COUNTER = 1 + BATTERY_PROPERTY_CURRENT_NOW = 2 + BATTERY_PROPERTY_CURRENT_AVERAGE = 3 + BATTERY_PROPERTY_CAPACITY = 4 + BATTERY_PROPERTY_STATUS = 5 + BATTERY_PROPERTY_ENERGY_COUNTER = 6 + + BATTERY_STATUS_UNKNOWN = 1 + BATTERY_STATUS_CHARGING = 2 + BATTERY_STATUS_DISCHARGING = 3 + BATTERY_STATUS_NOT_CHARGING = 4 + BATTERY_STATUS_FULL = 5 + + BATTERY_HEALTH_UNKNOWN = 1 + BATTERY_HEALTH_GOOD = 2 + BATTERY_HEALTH_OVERHEAT = 3 + BATTERY_HEALTH_DEAD = 4 + BATTERY_HEALTH_OVER_VOLTAGE = 5 + BATTERY_HEALTH_UNSPECIFIED_FAILURE = 6 + BATTERY_HEALTH_COLD = 7 + + BATTERY_PLUGGED_AC = 1 + BATTERY_PLUGGED_USB = 2 + BATTERY_PLUGGED_WIRELESS = 4 + + ACTION_CHARGING = "android.intent.action.ACTION_CHARGING" + ACTION_DISCHARGING = "android.intent.action.ACTION_DISCHARGING" + EXTRA_STATUS = "status" + EXTRA_HEALTH = "health" + EXTRA_LEVEL = "level" + EXTRA_SCALE = "scale" + EXTRA_PLUGGED = "plugged" + EXTRA_TEMPERATURE = "temperature" + EXTRA_VOLTAGE = "voltage" + EXTRA_TECHNOLOGY = "technology" + EXTRA_CHARGE_COUNTER = "charge_counter" + EXTRA_PRESENT = "present" + + def __init__(self): + super().__init__() + + def getIntProperty(self, id: int) -> int: + id_values = { + BatteryManager.BATTERY_PROPERTY_CHARGE_COUNTER: 3500, + BatteryManager.BATTERY_PROPERTY_CAPACITY: 85, + BatteryManager.BATTERY_PROPERTY_STATUS: BatteryManager.BATTERY_STATUS_DISCHARGING, + } + return id_values.get(id, 0) + + def getLongProperty(self, id: int) -> int: + return 0 + + +# ═══════════════════════════════════════════════════════════════ +# BiometricManager (lightweight) +# ═══════════════════════════════════════════════════════════════ + +class BiometricManager(Stub): + """BiometricManager — 生物识别管理器 (轻量)""" + + BIOMETRIC_SUCCESS = 0 + BIOMETRIC_ERROR_HW_UNAVAILABLE = 1 + BIOMETRIC_ERROR_NONE_ENROLLED = 11 + BIOMETRIC_ERROR_NO_HARDWARE = 12 + BIOMETRIC_ERROR_SECURITY_UPDATE_REQUIRED = 15 + + def __init__(self): + super().__init__() + + def canAuthenticate(self) -> int: + return BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE + + +# ═══════════════════════════════════════════════════════════════ +# Flashlight support +# ═══════════════════════════════════════════════════════════════ + +class CameraFlashlight(Stub): + """CameraFlashlight — 手电筒支持""" + + def __init__(self): + super().__init__() + self._on = False + + def setTorchMode(self, cameraId: str, enabled: bool): + self._on = enabled + + def isTorchModeEnabled(self, cameraId: str) -> bool: + return self._on + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "Sensor", "SensorManager", "SensorEvent", "SensorEventListener", + "SensorDelay", + "HardwareBuffer", + "BatteryManager", + "BiometricManager", + "CameraFlashlight", +] \ No newline at end of file diff --git a/android_pyapi/android/hardware_biometrics.py b/android_pyapi/android/hardware_biometrics.py new file mode 100644 index 0000000..8567b80 --- /dev/null +++ b/android_pyapi/android/hardware_biometrics.py @@ -0,0 +1,291 @@ +""" +Android Biometrics 组件 — BiometricManager, BiometricPrompt, 等 +方法签名完全对齐 Android SDK +""" + +from typing import Any, Callable, Dict, List, Optional, Tuple + +from .._core import Stub, AndroidOnlyError, android_context + + +# ═══════════════════════════════════════════════════════════════ +# BiometricConstants +# ═══════════════════════════════════════════════════════════════ + +class BiometricConstants(Stub): + """BiometricConstants — 生物识别常量""" + + BIOMETRIC_SUCCESS = 0 + BIOMETRIC_ERROR_HW_UNAVAILABLE = 1 + BIOMETRIC_ERROR_VENDOR = 8 + BIOMETRIC_ERROR_LOCKOUT = 7 + BIOMETRIC_ERROR_LOCKOUT_PERMANENT = 9 + BIOMETRIC_ERROR_USER_CANCELED = 10 + BIOMETRIC_ERROR_NO_BIOMETRIC = 11 + BIOMETRIC_ERROR_HW_NOT_PRESENT = 12 + BIOMETRIC_ERROR_NEGATIVE_BUTTON = 13 + BIOMETRIC_ERROR_NO_DEVICE_CREDENTIAL = 14 + BIOMETRIC_ERROR_SECURITY_UPDATE_REQUIRED = 15 + BIOMETRIC_ERROR_UNSUPPORTED = 65536 + BIOMETRIC_ERROR_CANCELED = 5 + BIOMETRIC_ERROR_TIMEOUT = 3 + BIOMETRIC_ERROR_NONE_ENROLLED = 11 + BIOMETRIC_ERROR_NO_HARDWARE = 12 + BIOMETRIC_STATUS_OK = 0 + + # Authenticator types + BIOMETRIC_STRONG = 0x0F + BIOMETRIC_WEAK = 0xFF + DEVICE_CREDENTIAL = 0x8000 + + +# ═══════════════════════════════════════════════════════════════ +# BiometricPrompt +# ═══════════════════════════════════════════════════════════════ + +class BiometricPrompt(Stub): + """BiometricPrompt — 生物识别提示 (API 28+)""" + + class AuthenticationCallback(Stub): + """BiometricPrompt.AuthenticationCallback — 认证回调""" + + def onAuthenticationError(self, errorCode: int, errString: str): + pass + + def onAuthenticationSucceeded(self, result: "BiometricPrompt.AuthenticationResult"): + pass + + def onAuthenticationFailed(self): + pass + + def onAuthenticationAcquired(self, acquireInfo: int): + pass + + class AuthenticationResult(Stub): + """BiometricPrompt.AuthenticationResult — 认证结果""" + + def __init__(self, cryptoObject: "BiometricPromptCryptoObject" = None, + authenticationType: int = BiometricConstants.BIOMETRIC_STRONG): + super().__init__() + self._crypto_object = cryptoObject + self._authentication_type = authenticationType + + def getCryptoObject(self) -> Optional["BiometricPromptCryptoObject"]: + return self._crypto_object + + def getAuthenticationType(self) -> int: + return self._authentication_type + + class PromptInfo(Stub): + """BiometricPrompt.PromptInfo — 提示信息""" + + class Builder(Stub): + """BiometricPrompt.PromptInfo.Builder — 提示信息构建器""" + + def __init__(self): + super().__init__() + self._title = "" + self._subtitle = "" + self._description = "" + self._device_credential_allowed = False + self._allowed_authenticators = 0 + self._confirmation_required = True + self._negative_button_text = "" + + def setTitle(self, title: str) -> "BiometricPrompt.PromptInfo.Builder": + self._title = title + return self + + def setSubtitle(self, subtitle: str) -> "BiometricPrompt.PromptInfo.Builder": + self._subtitle = subtitle + return self + + def setDescription(self, description: str) -> "BiometricPrompt.PromptInfo.Builder": + self._description = description + return self + + def setDeviceCredentialAllowed(self, allowed: bool) -> "BiometricPrompt.PromptInfo.Builder": + self._device_credential_allowed = allowed + return self + + def setAllowedAuthenticators(self, authenticators: int) -> "BiometricPrompt.PromptInfo.Builder": + self._allowed_authenticators = authenticators + return self + + def setConfirmationRequired(self, required: bool) -> "BiometricPrompt.PromptInfo.Builder": + self._confirmation_required = required + return self + + def setNegativeButtonText(self, text: str) -> "BiometricPrompt.PromptInfo.Builder": + self._negative_button_text = text + return self + + def build(self) -> "BiometricPrompt.PromptInfo": + info = BiometricPrompt.PromptInfo() + info._title = self._title + info._subtitle = self._subtitle + info._description = self._description + info._device_credential_allowed = self._device_credential_allowed + info._allowed_authenticators = self._allowed_authenticators + info._confirmation_required = self._confirmation_required + info._negative_button_text = self._negative_button_text + return info + + def __init__(self): + super().__init__() + self._title = "" + self._subtitle = "" + self._description = "" + self._device_credential_allowed = False + self._allowed_authenticators = 0 + self._confirmation_required = True + self._negative_button_text = "" + + def getTitle(self) -> str: + return self._title + + def getSubtitle(self) -> str: + return self._subtitle + + def getDescription(self) -> str: + return self._description + + def isDeviceCredentialAllowed(self) -> bool: + return self._device_credential_allowed + + def getAllowedAuthenticators(self) -> int: + return self._allowed_authenticators + + def isConfirmationRequired(self) -> bool: + return self._confirmation_required + + def getNegativeButtonText(self) -> str: + return self._negative_button_text + + def __init__(self, context, callback: AuthenticationCallback = None, + handler=None): + super().__init__() + self._context = context + self._callback = callback + self._cancelled = False + + def authenticate(self, crypto: "BiometricPromptCryptoObject" = None, + cancel: Any = None, executor=None, + callback: AuthenticationCallback = None): + self._cancelled = False + if callback: + self._callback = callback + if self._callback: + # Simulate failed authentication on desktop + self._callback.onAuthenticationError( + BiometricConstants.BIOMETRIC_ERROR_NO_HARDWARE, + "No biometric hardware available on this device" + ) + + def authenticate(self, promptInfo: PromptInfo, crypto: "BiometricPromptCryptoObject" = None): + self._cancelled = False + if self._callback: + self._callback.onAuthenticationError( + BiometricConstants.BIOMETRIC_ERROR_NO_HARDWARE, + "No biometric hardware available on this device" + ) + + def cancelAuthentication(self): + self._cancelled = True + if self._callback: + self._callback.onAuthenticationError( + BiometricConstants.BIOMETRIC_ERROR_CANCELED, + "Authentication cancelled" + ) + + def cancel(self): + self.cancelAuthentication() + + def isCancelled(self) -> bool: + return self._cancelled + + +# ═══════════════════════════════════════════════════════════════ +# BiometricPromptCryptoObject +# ═══════════════════════════════════════════════════════════════ + +class BiometricPromptCryptoObject(Stub): + """BiometricPromptCryptoObject — 加密对象""" + + def __init__(self, signature=None, cipher=None, mac=None): + super().__init__() + self._signature = signature + self._cipher = cipher + self._mac = mac + + def getSignature(self): + return self._signature + + def getCipher(self): + return self._cipher + + def getMac(self): + return self._mac + + +# ═══════════════════════════════════════════════════════════════ +# BiometricPromptAuthenticationResult +# ═══════════════════════════════════════════════════════════════ + +BiometricPromptAuthenticationResult = BiometricPrompt.AuthenticationResult + + +# ═══════════════════════════════════════════════════════════════ +# BiometricManager +# ═══════════════════════════════════════════════════════════════ + +class BiometricManager(Stub): + """BiometricManager — 生物识别管理器 (API 29+)""" + + BIOMETRIC_SUCCESS = BiometricConstants.BIOMETRIC_SUCCESS + BIOMETRIC_ERROR_HW_UNAVAILABLE = BiometricConstants.BIOMETRIC_ERROR_HW_UNAVAILABLE + BIOMETRIC_ERROR_NONE_ENROLLED = BiometricConstants.BIOMETRIC_ERROR_NONE_ENROLLED + BIOMETRIC_ERROR_NO_HARDWARE = BiometricConstants.BIOMETRIC_ERROR_NO_HARDWARE + BIOMETRIC_ERROR_SECURITY_UPDATE_REQUIRED = BiometricConstants.BIOMETRIC_ERROR_SECURITY_UPDATE_REQUIRED + BIOMETRIC_ERROR_UNSUPPORTED = BiometricConstants.BIOMETRIC_ERROR_UNSUPPORTED + BIOMETRIC_STATUS_OK = BiometricConstants.BIOMETRIC_STATUS_OK + BIOMETRIC_ERROR_VENDOR = BiometricConstants.BIOMETRIC_ERROR_VENDOR + BIOMETRIC_ERROR_USER_CANCELED = BiometricConstants.BIOMETRIC_ERROR_USER_CANCELED + BIOMETRIC_ERROR_CANCELED = BiometricConstants.BIOMETRIC_ERROR_CANCELED + BIOMETRIC_ERROR_TIMEOUT = BiometricConstants.BIOMETRIC_ERROR_TIMEOUT + BIOMETRIC_ERROR_LOCKOUT = BiometricConstants.BIOMETRIC_ERROR_LOCKOUT + BIOMETRIC_ERROR_LOCKOUT_PERMANENT = BiometricConstants.BIOMETRIC_ERROR_LOCKOUT_PERMANENT + + # Authenticators + AUTHENTICATOR_BIOMETRIC_STRONG = BiometricConstants.BIOMETRIC_STRONG + AUTHENTICATOR_BIOMETRIC_WEAK = BiometricConstants.BIOMETRIC_WEAK + AUTHENTICATOR_DEVICE_CREDENTIAL = BiometricConstants.DEVICE_CREDENTIAL + + def __init__(self, context=None): + super().__init__() + self._context = context + + def canAuthenticate(self, authenticators: int = AUTHENTICATOR_BIOMETRIC_STRONG) -> int: + """Check if biometric authentication is available""" + return BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE + + @staticmethod + def fromContext(context) -> "BiometricManager": + """Get BiometricManager from context""" + return BiometricManager(context) + + def toString(self) -> str: + return "BiometricManager(desktop - no hardware)" + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "BiometricManager", + "BiometricPrompt", + "BiometricPromptAuthenticationResult", + "BiometricPromptCryptoObject", + "BiometricConstants", +] \ No newline at end of file diff --git a/android_pyapi/android/hardware_camera2.py b/android_pyapi/android/hardware_camera2.py new file mode 100644 index 0000000..4025211 --- /dev/null +++ b/android_pyapi/android/hardware_camera2.py @@ -0,0 +1,761 @@ +""" +Android Camera2 组件 — CameraManager, CameraDevice, CaptureRequest 等 +方法签名完全对齐 Android SDK +""" + +import time +from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union + +from .._core import Stub, AndroidOnlyError, android_context, HAS_PIL + + +# ═══════════════════════════════════════════════════════════════ +# CameraMetadata +# ═══════════════════════════════════════════════════════════════ + +class CameraMetadata(Stub): + """CameraMetadata — 相机元数据基类""" + + # CONTROL_AE modes + CONTROL_AE_MODE_OFF = 0 + CONTROL_AE_MODE_ON = 1 + CONTROL_AE_MODE_ON_AUTO_FLASH = 2 + CONTROL_AE_MODE_ON_ALWAYS_FLASH = 3 + CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE = 4 + CONTROL_AE_MODE_EXTERNAL_FLASH = 5 + + # CONTROL_AF modes + CONTROL_AF_MODE_OFF = 0 + CONTROL_AF_MODE_AUTO = 1 + CONTROL_AF_MODE_MACRO = 2 + CONTROL_AF_MODE_CONTINUOUS_VIDEO = 3 + CONTROL_AF_MODE_CONTINUOUS_PICTURE = 4 + CONTROL_AF_MODE_EDOF = 5 + + # CONTROL_AWB modes + CONTROL_AWB_MODE_OFF = 0 + CONTROL_AWB_MODE_AUTO = 1 + CONTROL_AWB_MODE_INCANDESCENT = 2 + CONTROL_AWB_MODE_FLUORESCENT = 3 + CONTROL_AWB_MODE_WARM_FLUORESCENT = 4 + CONTROL_AWB_MODE_DAYLIGHT = 5 + CONTROL_AWB_MODE_CLOUDY_DAYLIGHT = 6 + CONTROL_AWB_MODE_TWILIGHT = 7 + CONTROL_AWB_MODE_SHADE = 8 + + # CONTROL modes + CONTROL_MODE_OFF = 0 + CONTROL_MODE_AUTO = 1 + CONTROL_MODE_USE_SCENE_MODE = 2 + CONTROL_MODE_OFF_KEEP_STATE = 3 + + # FLASH modes + FLASH_MODE_OFF = 0 + FLASH_MODE_SINGLE = 1 + FLASH_MODE_TORCH = 2 + + # STATISTICS_FACE_DETECT modes + STATISTICS_FACE_DETECT_MODE_OFF = 0 + STATISTICS_FACE_DETECT_MODE_SIMPLE = 1 + STATISTICS_FACE_DETECT_MODE_FULL = 2 + + # EDGE modes + EDGE_MODE_OFF = 0 + EDGE_MODE_FAST = 1 + EDGE_MODE_HIGH_QUALITY = 2 + EDGE_MODE_ZERO_SHUTTER_LAG = 3 + + # NOISE_REDUCTION modes + NOISE_REDUCTION_MODE_OFF = 0 + NOISE_REDUCTION_MODE_FAST = 1 + NOISE_REDUCTION_MODE_HIGH_QUALITY = 2 + NOISE_REDUCTION_MODE_MINIMAL = 3 + NOISE_REDUCTION_MODE_ZERO_SHUTTER_LAG = 4 + + # TONEMAP modes + TONEMAP_MODE_CONTRAST_CURVE = 0 + TONEMAP_MODE_FAST = 1 + TONEMAP_MODE_HIGH_QUALITY = 2 + TONEMAP_MODE_GAMMA_VALUE = 3 + TONEMAP_MODE_PRESET_CURVE = 4 + + # COLOR_CORRECTION modes + COLOR_CORRECTION_MODE_TRANSFORM_MATRIX = 0 + COLOR_CORRECTION_MODE_FAST = 1 + COLOR_CORRECTION_MODE_HIGH_QUALITY = 2 + + # COLOR_CORRECTION_ABERRATION modes + COLOR_CORRECTION_ABERRATION_MODE_OFF = 0 + COLOR_CORRECTION_ABERRATION_MODE_FAST = 1 + COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY = 2 + + # CONTROL_AE_PRECAPTURE_TRIGGER + CONTROL_AE_PRECAPTURE_TRIGGER_IDLE = 0 + CONTROL_AE_PRECAPTURE_TRIGGER_START = 1 + CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL = 2 + + # CONTROL_EFFECT modes + CONTROL_EFFECT_MODE_OFF = 0 + CONTROL_EFFECT_MODE_MONO = 1 + CONTROL_EFFECT_MODE_NEGATIVE = 2 + CONTROL_EFFECT_MODE_SOLARIZE = 3 + CONTROL_EFFECT_MODE_SEPIA = 4 + CONTROL_EFFECT_MODE_POSTERIZE = 5 + CONTROL_EFFECT_MODE_WHITEBOARD = 6 + CONTROL_EFFECT_MODE_BLACKBOARD = 7 + CONTROL_EFFECT_MODE_AQUA = 8 + + # CONTROL_SCENE modes + CONTROL_SCENE_MODE_DISABLED = 0 + CONTROL_SCENE_MODE_FACE_PRIORITY = 1 + CONTROL_SCENE_MODE_ACTION = 2 + CONTROL_SCENE_MODE_PORTRAIT = 3 + CONTROL_SCENE_MODE_LANDSCAPE = 4 + CONTROL_SCENE_MODE_NIGHT = 5 + CONTROL_SCENE_MODE_NIGHT_PORTRAIT = 6 + CONTROL_SCENE_MODE_THEATRE = 7 + CONTROL_SCENE_MODE_BEACH = 8 + CONTROL_SCENE_MODE_SNOW = 9 + CONTROL_SCENE_MODE_SUNSET = 10 + CONTROL_SCENE_MODE_STEADYPHOTO = 11 + CONTROL_SCENE_MODE_FIREWORKS = 12 + CONTROL_SCENE_MODE_SPORTS = 13 + CONTROL_SCENE_MODE_PARTY = 14 + CONTROL_SCENE_MODE_CANDLELIGHT = 15 + CONTROL_SCENE_MODE_BARCODE = 16 + CONTROL_SCENE_MODE_HIGH_SPEED_VIDEO = 17 + CONTROL_SCENE_MODE_HDR = 18 + + # CONTROL_VIDEO_STABILIZATION modes + CONTROL_VIDEO_STABILIZATION_MODE_OFF = 0 + CONTROL_VIDEO_STABILIZATION_MODE_ON = 1 + + # DISTORTION_CORRECTION modes + DISTORTION_CORRECTION_MODE_OFF = 0 + DISTORTION_CORRECTION_MODE_FAST = 1 + DISTORTION_CORRECTION_MODE_HIGH_QUALITY = 2 + + # HOT_PIXEL modes + HOT_PIXEL_MODE_OFF = 0 + HOT_PIXEL_MODE_FAST = 1 + HOT_PIXEL_MODE_HIGH_QUALITY = 2 + + # LENS_OPTICAL_STABILIZATION modes + LENS_OPTICAL_STABILIZATION_MODE_OFF = 0 + LENS_OPTICAL_STABILIZATION_MODE_ON = 1 + + # LENS_FACING + LENS_FACING_FRONT = 0 + LENS_FACING_BACK = 1 + LENS_FACING_EXTERNAL = 2 + + # INFO_SUPPORTED_HARDWARE_LEVEL + INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED = 0 + INFO_SUPPORTED_HARDWARE_LEVEL_FULL = 1 + INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY = 2 + INFO_SUPPORTED_HARDWARE_LEVEL_3 = 3 + INFO_SUPPORTED_HARDWARE_LEVEL_EXTERNAL = 4 + + +# ═══════════════════════════════════════════════════════════════ +# CameraCharacteristics +# ═══════════════════════════════════════════════════════════════ + +class CameraCharacteristics(CameraMetadata): + """CameraCharacteristics — 相机特性""" + + LENS_FACING = "android.lens.facing" + SENSOR_ORIENTATION = "android.sensor.orientation" + FLASH_INFO_AVAILABLE = "android.flash.info.available" + INFO_SUPPORTED_HARDWARE_LEVEL = "android.info.supportedHardwareLevel" + SCALER_STREAM_CONFIGURATION_MAP = "android.scaler.streamConfigurationMap" + CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES = "android.control.aeAvailableTargetFpsRanges" + CONTROL_AE_AVAILABLE_MODES = "android.control.aeAvailableModes" + CONTROL_AF_AVAILABLE_MODES = "android.control.afAvailableModes" + CONTROL_AVAILABLE_EFFECTS = "android.control.availableEffects" + CONTROL_AVAILABLE_SCENE_MODES = "android.control.availableSceneModes" + CONTROL_MAX_REGIONS_AE = "android.control.maxRegionsAe" + CONTROL_MAX_REGIONS_AF = "android.control.maxRegionsAf" + CONTROL_MAX_REGIONS_AWB = "android.control.maxRegionsAwb" + JPEG_AVAILABLE_THUMBNAIL_SIZES = "android.jpeg.availableThumbnailSizes" + JPEG_MAX_SIZE = "android.jpeg.maxSize" + SENSOR_INFO_PIXEL_ARRAY_SIZE = "android.sensor.info.pixelArraySize" + SENSOR_INFO_ACTIVE_ARRAY_SIZE = "android.sensor.info.activeArraySize" + FLASH_MODE = "android.flash.mode" + + def __init__(self, camera_id: str = "0"): + super().__init__() + self._properties: Dict[str, Any] = { + CameraCharacteristics.LENS_FACING: CameraCharacteristics.LENS_FACING_BACK, + CameraCharacteristics.SENSOR_ORIENTATION: 90, + CameraCharacteristics.FLASH_INFO_AVAILABLE: True, + CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL: + CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_FULL, + CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP: { + "output_sizes": [(1920, 1080), (1280, 720), (640, 480)], + "input_sizes": [(1920, 1080)], + }, + CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES: [(15, 30), (30, 30)], + CameraCharacteristics.CONTROL_AE_AVAILABLE_MODES: [0, 1, 2, 3, 4], + CameraCharacteristics.CONTROL_AF_AVAILABLE_MODES: [0, 1, 2, 3, 4, 5], + CameraCharacteristics.CONTROL_AVAILABLE_EFFECTS: list(range(9)), + CameraCharacteristics.CONTROL_AVAILABLE_SCENE_MODES: list(range(19)), + CameraCharacteristics.CONTROL_MAX_REGIONS_AE: 1, + CameraCharacteristics.CONTROL_MAX_REGIONS_AF: 1, + CameraCharacteristics.CONTROL_MAX_REGIONS_AWB: 0, + CameraCharacteristics.JPEG_AVAILABLE_THUMBNAIL_SIZES: [(320, 240), (160, 120)], + CameraCharacteristics.JPEG_MAX_SIZE: 5000000, + CameraCharacteristics.SENSOR_INFO_PIXEL_ARRAY_SIZE: (4032, 3024), + CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE: (4032, 3024), + } + + def get(self, key: str) -> Any: + return self._properties.get(key) + + def keys(self) -> Set[str]: + return set(self._properties.keys()) + + def query(self, key: str) -> Any: + return self._properties.get(key) + + +# ═══════════════════════════════════════════════════════════════ +# CameraId +# ═══════════════════════════════════════════════════════════════ + +class CameraId(Stub): + """CameraId — 相机ID封装""" + + def __init__(self, id_string: str): + super().__init__() + self._id = id_string + + def getId(self) -> str: + return self._id + + def toString(self) -> str: + return self._id + + def equals(self, other) -> bool: + if isinstance(other, CameraId): + return self._id == other._id + if isinstance(other, str): + return self._id == other + return False + + def hashCode(self) -> int: + return hash(self._id) + + +# ═══════════════════════════════════════════════════════════════ +# CameraCharacteristicsKey +# ═══════════════════════════════════════════════════════════════ + +class CameraCharacteristicsKey(Stub): + """CameraCharacteristicsKey — 相机特性键""" + + def __init__(self, name: str, native_type: type = object): + super().__init__() + self._name = name + self._native_type = native_type + + def getName(self) -> str: + return self._name + + def getNativeType(self) -> type: + return self._native_type + + def equals(self, other) -> bool: + if isinstance(other, CameraCharacteristicsKey): + return self._name == other._name + return False + + def hashCode(self) -> int: + return hash(self._name) + + def toString(self) -> str: + return f"CameraCharacteristicsKey({self._name})" + + +# ═══════════════════════════════════════════════════════════════ +# CaptureRequest +# ═══════════════════════════════════════════════════════════════ + +class CaptureRequest(CameraMetadata): + """CaptureRequest — 捕获请求""" + + CONTROL_AE_MODE = "android.control.aeMode" + CONTROL_AF_MODE = "android.control.afMode" + CONTROL_AWB_MODE = "android.control.awbMode" + CONTROL_MODE = "android.control.mode" + FLASH_MODE = "android.flash.mode" + SENSOR_EXPOSURE_TIME = "android.sensor.exposureTime" + SENSOR_SENSITIVITY = "android.sensor.sensitivity" + LENS_FOCUS_DISTANCE = "android.lens.focusDistance" + STATISTICS_FACE_DETECT_MODE = "android.statistics.faceDetectMode" + JPEG_QUALITY = "android.jpeg.quality" + JPEG_ORIENTATION = "android.jpeg.orientation" + JPEG_THUMBNAIL_QUALITY = "android.jpeg.thumbnailQuality" + JPEG_THUMBNAIL_SIZE = "android.jpeg.thumbnailSize" + SCALER_CROP_REGION = "android.scaler.cropRegion" + EDGE_MODE = "android.edge.mode" + NOISE_REDUCTION_MODE = "android.noiseReduction.mode" + TONEMAP_MODE = "android.tonemap.mode" + BLACK_LEVEL_LOCK = "android.blackLevel.lock" + CONTROL_AE_TARGET_FPS_RANGE = "android.control.aeTargetFpsRange" + CONTROL_AE_EXPOSURE_COMPENSATION = "android.control.aeExposureCompensation" + CONTROL_AE_LOCK = "android.control.aeLock" + CONTROL_AE_PRECAPTURE_TRIGGER = "android.control.aePrecaptureTrigger" + CONTROL_AWB_LOCK = "android.control.awbLock" + CONTROL_EFFECT_MODE = "android.control.effectMode" + CONTROL_SCENE_MODE = "android.control.sceneMode" + CONTROL_VIDEO_STABILIZATION_MODE = "android.control.videoStabilizationMode" + COLOR_CORRECTION_MODE = "android.colorCorrection.mode" + COLOR_CORRECTION_GAINS = "android.colorCorrection.gains" + COLOR_CORRECTION_TRANSFORM = "android.colorCorrection.transform" + COLOR_CORRECTION_ABERRATION_MODE = "android.colorCorrection.aberrationMode" + CONTROL_POST_RAW_SENSITIVITY_BOOST = "android.control.postRawSensitivityBoost" + DISTORTION_CORRECTION_MODE = "android.distortionCorrection.mode" + HOT_PIXEL_MODE = "android.hotPixel.mode" + LENS_OPTICAL_STABILIZATION_MODE = "android.lens.opticalStabilizationMode" + REQUEST_PIPELINE_MAX_DEPTH = "android.request.pipelineMaxDepth" + SENSOR_TIMESTAMP = "android.sensor.timestamp" + STATISTICS_LENS_SHADING_MAP_MODE = "android.statistics.lensShadingMapMode" + STATISTICS_OIS_DATA_MODE = "android.statistics.oisDataMode" + STATISTICS_SECTION = "android.statistics.section" + TONEMAP_CURVE = "android.tonemap.curve" + TONEMAP_GAMMA = "android.tonemap.gamma" + + class Builder(Stub): + """CaptureRequest.Builder — 捕获请求构建器""" + + def __init__(self, camera_device: "CameraDevice"): + super().__init__() + self._parameters: Dict[str, Any] = {} + self._tag = None + self._camera_device = camera_device + + def set(self, key: str, value: Any): + self._parameters[key] = value + + def get(self, key: str) -> Any: + return self._parameters.get(key) + + def setTag(self, tag: Any): + self._tag = tag + + def build(self) -> "CaptureRequest": + req = CaptureRequest() + req._parameters = dict(self._parameters) + req._tag = self._tag + return req + + def addTarget(self, surface): + pass + + def removeTarget(self, surface): + pass + + def __init__(self): + super().__init__() + self._parameters: Dict[str, Any] = { + CaptureRequest.CONTROL_AE_MODE: CameraMetadata.CONTROL_AE_MODE_ON, + CaptureRequest.CONTROL_AF_MODE: CameraMetadata.CONTROL_AF_MODE_AUTO, + CaptureRequest.CONTROL_AWB_MODE: CameraMetadata.CONTROL_AWB_MODE_AUTO, + CaptureRequest.CONTROL_MODE: CameraMetadata.CONTROL_MODE_AUTO, + CaptureRequest.FLASH_MODE: CameraMetadata.FLASH_MODE_OFF, + CaptureRequest.JPEG_QUALITY: 95, + CaptureRequest.JPEG_ORIENTATION: 0, + } + self._tag = None + self._targets: List[Any] = [] + + def get(self, key: str) -> Any: + return self._parameters.get(key) + + def keys(self) -> Set[str]: + return set(self._parameters.keys()) + + def getTag(self) -> Any: + return self._tag + + +# ═══════════════════════════════════════════════════════════════ +# CaptureResult +# ═══════════════════════════════════════════════════════════════ + +class CaptureResult(CameraMetadata): + """CaptureResult — 捕获结果""" + + # Same keys as CaptureRequest + CONTROL_AE_MODE = CaptureRequest.CONTROL_AE_MODE + CONTROL_AF_MODE = CaptureRequest.CONTROL_AF_MODE + CONTROL_AWB_MODE = CaptureRequest.CONTROL_AWB_MODE + CONTROL_MODE = CaptureRequest.CONTROL_MODE + FLASH_MODE = CaptureRequest.FLASH_MODE + SENSOR_EXPOSURE_TIME = CaptureRequest.SENSOR_EXPOSURE_TIME + SENSOR_SENSITIVITY = CaptureRequest.SENSOR_SENSITIVITY + LENS_FOCUS_DISTANCE = CaptureRequest.LENS_FOCUS_DISTANCE + STATISTICS_FACE_DETECT_MODE = CaptureRequest.STATISTICS_FACE_DETECT_MODE + JPEG_QUALITY = CaptureRequest.JPEG_QUALITY + JPEG_ORIENTATION = CaptureRequest.JPEG_ORIENTATION + JPEG_THUMBNAIL_QUALITY = CaptureRequest.JPEG_THUMBNAIL_QUALITY + JPEG_THUMBNAIL_SIZE = CaptureRequest.JPEG_THUMBNAIL_SIZE + SCALER_CROP_REGION = CaptureRequest.SCALER_CROP_REGION + EDGE_MODE = CaptureRequest.EDGE_MODE + NOISE_REDUCTION_MODE = CaptureRequest.NOISE_REDUCTION_MODE + TONEMAP_MODE = CaptureRequest.TONEMAP_MODE + BLACK_LEVEL_LOCK = CaptureRequest.BLACK_LEVEL_LOCK + CONTROL_AE_TARGET_FPS_RANGE = CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE + CONTROL_AE_EXPOSURE_COMPENSATION = CaptureRequest.CONTROL_AE_EXPOSURE_COMPENSATION + CONTROL_AE_LOCK = CaptureRequest.CONTROL_AE_LOCK + CONTROL_AE_PRECAPTURE_TRIGGER = CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER + CONTROL_AWB_LOCK = CaptureRequest.CONTROL_AWB_LOCK + CONTROL_EFFECT_MODE = CaptureRequest.CONTROL_EFFECT_MODE + CONTROL_SCENE_MODE = CaptureRequest.CONTROL_SCENE_MODE + CONTROL_VIDEO_STABILIZATION_MODE = CaptureRequest.CONTROL_VIDEO_STABILIZATION_MODE + COLOR_CORRECTION_MODE = CaptureRequest.COLOR_CORRECTION_MODE + COLOR_CORRECTION_GAINS = CaptureRequest.COLOR_CORRECTION_GAINS + COLOR_CORRECTION_TRANSFORM = CaptureRequest.COLOR_CORRECTION_TRANSFORM + COLOR_CORRECTION_ABERRATION_MODE = CaptureRequest.COLOR_CORRECTION_ABERRATION_MODE + CONTROL_POST_RAW_SENSITIVITY_BOOST = CaptureRequest.CONTROL_POST_RAW_SENSITIVITY_BOOST + DISTORTION_CORRECTION_MODE = CaptureRequest.DISTORTION_CORRECTION_MODE + HOT_PIXEL_MODE = CaptureRequest.HOT_PIXEL_MODE + LENS_OPTICAL_STABILIZATION_MODE = CaptureRequest.LENS_OPTICAL_STABILIZATION_MODE + REQUEST_PIPELINE_MAX_DEPTH = CaptureRequest.REQUEST_PIPELINE_MAX_DEPTH + SENSOR_TIMESTAMP = CaptureRequest.SENSOR_TIMESTAMP + STATISTICS_LENS_SHADING_MAP_MODE = CaptureRequest.STATISTICS_LENS_SHADING_MAP_MODE + STATISTICS_OIS_DATA_MODE = CaptureRequest.STATISTICS_OIS_DATA_MODE + STATISTICS_SECTION = CaptureRequest.STATISTICS_SECTION + TONEMAP_CURVE = CaptureRequest.TONEMAP_CURVE + TONEMAP_GAMMA = CaptureRequest.TONEMAP_GAMMA + + def __init__(self, request: CaptureRequest = None): + super().__init__() + self._results: Dict[str, Any] = { + CaptureResult.CONTROL_AE_MODE: CameraMetadata.CONTROL_AE_MODE_ON, + CaptureResult.CONTROL_AF_MODE: CameraMetadata.CONTROL_AF_MODE_AUTO, + CaptureResult.CONTROL_AWB_MODE: CameraMetadata.CONTROL_AWB_MODE_AUTO, + CaptureResult.CONTROL_MODE: CameraMetadata.CONTROL_MODE_AUTO, + CaptureResult.FLASH_MODE: CameraMetadata.FLASH_MODE_OFF, + CaptureResult.SENSOR_EXPOSURE_TIME: 33333333, + CaptureResult.SENSOR_SENSITIVITY: 100, + CaptureResult.SENSOR_TIMESTAMP: int(time.time() * 1e9), + } + self._request = request + self._sequence_id = -1 + self._frame_number = -1 + + def get(self, key: str) -> Any: + return self._results.get(key) + + def keys(self) -> Set[str]: + return set(self._results.keys()) + + def getRequest(self) -> Optional[CaptureRequest]: + return self._request + + def getSequenceId(self) -> int: + return self._sequence_id + + def getFrameNumber(self) -> int: + return self._frame_number + + +# ═══════════════════════════════════════════════════════════════ +# TotalCaptureResult +# ═══════════════════════════════════════════════════════════════ + +class TotalCaptureResult(CaptureResult): + """TotalCaptureResult — 完整捕获结果""" + + def __init__(self, request: CaptureRequest = None, + partial_results: List[CaptureResult] = None): + super().__init__(request) + self._partial_results = partial_results or [] + + def getPartialResults(self) -> List[CaptureResult]: + return list(self._partial_results) + + +# ═══════════════════════════════════════════════════════════════ +# CameraCaptureSession +# ═══════════════════════════════════════════════════════════════ + +class CameraCaptureSession(Stub): + """CameraCaptureSession — 捕获会话""" + + class StateCallback(Stub): + """CameraCaptureSession.StateCallback — 会话状态回调""" + + def onConfigured(self, session: "CameraCaptureSession"): + pass + + def onConfigureFailed(self, session: "CameraCaptureSession"): + pass + + def onReady(self, session: "CameraCaptureSession"): + pass + + def onActive(self, session: "CameraCaptureSession"): + pass + + def onClosed(self, session: "CameraCaptureSession"): + pass + + def onSurfacePrepared(self, session: "CameraCaptureSession", surface): + pass + + class CaptureCallback(Stub): + """CameraCaptureSession.CaptureCallback — 捕获回调""" + + def onCaptureStarted(self, session: "CameraCaptureSession", request: CaptureRequest, + timestamp: int, frameNumber: int): + pass + + def onCaptureCompleted(self, session: "CameraCaptureSession", request: CaptureRequest, + result: TotalCaptureResult): + pass + + def onCaptureFailed(self, session: "CameraCaptureSession", request: CaptureRequest, + failure): + pass + + def onCaptureProgressed(self, session: "CameraCaptureSession", request: CaptureRequest, + result: CaptureResult): + pass + + def onCaptureSequenceCompleted(self, session: "CameraCaptureSession", + sequenceId: int, frameNumber: int): + pass + + def onCaptureSequenceAborted(self, session: "CameraCaptureSession", sequenceId: int): + pass + + def onCaptureBufferLost(self, session: "CameraCaptureSession", request: CaptureRequest, + target, frameNumber: int): + pass + + def __init__(self, device: "CameraDevice"): + super().__init__() + self._device = device + self._closed = False + self._repeating_request = None + self._state_callback = None + self._session_id = int(time.time() * 1000) + + def capture(self, request: CaptureRequest, callback: CaptureCallback = None, + handler=None) -> int: + seq_id = int(time.time() * 1000) + result = TotalCaptureResult(request) + if callback: + callback.onCaptureStarted(self, request, int(time.time() * 1e9), 0) + callback.onCaptureCompleted(self, request, result) + callback.onCaptureSequenceCompleted(self, seq_id, 0) + return seq_id + + def setRepeatingRequest(self, request: CaptureRequest, callback: CaptureCallback = None, + handler=None) -> int: + self._repeating_request = request + seq_id = int(time.time() * 1000) + result = TotalCaptureResult(request) + if callback: + callback.onCaptureStarted(self, request, int(time.time() * 1e9), 0) + callback.onCaptureCompleted(self, request, result) + return seq_id + + def stopRepeatingRequest(self) -> None: + self._repeating_request = None + + def abortCaptures(self) -> None: + pass + + def close(self): + self._closed = True + + def getDevice(self) -> "CameraDevice": + return self._device + + def isClosed(self) -> bool: + return self._closed + + +# ═══════════════════════════════════════════════════════════════ +# CameraDevice +# ═══════════════════════════════════════════════════════════════ + +class CameraDevice(Stub): + """CameraDevice — 相机设备""" + + STATE_OPENED = 0 + STATE_CLOSED = 3 + STATE_DISCONNECTED = 1 + STATE_ERROR = 2 + + class StateCallback(Stub): + """CameraDevice.StateCallback — 设备状态回调""" + + def onOpened(self, device: "CameraDevice"): + pass + + def onClosed(self, device: "CameraDevice"): + pass + + def onDisconnected(self, device: "CameraDevice"): + pass + + def onError(self, device: "CameraDevice", error: int): + pass + + def __init__(self, camera_id: str = "0"): + super().__init__() + self._id = camera_id + self._state = CameraDevice.STATE_OPENED + self._state_callback = None + self._sessions: List[CameraCaptureSession] = [] + + def getId(self) -> str: + return self._id + + def createCaptureRequest(self, templateType: int) -> CaptureRequest.Builder: + return CaptureRequest.Builder(self) + + def createCaptureSession(self, outputs: List[Any], + callback: CameraCaptureSession.StateCallback, + handler=None): + session = CameraCaptureSession(self) + session._state_callback = callback + self._sessions.append(session) + if callback: + callback.onConfigured(session) + return session + + def close(self): + self._state = CameraDevice.STATE_CLOSED + for session in self._sessions: + session.close() + + def getState(self) -> int: + return self._state + + def toString(self) -> str: + return f"CameraDevice@{self._id}" + + +# ═══════════════════════════════════════════════════════════════ +# CameraManager +# ═══════════════════════════════════════════════════════════════ + +class CameraManager(Stub): + """CameraManager — 相机管理器""" + + def __init__(self): + super().__init__() + self._cameras: Dict[str, CameraCharacteristics] = { + "0": CameraCharacteristics("0"), + } + self._open_devices: Dict[str, CameraDevice] = {} + self._availability_callbacks: List[Any] = [] + self._torch_callbacks: List[Any] = [] + + def getCameraIdList(self) -> List[str]: + return list(self._cameras.keys()) + + def getCameraCharacteristics(self, cameraId: str) -> CameraCharacteristics: + if cameraId not in self._cameras: + raise AndroidOnlyError(f"Camera {cameraId} not available") + return self._cameras[cameraId] + + def openCamera(self, cameraId: str, callback: CameraDevice.StateCallback, + handler=None): + if cameraId not in self._cameras: + if callback: + callback.onError(None, CameraDevice.STATE_ERROR) + return + device = CameraDevice(cameraId) + self._open_devices[cameraId] = device + if callback: + callback.onOpened(device) + + def registerAvailabilityCallback(self, callback): + self._availability_callbacks.append(callback) + + def unregisterAvailabilityCallback(self, callback): + if callback in self._availability_callbacks: + self._availability_callbacks.remove(callback) + + def registerTorchCallback(self, callback, handler=None): + self._torch_callbacks.append(callback) + + def unregisterTorchCallback(self, callback): + if callback in self._torch_callbacks: + self._torch_callbacks.remove(callback) + + def setTorchMode(self, cameraId: str, enabled: bool): + pass + + +# ═══════════════════════════════════════════════════════════════ +# CameraOfflineSession +# ═══════════════════════════════════════════════════════════════ + +class CameraOfflineSession(CameraCaptureSession): + """CameraOfflineSession — 离线会话 (API 30+)""" + + def __init__(self, device: CameraDevice): + super().__init__(device) + + def switchToOffline(self): + pass + + +# ═══════════════════════════════════════════════════════════════ +# CameraExtensionSession +# ═══════════════════════════════════════════════════════════════ + +class CameraExtensionSession(Stub): + """CameraExtensionSession — 扩展会话 (API 31+)""" + + class StateCallback(Stub): + def onConfigured(self, session: "CameraExtensionSession"): + pass + + def onConfigureFailed(self, session: "CameraExtensionSession"): + pass + + def onClosed(self, session: "CameraExtensionSession"): + pass + + class ExtensionCaptureCallback(Stub): + def onCaptureStarted(self, session: "CameraExtensionSession", request: CaptureRequest, + timestamp: int): + pass + + def onCaptureProcessStarted(self, session: "CameraExtensionSession", request: CaptureRequest): + pass + + def onCaptureFailed(self, session: "CameraExtensionSession", request: CaptureRequest): + pass + + def onCaptureResultAvailable(self, session: "CameraExtensionSession", + request: CaptureRequest, result: TotalCaptureResult): + pass + + def __init__(self): + super().__init__() + self._closed = False + + def close(self): + self._closed = True + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "CameraManager", "CameraDevice", "CameraCaptureSession", + "CaptureRequest", "CaptureResult", "CameraCharacteristics", + "CameraMetadata", "CameraId", "CameraCharacteristicsKey", + "TotalCaptureResult", "CameraOfflineSession", "CameraExtensionSession", +] \ No newline at end of file diff --git a/android_pyapi/android/inputmethod.py b/android_pyapi/android/inputmethod.py new file mode 100644 index 0000000..553deef --- /dev/null +++ b/android_pyapi/android/inputmethod.py @@ -0,0 +1,804 @@ +""" +Android InputMethod 组件 — InputMethodService, Keyboard, KeyboardView, Key 等 +方法签名完全对齐 Android SDK +""" + +import sys +from typing import Any, Callable, Dict, List, Optional, Tuple + +from .._core import Stub, AndroidOnlyError, android_context + + +# ═══════════════════════════════════════════════════════════════ +# InputMethod +# ═══════════════════════════════════════════════════════════════ + +class InputMethod(Stub): + """InputMethod — 输入法接口""" + + def __init__(self): + super().__init__() + + def createSession(self, callback: Any) -> Optional["InputMethodSession"]: + """创建输入法会话""" + return None + + def startInput(self, input_connection: Any, editor_info: Any) -> None: + """开始输入""" + pass + + def restartInput(self, input_connection: Any, editor_info: Any) -> None: + """重启输入""" + pass + + def dispatchKeyEvent(self, event: Any) -> None: + """分发按键事件""" + pass + + def dispatchTrackballEvent(self, event: Any) -> None: + """分发轨迹球事件""" + pass + + def dispatchGenericMotionEvent(self, event: Any) -> None: + """分发通用运动事件""" + pass + + +# ═══════════════════════════════════════════════════════════════ +# InputMethodSession +# ═══════════════════════════════════════════════════════════════ + +class InputMethodSession(Stub): + """InputMethodSession — 输入法会话接口""" + + def __init__(self): + super().__init__() + + def finishInput(self): + """结束输入""" + pass + + def updateSelection(self, old_sel_start: int, old_sel_end: int, + new_sel_start: int, new_sel_end: int, + candidates_start: int, candidates_end: int): + """更新选区""" + pass + + def updateCursor(self, old_cursor: Any, new_cursor: Any): + """更新光标""" + pass + + def displayCompletions(self, completions: List["CompletionInfo"]): + """显示补全""" + pass + + def appPrivateCommand(self, action: str, data: Any): + """应用私有命令""" + pass + + def viewClicked(self, focus_changed: bool): + """视图点击""" + pass + + def updateExtractedText(self, token: int, extracted_text: Any): + """更新提取文本""" + pass + + def dispatchKeyEvent(self, key_code: int, event: Any) -> None: + """分发按键事件""" + pass + + def dispatchTrackballEvent(self, event: Any) -> None: + pass + + def dispatchGenericMotionEvent(self, event: Any) -> None: + pass + + def toggleSoftInput(self, show_flags: int, hide_flags: int): + """切换软键盘""" + pass + + def notifyImeHidden(self): + """通知输入法隐藏""" + pass + + def removeImeSurface(self): + """移除输入法界面""" + pass + + +# ═══════════════════════════════════════════════════════════════ +# AbstractInputMethodService +# ═══════════════════════════════════════════════════════════════ + +class AbstractInputMethodService(Stub): + """AbstractInputMethodService — 抽象输入法服务基类""" + + def __init__(self): + super().__init__() + self._input_method: Optional[InputMethod] = None + self._input_method_session: Optional[InputMethodSession] = None + + def onCreate(self): + """服务创建""" + pass + + def onDestroy(self): + """服务销毁""" + pass + + def onBind(self, intent: Any) -> Any: + """绑定""" + return None + + def onUnbind(self, intent: Any) -> bool: + """解绑""" + return False + + def onCreateInputMethod(self) -> InputMethod: + """创建输入法实例""" + return InputMethod() + + def onCreateInputMethodSession(self) -> InputMethodSession: + """创建输入法会话""" + return InputMethodSession() + + def getKeyDispatcherState(self) -> Any: + """获取按键调度状态""" + return None + + +# ═══════════════════════════════════════════════════════════════ +# InputMethodImpl +# ═══════════════════════════════════════════════════════════════ + +class InputMethodImpl(InputMethod): + """InputMethodImpl — 输入法实现""" + + def __init__(self): + super().__init__() + self._session: Optional[InputMethodSession] = None + + def createSession(self, callback: Any) -> Optional["InputMethodSession"]: + self._session = InputMethodSessionImpl() + return self._session + + def startInput(self, input_connection: Any, editor_info: Any): + sys.stderr.write("[InputMethodImpl] startInput\n") + + def restartInput(self, input_connection: Any, editor_info: Any): + sys.stderr.write("[InputMethodImpl] restartInput\n") + + def dispatchKeyEvent(self, event: Any): + sys.stderr.write("[InputMethodImpl] dispatchKeyEvent\n") + + def dispatchTrackballEvent(self, event: Any): + pass + + def dispatchGenericMotionEvent(self, event: Any): + pass + + +# ═══════════════════════════════════════════════════════════════ +# InputMethodSessionImpl +# ═══════════════════════════════════════════════════════════════ + +class InputMethodSessionImpl(InputMethodSession): + """InputMethodSessionImpl — 输入法会话实现""" + + def __init__(self): + super().__init__() + + def finishInput(self): + sys.stderr.write("[InputMethodSessionImpl] finishInput\n") + + def updateSelection(self, old_sel_start: int, old_sel_end: int, + new_sel_start: int, new_sel_end: int, + candidates_start: int, candidates_end: int): + pass + + def displayCompletions(self, completions: List["CompletionInfo"]): + pass + + def dispatchKeyEvent(self, key_code: int, event: Any): + pass + + +# ═══════════════════════════════════════════════════════════════ +# InputMethodService +# ═══════════════════════════════════════════════════════════════ + +class InputMethodService(AbstractInputMethodService): + """InputMethodService — 输入法服务""" + + SHOW_EXPLICIT = 0x0001 + SHOW_IMPLICIT = 0x0002 + + def __init__(self): + super().__init__() + self._input_view: Optional[Any] = None + self._candidates_view: Optional[Any] = None + self._input_connection: Optional[Any] = None + self._input_editor_info: Optional["EditorInfo"] = None + self._input_binding: Optional["InputBinding"] = None + self._input_view_shown: bool = False + self._fullscreen_mode: bool = False + self._extract_to_fullscreen_mode: bool = False + self._is_fullscreen: bool = False + self._keyboard: Optional["Keyboard"] = None + self._settings_observer: Any = None + self._candidates_view_shown: bool = False + self._show_input_requested: bool = False + self._token: Any = None + self._window_visible: bool = False + self._input_started: bool = False + + def onCreate(self): + """创建服务""" + sys.stderr.write("[InputMethodService] onCreate\n") + + def onCreateInputView(self) -> Optional[Any]: + """创建输入视图""" + return None + + def onCreateCandidatesView(self) -> Optional[Any]: + """创建候选视图""" + return None + + def onStartInputView(self, info: "EditorInfo", restarting: bool): + """开始输入视图""" + pass + + def onFinishInputView(self, finishing_input: bool): + """结束输入视图""" + pass + + def onStartInput(self, attribute: "EditorInfo", restarting: bool): + """开始输入""" + self._input_editor_info = attribute + self._input_started = True + + def onFinishInput(self): + """结束输入""" + self._input_started = False + + def onBindInput(self, binding: "InputBinding"): + """绑定输入""" + self._input_binding = binding + + def onUnbindInput(self) -> bool: + """解绑输入""" + self._input_binding = None + return False + + def onDestroy(self): + """销毁""" + self._input_view = None + self._candidates_view = None + self._input_connection = None + + def showWindow(self, show_flags: int): + """显示窗口""" + self._window_visible = True + sys.stderr.write(f"[InputMethodService] showWindow: flags={show_flags}\n") + + def hideWindow(self): + """隐藏窗口""" + self._window_visible = False + + def setInputView(self, view: Any): + """设置输入视图""" + self._input_view = view + + def setCandidatesView(self, view: Any): + """设置候选视图""" + self._candidates_view = view + + def updateInputViewShown(self): + """更新输入视图显示状态""" + pass + + def updateFullscreenMode(self): + """更新全屏模式""" + pass + + def updateExtractToFullscreenMode(self): + """更新提取全屏模式""" + pass + + def requestHideSelf(self, flags: int): + """请求隐藏自身""" + sys.stderr.write(f"[InputMethodService] requestHideSelf: flags={flags}\n") + + def switchInputMethod(self, id: str): + """切换输入法""" + sys.stderr.write(f"[InputMethodService] switchInputMethod: id={id}\n") + + def sendDefaultEditorAction(self, from_enter_key: bool): + """发送默认编辑器动作""" + pass + + def sendDownUpKeyEvents(self, key_event_code: int): + """发送按键按下和释放事件""" + pass + + def getCurrentInputBinding(self) -> Optional["InputBinding"]: + """获取当前输入绑定""" + return self._input_binding + + def getCurrentInputEditorInfo(self) -> Optional["EditorInfo"]: + """获取当前编辑器信息""" + return self._input_editor_info + + def getCurrentInputConnection(self) -> Optional["InputConnection"]: + """获取当前输入连接""" + return self._input_connection + + def getTextForImeAction(self, ime_options: int) -> str: + """获取IME动作的文本""" + action_map = { + 0x0001: "None", + 0x0002: "Go", + 0x0003: "Search", + 0x0004: "Send", + 0x0005: "Next", + 0x0006: "Done", + 0x0007: "Previous", + } + action = ime_options & 0x000000FF + return action_map.get(action, "Unknown") + + def doStartInput(self, input_connection: Any, editor_info: "EditorInfo", restarting: bool): + """执行启动输入""" + self._input_connection = input_connection + self._input_editor_info = editor_info + self.onStartInput(editor_info, restarting) + if self._window_visible: + self.onStartInputView(editor_info, restarting) + + def doFinishInput(self): + """执行结束输入""" + self.onFinishInput() + self.onFinishInputView(True) + + def onEvaluateInputViewShown(self) -> bool: + """评估是否显示输入视图""" + return self._input_view is not None + + def onEvaluateFullscreenMode(self) -> bool: + """评估是否全屏模式""" + return self._fullscreen_mode + + def onConfigureWindow(self, win: Any, is_fullscreen: bool, is_candidates: bool): + """配置窗口""" + pass + + def isInputViewShown(self) -> bool: + """输入视图是否已显示""" + return self._input_view_shown + + def updateWindow(self, show_input: bool = False): + """更新窗口""" + pass + + def setExtractView(self, view: Any): + """设置提取视图""" + pass + + def getExtractView(self) -> Optional[Any]: + """获取提取视图""" + return None + + def getInputView(self) -> Optional[Any]: + """获取输入视图""" + return self._input_view + + def getCandidatesView(self) -> Optional[Any]: + """获取候选视图""" + return self._candidates_view + + def isFullscreenMode(self) -> bool: + """是否全屏模式""" + return self._is_fullscreen + + def onDisplayCompletions(self, completions: List["CompletionInfo"]): + """显示补全""" + pass + + def onUpdateSelection(self, old_sel_start: int, old_sel_end: int, + new_sel_start: int, new_sel_end: int, + candidates_start: int, candidates_end: int): + """更新选区""" + pass + + def onViewClicked(self, focus_changed: bool): + """视图点击""" + pass + + def onWindowShown(self): + """窗口显示""" + self._window_visible = True + + def onWindowHidden(self): + """窗口隐藏""" + self._window_visible = False + + def setKeyboard(self, keyboard: "Keyboard"): + """设置键盘""" + self._keyboard = keyboard + + def getKeyboard(self) -> Optional["Keyboard"]: + """获取键盘""" + return self._keyboard + + +# ═══════════════════════════════════════════════════════════════ +# Key +# ═══════════════════════════════════════════════════════════════ + +class Key(Stub): + """Key — 键盘按键""" + + def __init__(self, row: "KeyboardRow" = None): + super().__init__() + self.codes: List[int] = [] + self.label: Optional[str] = None + self.icon: Any = None + self.sticky: bool = False + self.modifier: bool = False + self.repeatable: bool = False + self.edgeFlags: int = 0 + self.popupCharacters: Optional[str] = None + self.popupResId: int = 0 + self._x: int = 0 + self._y: int = 0 + self._width: int = 0 + self._height: int = 0 + self._gap: int = 0 + self._row: Optional["KeyboardRow"] = row + self._pressed: bool = False + self._on: bool = False + + def getCode(self) -> int: + """获取按键码""" + return self.codes[0] if self.codes else 0 + + def isPressed(self) -> bool: + """是否按下""" + return self._pressed + + def setPressed(self, pressed: bool): + """设置按下状态""" + self._pressed = pressed + + def isOn(self) -> bool: + """是否开启""" + return self._on + + def setOn(self, on_state: bool): + """设置开启状态""" + self._on = on_state + + def squaredDistance(self, x: int, y: int) -> int: + """计算距离平方""" + center_x = self._x + self._width // 2 + center_y = self._y + self._height // 2 + return (x - center_x) ** 2 + (y - center_y) ** 2 + + def hitTest(self, x: int, y: int) -> bool: + """命中测试""" + return (self._x <= x <= self._x + self._width and + self._y <= y <= self._y + self._height) + + def getX(self) -> int: + return self._x + + def getY(self) -> int: + return self._y + + def getWidth(self) -> int: + return self._width + + def getHeight(self) -> int: + return self._height + + def toString(self) -> str: + return f"Key(code={self.getCode()}, label={self.label})" + + +# ═══════════════════════════════════════════════════════════════ +# KeyboardRow +# ═══════════════════════════════════════════════════════════════ + +class KeyboardRow(Stub): + """KeyboardRow — 键盘行""" + + def __init__(self, keyboard: "Keyboard" = None): + super().__init__() + self._keys: List[Key] = [] + self._keyboard: Optional["Keyboard"] = keyboard + self._default_width: int = 0 + self._default_height: int = 0 + self._row_edge_flags: int = 0 + self._mode: str = "" + + def getKeys(self) -> List[Key]: + return list(self._keys) + + def addKey(self, key: Key): + self._keys.append(key) + + def getKeyboard(self) -> Optional["Keyboard"]: + return self._keyboard + + def getDefaultWidth(self) -> int: + return self._default_width + + def getDefaultHeight(self) -> int: + return self._default_height + + def toString(self) -> str: + return f"KeyboardRow(keys={len(self._keys)})" + + +# ═══════════════════════════════════════════════════════════════ +# Keyboard +# ═══════════════════════════════════════════════════════════════ + +class Keyboard(Stub): + """Keyboard — 键盘布局""" + + def __init__(self, context: Any = None, xml_layout_res_id: int = 0): + super().__init__() + self._keys: List[Key] = [] + self._rows: List[KeyboardRow] = [] + self._modifier_keys: List[Key] = [] + self._height: int = 0 + self._min_width: int = 0 + self._key_width: int = 0 + self._key_height: int = 0 + self._horizontal_gap: int = 0 + self._vertical_gap: int = 0 + self._shift_keys: List[Key] = [] + self._alt_keys: List[Key] = [] + + def getKeys(self) -> List[Key]: + return list(self._keys) + + def getHeight(self) -> int: + return self._height + + def getMinWidth(self) -> int: + return self._min_width + + def getKeyWidth(self) -> int: + return self._key_width + + def getKeyHeight(self) -> int: + return self._key_height + + def getHorizontalGap(self) -> int: + return self._horizontal_gap + + def getVerticalGap(self) -> int: + return self._vertical_gap + + def getModifierKeys(self) -> List[Key]: + return list(self._modifier_keys) + + def getNearestKeys(self, x: int, y: int) -> List[Key]: + """获取最近的按键""" + nearest: List[Key] = [] + for key in self._keys: + if key.hitTest(x, y): + nearest.append(key) + return nearest + + def setKeys(self, keys: List[Key]): + """设置按键列表""" + self._keys = keys + + def getRows(self) -> List[KeyboardRow]: + return list(self._rows) + + def setShifted(self, shift_state: bool): + """设置Shift状态""" + pass + + def isShifted(self) -> bool: + """是否Shift状态""" + return False + + def getShiftKeyIndex(self) -> int: + """获取Shift按键索引""" + for i, key in enumerate(self._keys): + if key.modifier: + return i + return -1 + + def setVerticalGap(self, gap: int): + self._vertical_gap = gap + + def setHorizontalGap(self, gap: int): + self._horizontal_gap = gap + + def setKeyWidth(self, width: int): + self._key_width = width + + def setKeyHeight(self, height: int): + self._key_height = height + + def toString(self) -> str: + return f"Keyboard(keys={len(self._keys)}, rows={len(self._rows)})" + + +# ═══════════════════════════════════════════════════════════════ +# KeyboardView +# ═══════════════════════════════════════════════════════════════ + +class KeyboardView(Stub): + """KeyboardView — 键盘视图""" + + class OnKeyboardActionListener(Stub): + """OnKeyboardActionListener — 键盘动作监听器""" + + def onKey(self, primary_code: int): + pass + + def onPress(self, primary_code: int): + pass + + def onRelease(self, primary_code: int): + pass + + def onText(self, text: str): + pass + + def swipeLeft(self): + pass + + def swipeRight(self): + pass + + def swipeDown(self): + pass + + def swipeUp(self): + pass + + def __init__(self, context: Any = None, attrs: Any = None): + super().__init__() + self._keyboard: Optional[Keyboard] = None + self._on_keyboard_action_listener: Optional["KeyboardView.OnKeyboardActionListener"] = None + self._preview_enabled: bool = True + self._proximity_correction_enabled: bool = True + self._vertical_correction: int = 0 + self._key_text_color: int = 0xFF000000 + self._key_text_size: int = 20 + self._shadow_color: int = 0x00000000 + self._shadow_radius: float = 0.0 + self._background_color: int = 0xFF888888 + + def setKeyboard(self, keyboard: Keyboard): + self._keyboard = keyboard + + def getKeyboard(self) -> Optional[Keyboard]: + return self._keyboard + + def onDraw(self, canvas: Any): + """绘制键盘""" + pass + + def setOnKeyboardActionListener(self, listener: "KeyboardView.OnKeyboardActionListener"): + self._on_keyboard_action_listener = listener + + def getOnKeyboardActionListener(self) -> Optional["KeyboardView.OnKeyboardActionListener"]: + return self._on_keyboard_action_listener + + def setPreviewEnabled(self, preview_enabled: bool): + self._preview_enabled = preview_enabled + + def isPreviewEnabled(self) -> bool: + return self._preview_enabled + + def setProximityCorrectionEnabled(self, enabled: bool): + self._proximity_correction_enabled = enabled + + def isProximityCorrectionEnabled(self) -> bool: + return self._proximity_correction_enabled + + def setVerticalCorrection(self, vertical_correction: int): + self._vertical_correction = vertical_correction + + def getVerticalCorrection(self) -> int: + return self._vertical_correction + + def setKeyTextColor(self, color: int): + self._key_text_color = color + + def setKeyTextSize(self, size: int): + self._key_text_size = size + + def setShadowColor(self, color: int): + self._shadow_color = color + + def setShadowRadius(self, radius: float): + self._shadow_radius = radius + + def setBackgroundColor(self, color: int): + self._background_color = color + + def invalidateAllKeys(self): + """使所有按键失效""" + pass + + def invalidateKey(self, key_index: int): + """使指定按键失效""" + pass + + def onClick(self, key: Key): + """点击按键""" + if self._on_keyboard_action_listener and key.codes: + self._on_keyboard_action_listener.onKey(key.codes[0]) + + def onLongPress(self, key: Key) -> bool: + """长按按键""" + if key.popupCharacters: + return True + return False + + def closing(self): + """关闭""" + pass + + def handleBack(self) -> bool: + """处理返回键""" + return False + + def setKeys(self, keys: List[Key]): + """设置按键""" + if self._keyboard: + self._keyboard.setKeys(keys) + + +# ═══════════════════════════════════════════════════════════════ +# KeyEventCallback +# ═══════════════════════════════════════════════════════════════ + +class KeyEventCallback(Stub): + """KeyEventCallback — 按键事件回调""" + + def onKeyDown(self, key_code: int, event: Any) -> bool: + """按键按下""" + return False + + def onKeyLongPress(self, key_code: int, event: Any) -> bool: + """按键长按""" + return False + + def onKeyUp(self, key_code: int, event: Any) -> bool: + """按键释放""" + return False + + def onKeyMultiple(self, key_code: int, count: int, event: Any) -> bool: + """按键重复""" + return False + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "InputMethodService", + "InputMethodImpl", + "InputMethodSessionImpl", + "AbstractInputMethodService", + "InputMethod", + "InputMethodSession", + "Keyboard", + "KeyboardView", + "Key", + "KeyEventCallback", + "KeyboardRow", +] \ No newline at end of file diff --git a/android_pyapi/android/location.py b/android_pyapi/android/location.py new file mode 100644 index 0000000..5ad2073 --- /dev/null +++ b/android_pyapi/android/location.py @@ -0,0 +1,1055 @@ +""" +Android Location 组件 — Location, LocationManager, Geocoder 等 +方法签名完全对齐 Android SDK +""" + +import os +import sys +import math +import threading +from typing import Any, Dict, List, Optional, Set, Tuple, Union +from datetime import datetime + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, + _sdcard_root, _app_data_dir, _package_name, +) + + +# ═══════════════════════════════════════════════════════════════ +# Location +# ═══════════════════════════════════════════════════════════════ + +class Location(Stub): + """Location — 地理位置信息""" + + FORMAT_DEGREES = 0 + FORMAT_MINUTES = 1 + FORMAT_SECONDS = 2 + + def __init__(self, provider: str = ""): + super().__init__() + self._provider = provider + self._latitude: float = 0.0 + self._longitude: float = 0.0 + self._accuracy: float = 0.0 + self._time: int = 0 + self._elapsed_realtime_nanos: int = 0 + self._altitude: float = 0.0 + self._speed: float = 0.0 + self._bearing: float = 0.0 + self._extras: Optional[Dict[str, Any]] = None + + def setLatitude(self, latitude: float): + self._latitude = latitude + + def getLatitude(self) -> float: + return self._latitude + + def setLongitude(self, longitude: float): + self._longitude = longitude + + def getLongitude(self) -> float: + return self._longitude + + def setAccuracy(self, accuracy: float): + self._accuracy = accuracy + + def getAccuracy(self) -> float: + return self._accuracy + + def setTime(self, time: int): + self._time = time + + def getTime(self) -> int: + return self._time + + def setElapsedRealtimeNanos(self, nanos: int): + self._elapsed_realtime_nanos = nanos + + def getElapsedRealtimeNanos(self) -> int: + return self._elapsed_realtime_nanos + + def setAltitude(self, altitude: float): + self._altitude = altitude + + def getAltitude(self) -> float: + return self._altitude + + def setSpeed(self, speed: float): + self._speed = speed + + def getSpeed(self) -> float: + return self._speed + + def setBearing(self, bearing: float): + self._bearing = bearing + + def getBearing(self) -> float: + return self._bearing + + def setProvider(self, provider: str): + self._provider = provider + + def getProvider(self) -> str: + return self._provider + + def distanceTo(self, dest: "Location") -> float: + R = 6371000 + lat1 = math.radians(self._latitude) + lat2 = math.radians(dest._latitude) + dlat = math.radians(dest._latitude - self._latitude) + dlon = math.radians(dest._longitude - self._longitude) + a = (math.sin(dlat / 2) ** 2 + + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2) + c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a)) + return R * c + + def bearingTo(self, dest: "Location") -> float: + lat1 = math.radians(self._latitude) + lat2 = math.radians(dest._latitude) + dlon = math.radians(dest._longitude - self._longitude) + y = math.sin(dlon) * math.cos(lat2) + x = (math.cos(lat1) * math.sin(lat2) - + math.sin(lat1) * math.cos(lat2) * math.cos(dlon)) + return (math.degrees(math.atan2(y, x)) + 360) % 360 + + @staticmethod + def convert(coordinate: Union[str, float], output_type: int = FORMAT_DEGREES) -> Union[str, float]: + if isinstance(coordinate, str): + return Location._parse_coordinate(coordinate) + return Location._format_coordinate(coordinate, output_type) + + @staticmethod + def _parse_coordinate(coord_str: str) -> float: + coord_str = coord_str.strip() + try: + return float(coord_str) + except ValueError: + pass + parts = coord_str.replace(",", ".").split() + if len(parts) >= 3: + try: + d = float(parts[0]) + m = float(parts[1]) + s = float(parts[2].rstrip("NSEW")) + result = d + m / 60.0 + s / 3600.0 + if coord_str.rstrip()[-1:] in ("S", "W"): + result = -result + return result + except (ValueError, IndexError): + return 0.0 + return 0.0 + + @staticmethod + def _format_coordinate(coord: float, output_type: int) -> str: + if output_type == Location.FORMAT_DEGREES: + return f"{coord:.6f}" + elif output_type == Location.FORMAT_MINUTES: + deg = int(coord) + minutes = (coord - deg) * 60 + return f"{deg}:{minutes:.3f}" + else: + deg = int(coord) + minutes = (coord - deg) * 60 + int_min = int(minutes) + secs = (minutes - int_min) * 60 + return f"{deg}:{int_min}:{secs:.2f}" + + def getExtras(self) -> Optional[Dict[str, Any]]: + return self._extras + + def setExtras(self, extras: Dict[str, Any]): + self._extras = extras + + def toString(self) -> str: + return (f"Location[provider={self._provider}, " + f"{self._latitude:.6f},{self._longitude:.6f}, " + f"acc={self._accuracy:.1f}]") + + def __repr__(self): + return self.toString() + + +# ═══════════════════════════════════════════════════════════════ +# Criteria +# ═══════════════════════════════════════════════════════════════ + +class Criteria(Stub): + """Criteria — 位置提供者筛选条件""" + + ACCURACY_FINE = 1 + ACCURACY_COARSE = 2 + POWER_LOW = 1 + POWER_MEDIUM = 2 + POWER_HIGH = 3 + NO_REQUIREMENT = 0 + + def __init__(self): + super().__init__() + self._accuracy = self.NO_REQUIREMENT + self._power_requirement = self.NO_REQUIREMENT + self._altitude_required = False + self._bearing_required = False + self._speed_required = False + self._cost_allowed = False + + def setAccuracy(self, accuracy: int): + self._accuracy = accuracy + + def getAccuracy(self) -> int: + return self._accuracy + + def setPowerRequirement(self, power: int): + self._power_requirement = power + + def getPowerRequirement(self) -> int: + return self._power_requirement + + def setAltitudeRequired(self, required: bool): + self._altitude_required = required + + def isAltitudeRequired(self) -> bool: + return self._altitude_required + + def setBearingRequired(self, required: bool): + self._bearing_required = required + + def isBearingRequired(self) -> bool: + return self._bearing_required + + def setSpeedRequired(self, required: bool): + self._speed_required = required + + def isSpeedRequired(self) -> bool: + return self._speed_required + + def setCostAllowed(self, allowed: bool): + self._cost_allowed = allowed + + def isCostAllowed(self) -> bool: + return self._cost_allowed + + def toString(self) -> str: + return f"Criteria(acc={self._accuracy}, power={self._power_requirement})" + + +# ═══════════════════════════════════════════════════════════════ +# LocationProvider +# ═══════════════════════════════════════════════════════════════ + +class LocationProvider(Stub): + """LocationProvider — 位置提供者""" + + AVAILABLE = 2 + TEMPORARILY_UNAVAILABLE = 1 + OUT_OF_SERVICE = 0 + + def __init__(self, name: str = ""): + super().__init__() + self._name = name + self._accuracy = Criteria.NO_REQUIREMENT + self._power_requirement = Criteria.NO_REQUIREMENT + self._has_monetary_cost = False + self._requires_cell = False + self._requires_network = False + self._requires_satellite = False + self._supports_altitude = False + self._supports_bearing = False + self._supports_speed = False + + def getName(self) -> str: + return self._name + + def getAccuracy(self) -> int: + return self._accuracy + + def getPowerRequirement(self) -> int: + return self._power_requirement + + def hasMonetaryCost(self) -> bool: + return self._has_monetary_cost + + def requiresCell(self) -> bool: + return self._requires_cell + + def requiresNetwork(self) -> bool: + return self._requires_network + + def requiresSatellite(self) -> bool: + return self._requires_satellite + + def supportsAltitude(self) -> bool: + return self._supports_altitude + + def supportsBearing(self) -> bool: + return self._supports_bearing + + def supportsSpeed(self) -> bool: + return self._supports_speed + + def getRequirements(self) -> int: + req = 0 + if self._requires_cell: + req |= 1 + if self._requires_network: + req |= 2 + if self._requires_satellite: + req |= 4 + return req + + def toString(self) -> str: + return f"LocationProvider(name={self._name})" + + +# ═══════════════════════════════════════════════════════════════ +# LocationListener +# ═══════════════════════════════════════════════════════════════ + +class LocationListener(Stub): + """LocationListener — 位置变化监听器""" + + def onLocationChanged(self, location: Location): + pass + + def onStatusChanged(self, provider: str, status: int, extras: Any): + pass + + def onProviderEnabled(self, provider: str): + pass + + def onProviderDisabled(self, provider: str): + pass + + +# ═══════════════════════════════════════════════════════════════ +# GpsSatellite +# ═══════════════════════════════════════════════════════════════ + +class GpsSatellite(Stub): + """GpsSatellite — GPS 卫星信息""" + + def __init__(self): + super().__init__() + self._prn: int = 0 + self._snr: float = 0.0 + self._elevation: float = 0.0 + self._azimuth: float = 0.0 + self._has_almanac: bool = False + self._has_ephemeris: bool = False + self._used_in_fix: bool = False + + def getPrn(self) -> int: + return self._prn + + def getSnr(self) -> float: + return self._snr + + def getElevation(self) -> float: + return self._elevation + + def getAzimuth(self) -> float: + return self._azimuth + + def hasAlmanac(self) -> bool: + return self._has_almanac + + def hasEphemeris(self) -> bool: + return self._has_ephemeris + + def usedInFix(self) -> bool: + return self._used_in_fix + + def toString(self) -> str: + return f"GpsSatellite(prn={self._prn}, snr={self._snr})" + + +# ═══════════════════════════════════════════════════════════════ +# GpsStatus +# ═══════════════════════════════════════════════════════════════ + +class GpsStatus(Stub): + """GpsStatus — GPS 状态""" + + GPS_EVENT_STARTED = 1 + GPS_EVENT_STOPPED = 2 + GPS_EVENT_FIRST_FIX = 3 + GPS_EVENT_SATELLITE_STATUS = 4 + + def __init__(self): + super().__init__() + self._satellites: List[GpsSatellite] = [] + self._max_satellites: int = 32 + self._time_to_first_fix: int = 0 + + def getSatellites(self) -> List[GpsSatellite]: + return list(self._satellites) + + def getMaxSatellites(self) -> int: + return self._max_satellites + + def getTimeToFirstFix(self) -> int: + return self._time_to_first_fix + + def setTimeToFirstFix(self, ttf: int): + self._time_to_first_fix = ttf + + +class GpsStatusListener(Stub): + """GpsStatusListener — GPS 状态监听器""" + + def onGpsStatusChanged(self, event: int): + pass + + +# ═══════════════════════════════════════════════════════════════ +# GnssClock / GnssMeasurement / GnssMeasurementsEvent / GnssNavigationMessage +# ═══════════════════════════════════════════════════════════════ + +class GnssClock(Stub): + """GnssClock — GNSS 时钟""" + + def __init__(self): + super().__init__() + self._time_nanos: int = 0 + self._time_uncertainty_nanos: float = 0.0 + self._leap_second: int = 0 + self._full_bias_nanos: int = 0 + self._bias_nanos: float = 0.0 + self._bias_uncertainty_nanos: float = 0.0 + self._drift_nanos_per_sec: float = 0.0 + self._drift_uncertainty_nanos_per_sec: float = 0.0 + self._hardware_clock_discontinuity_count: int = 0 + self._has_leap_second: bool = False + self._has_full_bias_nanos: bool = False + self._has_bias_nanos: bool = False + self._has_bias_uncertainty_nanos: bool = False + self._has_drift_nanos_per_sec: bool = False + self._has_drift_uncertainty_nanos_per_sec: bool = False + + def getTimeNanos(self) -> int: + return self._time_nanos + + def getTimeUncertaintyNanos(self) -> float: + return self._time_uncertainty_nanos + + def getLeapSecond(self) -> int: + return self._leap_second + + def getFullBiasNanos(self) -> int: + return self._full_bias_nanos + + def getBiasNanos(self) -> float: + return self._bias_nanos + + def getBiasUncertaintyNanos(self) -> float: + return self._bias_uncertainty_nanos + + def getDriftNanosPerSec(self) -> float: + return self._drift_nanos_per_sec + + def getDriftUncertaintyNanosPerSec(self) -> float: + return self._drift_uncertainty_nanos_per_sec + + def getHardwareClockDiscontinuityCount(self) -> int: + return self._hardware_clock_discontinuity_count + + +class GnssMeasurement(Stub): + """GnssMeasurement — GNSS 测量值""" + + STATE_UNKNOWN = 0 + STATE_CODE_LOCK = 1 + STATE_BIT_SYNC = 2 + STATE_SUBFRAME_SYNC = 3 + STATE_TOW_DECODED = 4 + STATE_MSEC_AMBIGUOUS = 5 + + def __init__(self): + super().__init__() + self._svid: int = 0 + self._constellation_type: int = 0 + self._time_offset_nanos: float = 0.0 + self._state: int = 0 + self._received_gps_tow_nanos: int = 0 + self._received_gps_tow_uncertainty_nanos: int = 0 + self._carrier_frequency_hz: float = 0.0 + self._carrier_phase: float = 0.0 + self._carrier_phase_uncertainty: float = 0.0 + self._multipath_indicator: int = 0 + self._snr_in_db: float = 0.0 + self._constellation_type_val: int = 0 + + def getSvid(self) -> int: + return self._svid + + def getConstellationType(self) -> int: + return self._constellation_type + + def getTimeOffsetNanos(self) -> float: + return self._time_offset_nanos + + def getState(self) -> int: + return self._state + + def getReceivedGpsTowNanos(self) -> int: + return self._received_gps_tow_nanos + + def getReceivedGpsTowUncertaintyNanos(self) -> int: + return self._received_gps_tow_uncertainty_nanos + + def getCarrierFrequencyHz(self) -> float: + return self._carrier_frequency_hz + + def getCarrierPhase(self) -> float: + return self._carrier_phase + + def getCarrierPhaseUncertainty(self) -> float: + return self._carrier_phase_uncertainty + + def getMultipathIndicator(self) -> int: + return self._multipath_indicator + + def getSnrInDb(self) -> float: + return self._snr_in_db + + +class GnssMeasurementsEvent(Stub): + """GnssMeasurementsEvent — GNSS 测量事件""" + + def __init__(self, clock: Optional[GnssClock] = None, + measurements: Optional[List[GnssMeasurement]] = None): + super().__init__() + self._clock = clock or GnssClock() + self._measurements = measurements or [] + + def getClock(self) -> GnssClock: + return self._clock + + def getMeasurements(self) -> List[GnssMeasurement]: + return list(self._measurements) + + +class GnssNavigationMessage(Stub): + """GnssNavigationMessage — GNSS 导航消息""" + + STATUS_PARITY_PASSED = 1 + STATUS_PARITY_REBUILT = 2 + TYPE_GPS_L1CA = 256 + TYPE_GPS_L2CA = 512 + TYPE_GPS_L5 = 768 + TYPE_GLO_L1CA = 1024 + TYPE_GLO_L2CA = 1280 + TYPE_BDS_D1 = 1792 + TYPE_BDS_D2 = 2048 + TYPE_GAL_I = 2560 + TYPE_GAL_F = 2816 + TYPE_QZS_L1CA = 3072 + TYPE_QZS_L5 = 3328 + + def __init__(self): + super().__init__() + self._type: int = 0 + self._svid: int = 0 + self._message_id: int = 0 + self._submessage_id: int = 0 + self._data: bytes = b"" + self._status: int = 0 + + def getType(self) -> int: + return self._type + + def getSvid(self) -> int: + return self._svid + + def getMessageId(self) -> int: + return self._message_id + + def getSubmessageId(self) -> int: + return self._submessage_id + + def getData(self) -> bytes: + return self._data + + def getStatus(self) -> int: + return self._status + + +# ═══════════════════════════════════════════════════════════════ +# GnssStatus +# ═══════════════════════════════════════════════════════════════ + +class GnssStatus(Stub): + """GnssStatus — GNSS 卫星状态""" + + GNSS_CONSTELLATION_GPS = 1 + GNSS_CONSTELLATION_SBAS = 2 + GNSS_CONSTELLATION_GLONASS = 3 + CONSTELLATION_QZSS = 4 + CONSTELLATION_BEIDOU = 5 + CONSTELLATION_GALILEO = 6 + CONSTELLATION_IRNSS = 7 + + def __init__(self): + super().__init__() + self._satellites: List[Dict[str, Any]] = [] + + def getSatelliteCount(self) -> int: + return len(self._satellites) + + def getSvid(self, index: int) -> int: + if 0 <= index < len(self._satellites): + return self._satellites[index].get("svid", 0) + return 0 + + def getConstellationType(self, index: int) -> int: + if 0 <= index < len(self._satellites): + return self._satellites[index].get("constellation", 0) + return 0 + + def getCarrierFrequencyHz(self, index: int) -> float: + if 0 <= index < len(self._satellites): + return self._satellites[index].get("carrier_freq", 0.0) + return 0.0 + + def getBasebandCn0DbHz(self, index: int) -> float: + return 0.0 + + def getCn0DbHz(self, index: int) -> float: + if 0 <= index < len(self._satellites): + return self._satellites[index].get("cn0", 0.0) + return 0.0 + + def getAzimuthDegrees(self, index: int) -> float: + if 0 <= index < len(self._satellites): + return self._satellites[index].get("azimuth", 0.0) + return 0.0 + + def getElevationDegrees(self, index: int) -> float: + if 0 <= index < len(self._satellites): + return self._satellites[index].get("elevation", 0.0) + return 0.0 + + def hasAlmanac(self, index: int) -> bool: + if 0 <= index < len(self._satellites): + return self._satellites[index].get("has_almanac", False) + return False + + def hasEphemeris(self, index: int) -> bool: + if 0 <= index < len(self._satellites): + return self._satellites[index].get("has_ephemeris", False) + return False + + def usedInFix(self, index: int) -> bool: + if 0 <= index < len(self._satellites): + return self._satellites[index].get("used_in_fix", False) + return False + + +# ═══════════════════════════════════════════════════════════════ +# LocationRequest +# ═══════════════════════════════════════════════════════════════ + +class LocationRequest(Stub): + """LocationRequest — 位置请求""" + + QUALITY_HIGH_ACCURACY = 100 + QUALITY_BALANCED_POWER_ACCURACY = 102 + QUALITY_LOW_POWER = 104 + QUALITY_PASSIVE = 105 + + PRIORITY_HIGH_ACCURACY = 100 + PRIORITY_BALANCED_POWER_ACCURACY = 102 + PRIORITY_LOW_POWER = 104 + PRIORITY_NO_POWER = 105 + + def __init__(self): + super().__init__() + self._quality: int = self.QUALITY_BALANCED_POWER_ACCURACY + self._interval: int = 60000 + self._fastest_interval: int = 30000 + self._smallest_displacement: float = 0.0 + self._max_wait_time: int = 0 + self._duration_millis: int = 0 + self._max_updates: int = 0 # 0 means unlimited + self._priority: int = self.PRIORITY_BALANCED_POWER_ACCURACY + + def setQuality(self, quality: int): + self._quality = quality + + def getQuality(self) -> int: + return self._quality + + def setInterval(self, interval: int): + self._interval = interval + + def getInterval(self) -> int: + return self._interval + + def setFastestInterval(self, interval: int): + self._fastest_interval = interval + + def getFastestInterval(self) -> int: + return self._fastest_interval + + def setSmallestDisplacement(self, displacement: float): + self._smallest_displacement = displacement + + def getSmallestDisplacement(self) -> float: + return self._smallest_displacement + + def setMaxWaitTime(self, time: int): + self._max_wait_time = time + + def getMaxWaitTime(self) -> int: + return self._max_wait_time + + def setDurationMillis(self, duration: int): + self._duration_millis = duration + + def getDurationMillis(self) -> int: + return self._duration_millis + + def setMaxUpdates(self, updates: int): + self._max_updates = updates + + def getMaxUpdates(self) -> int: + return self._max_updates + + def setPriority(self, priority: int): + self._priority = priority + + def getPriority(self) -> int: + return self._priority + + def toString(self) -> str: + return f"LocationRequest(interval={self._interval}, priority={self._priority})" + + +# ═══════════════════════════════════════════════════════════════ +# LocationProviderProperties +# ═══════════════════════════════════════════════════════════════ + +class LocationProviderProperties(Stub): + """LocationProviderProperties — 提供者属性""" + + def __init__(self, requires_network: bool = False, + requires_satellite: bool = False, + requires_cell: bool = False, + has_monetary_cost: bool = False, + supports_altitude: bool = False, + supports_speed: bool = False, + supports_bearing: bool = False, + power_requirement: int = Criteria.NO_REQUIREMENT, + accuracy: int = Criteria.NO_REQUIREMENT): + super().__init__() + self.requiresNetwork = requires_network + self.requiresSatellite = requires_satellite + self.requiresCell = requires_cell + self.hasMonetaryCost = has_monetary_cost + self.supportsAltitude = supports_altitude + self.supportsSpeed = supports_speed + self.supportsBearing = supports_bearing + self.powerRequirement = power_requirement + self.accuracy = accuracy + + +# ═══════════════════════════════════════════════════════════════ +# SettingInjectorService +# ═══════════════════════════════════════════════════════════════ + +class SettingInjectorService(Stub): + """SettingInjectorService — 设置注入服务""" + + ACTION_INJECTED_SETTING = "android.location.InjectedSetting" + + def __init__(self, name: str = ""): + super().__init__() + self._name = name + + def onGetSummary(self) -> str: + return self._name + + def onGetEnabled(self) -> bool: + return True + + def toString(self) -> str: + return f"SettingInjectorService(name={self._name})" + + +# ═══════════════════════════════════════════════════════════════ +# Address +# ═══════════════════════════════════════════════════════════════ + +class Address(Stub): + """Address — 地理地址""" + + def __init__(self, locale: Any = None): + super().__init__() + self._address_lines: List[str] = [] + self._feature_name: str = "" + self._latitude: float = 0.0 + self._longitude: float = 0.0 + self._has_lat_lon: bool = False + self._admin_area: str = "" + self._sub_admin_area: str = "" + self._locality: str = "" + self._sub_locality: str = "" + self._premises: str = "" + self._thoroughfare: str = "" + self._sub_thoroughfare: str = "" + self._postal_code: str = "" + self._country_name: str = "" + self._country_code: str = "" + self._phone: str = "" + self._url: str = "" + self._extras: Optional[Dict[str, Any]] = None + + def getAddressLine(self, index: int) -> Optional[str]: + if 0 <= index < len(self._address_lines): + return self._address_lines[index] + return None + + def getMaxAddressLineIndex(self) -> int: + return max(0, len(self._address_lines) - 1) + + def getAdminArea(self) -> Optional[str]: + return self._admin_area or None + + def getSubAdminArea(self) -> Optional[str]: + return self._sub_admin_area or None + + def getLocality(self) -> Optional[str]: + return self._locality or None + + def getSubLocality(self) -> Optional[str]: + return self._sub_locality or None + + def getPremises(self) -> Optional[str]: + return self._premises or None + + def getThoroughfare(self) -> Optional[str]: + return self._thoroughfare or None + + def getSubThoroughfare(self) -> Optional[str]: + return self._sub_thoroughfare or None + + def getPostalCode(self) -> Optional[str]: + return self._postal_code or None + + def getCountryName(self) -> Optional[str]: + return self._country_name or None + + def getCountryCode(self) -> Optional[str]: + return self._country_code or None + + def getFeatureName(self) -> Optional[str]: + return self._feature_name or None + + def getLatitude(self) -> float: + return self._latitude + + def getLongitude(self) -> float: + return self._longitude + + def getPhone(self) -> Optional[str]: + return self._phone or None + + def getUrl(self) -> Optional[str]: + return self._url or None + + def setAddressLine(self, index: int, line: str): + while len(self._address_lines) <= index: + self._address_lines.append("") + self._address_lines[index] = line + + def setFeatureName(self, name: str): + self._feature_name = name + + def setLatitude(self, latitude: float): + self._latitude = latitude + self._has_lat_lon = True + + def setLongitude(self, longitude: float): + self._longitude = longitude + self._has_lat_lon = True + + def hasLatitude(self) -> bool: + return self._has_lat_lon + + def hasLongitude(self) -> bool: + return self._has_lat_lon + + def toString(self) -> str: + return f"Address(locality={self._locality}, country={self._country_name})" + + +# ═══════════════════════════════════════════════════════════════ +# Geocoder +# ═══════════════════════════════════════════════════════════════ + +class Geocoder(Stub): + """Geocoder — 地理编码/逆地理编码""" + + def __init__(self, context: Any = None, locale: Any = None): + super().__init__() + self._context = context + + def getFromLocation(self, latitude: float, longitude: float, + max_results: int = 1) -> List[Address]: + addr = Address() + addr.setLatitude(latitude) + addr.setLongitude(longitude) + addr.setFeatureName("Unknown Location") + addr.setLocality("Unknown") + addr.setCountryName("Unknown") + return [addr] if max_results > 0 else [] + + def getFromLocationName(self, location_name: str, max_results: int = 1, + lower_left_lat: Optional[float] = None, + lower_left_lon: Optional[float] = None, + upper_right_lat: Optional[float] = None, + upper_right_lon: Optional[float] = None) -> List[Address]: + addr = Address() + addr.setFeatureName(location_name) + addr.setLocality(location_name) + return [addr] if max_results > 0 else [] + + +# ═══════════════════════════════════════════════════════════════ +# LocationManager +# ═══════════════════════════════════════════════════════════════ + +class LocationManager(Stub): + """LocationManager — 位置管理器""" + + GPS_PROVIDER = "gps" + NETWORK_PROVIDER = "network" + PASSIVE_PROVIDER = "passive" + FUSED_PROVIDER = "fused" + + KEY_PROXIMITY_ENTERING = "entering" + KEY_PROXIMITY_DO_ENTER = "doEnter" + KEY_FLUSH_COMPLETE = "flushComplete" + KEY_LOCATION_CHANGED = "locationChanged" + KEY_PROXIMITY_ENTERING_DO_ENTER = "doEnter" + + PROVIDERS_CHANGED_ACTION = "android.location.PROVIDERS_CHANGED" + MODE_CHANGED_ACTION = "android.location.MODE_CHANGED" + + def __init__(self): + super().__init__() + self._listeners: Dict[str, List[LocationListener]] = {} + self._providers = { + self.GPS_PROVIDER: LocationProvider(self.GPS_PROVIDER), + self.NETWORK_PROVIDER: LocationProvider(self.NETWORK_PROVIDER), + self.PASSIVE_PROVIDER: LocationProvider(self.PASSIVE_PROVIDER), + self.FUSED_PROVIDER: LocationProvider(self.FUSED_PROVIDER), + } + self._last_known_locations: Dict[str, Location] = {} + self._enabled_providers = {self.GPS_PROVIDER, self.NETWORK_PROVIDER, + self.PASSIVE_PROVIDER, self.FUSED_PROVIDER} + + def getLastKnownLocation(self, provider: str) -> Optional[Location]: + if provider in self._last_known_locations: + return self._last_known_locations[provider] + loc = Location(provider) + loc.setLatitude(37.7749) + loc.setLongitude(-122.4194) + loc.setTime(int(datetime.now().timestamp() * 1000)) + loc.setAccuracy(20.0) + self._last_known_locations[provider] = loc + return loc + + def requestLocationUpdates(self, provider_or_request: Any, min_time: Any = None, + min_distance: float = 0.0, listener_or_callback: Any = None, + looper: Any = None) -> None: + if isinstance(provider_or_request, str): + provider = provider_or_request + else: + provider = self.GPS_PROVIDER + if listener_or_callback is not None: + if provider not in self._listeners: + self._listeners[provider] = [] + if isinstance(listener_or_callback, LocationListener): + self._listeners[provider].append(listener_or_callback) + + def removeUpdates(self, listener: Any): + for provider in list(self._listeners.keys()): + self._listeners[provider] = [ + l for l in self._listeners[provider] if l is not listener + ] + if not self._listeners[provider]: + del self._listeners[provider] + + def isProviderEnabled(self, provider: str) -> bool: + return provider in self._enabled_providers + + def getProviders(self, criteria: Optional[Criteria] = None, enabled_only: bool = False) -> List[str]: + providers = list(self._providers.keys()) + if enabled_only: + providers = [p for p in providers if p in self._enabled_providers] + return providers + + def getBestProvider(self, criteria: Criteria, enabled_only: bool = False) -> Optional[str]: + if criteria.getAccuracy() == Criteria.ACCURACY_FINE: + return self.GPS_PROVIDER + return self.NETWORK_PROVIDER + + def getAllProviders(self) -> List[str]: + return list(self._providers.keys()) + + def getProvider(self, name: str) -> Optional[LocationProvider]: + return self._providers.get(name) + + def addProximityAlert(self, latitude: float, longitude: float, + radius: float, expiration: int, intent: Any): + pass + + def sendExtraCommand(self, provider: str, command: str, extras: Any) -> bool: + return True + + def clearTestProviderLocation(self, provider: str): + pass + + def setTestProviderLocation(self, provider: str, location: Location): + pass + + def removeTestProvider(self, provider: str): + pass + + def addTestProvider(self, name: str, requires_network: bool, requires_satellite: bool, + requires_cell: bool, has_monetary_cost: bool, supports_altitude: bool, + supports_speed: bool, supports_bearing: bool, power_requirement: int, + accuracy: int): + self._providers[name] = LocationProvider(name) + + def toString(self) -> str: + return f"LocationManager(providers={list(self._providers.keys())})" + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "Location", + "LocationManager", + "LocationListener", + "LocationProvider", + "Criteria", + "Geocoder", + "Address", + "GpsStatus", + "GpsSatellite", + "GpsStatusListener", + "LocationRequest", + "LocationProviderProperties", + "SettingInjectorService", + "GnssStatus", + "GnssClock", + "GnssMeasurement", + "GnssMeasurementsEvent", + "GnssNavigationMessage", +] \ No newline at end of file diff --git a/android_pyapi/android/media.py b/android_pyapi/android/media.py new file mode 100644 index 0000000..102982f --- /dev/null +++ b/android_pyapi/android/media.py @@ -0,0 +1,2049 @@ +""" +Android Media 组件 — MediaPlayer, MediaRecorder, SoundPool, AudioManager 等 +方法签名完全对齐 Android SDK +""" + +import io +import math +import os +import time +import struct +from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union + +from .._core import Stub, AndroidOnlyError, android_context, HAS_PIL, HAS_PYMUPDF, resolve_android_path +from .graphics import PointF + + +# ═══════════════════════════════════════════════════════════════ +# AudioAttributes +# ═══════════════════════════════════════════════════════════════ + +class AudioAttributes(Stub): + """AudioAttributes — 音频属性""" + + CONTENT_TYPE_UNKNOWN = 0 + CONTENT_TYPE_SPEECH = 1 + CONTENT_TYPE_MUSIC = 2 + CONTENT_TYPE_MOVIE = 3 + CONTENT_TYPE_SONIFICATION = 4 + + USAGE_UNKNOWN = 0 + USAGE_MEDIA = 1 + USAGE_VOICE_COMMUNICATION = 2 + USAGE_VOICE_COMMUNICATION_SIGNALLING = 3 + USAGE_ALARM = 4 + USAGE_NOTIFICATION = 5 + USAGE_NOTIFICATION_RINGTONE = 6 + USAGE_GAME = 14 + USAGE_ASSISTANCE_ACCESSIBILITY = 11 + USAGE_ASSISTANCE_NAVIGATION_GUIDANCE = 12 + USAGE_ASSISTANCE_SONIFICATION = 13 + + FLAG_AUDIBILITY_ENFORCED = 1 + FLAG_SECURE = 2 + FLAG_SCO = 4 + FLAG_BEACON = 8 + FLAG_BYPASS_INTERRUPTION_POLICY = 16 + FLAG_BYPASS_MUTE = 32 + FLAG_LOW_LATENCY = 64 + FLAG_DEEP_BUFFER = 128 + + class Builder(Stub): + """AudioAttributes.Builder — 音频属性构建器""" + + def __init__(self): + super().__init__() + self._content_type = AudioAttributes.CONTENT_TYPE_UNKNOWN + self._usage = AudioAttributes.USAGE_UNKNOWN + self._flags = 0 + self._legacy_stream_type = -1 + + def setContentType(self, contentType: int) -> "AudioAttributes.Builder": + self._content_type = contentType + return self + + def setUsage(self, usage: int) -> "AudioAttributes.Builder": + self._usage = usage + return self + + def setFlags(self, flags: int) -> "AudioAttributes.Builder": + self._flags = flags + return self + + def setLegacyStreamType(self, streamType: int) -> "AudioAttributes.Builder": + self._legacy_stream_type = streamType + return self + + def build(self) -> "AudioAttributes": + attrs = AudioAttributes() + attrs._content_type = self._content_type + attrs._usage = self._usage + attrs._flags = self._flags + attrs._legacy_stream_type = self._legacy_stream_type + return attrs + + def __init__(self): + super().__init__() + self._content_type = AudioAttributes.CONTENT_TYPE_UNKNOWN + self._usage = AudioAttributes.USAGE_UNKNOWN + self._flags = 0 + self._legacy_stream_type = -1 + + def getContentType(self) -> int: + return self._content_type + + def getUsage(self) -> int: + return self._usage + + def getFlags(self) -> int: + return self._flags + + def getLegacyStreamType(self) -> int: + if self._legacy_stream_type >= 0: + return self._legacy_stream_type + usage_map = { + AudioAttributes.USAGE_MEDIA: 3, + AudioAttributes.USAGE_ALARM: 4, + AudioAttributes.USAGE_NOTIFICATION: 5, + AudioAttributes.USAGE_NOTIFICATION_RINGTONE: 2, + AudioAttributes.USAGE_VOICE_COMMUNICATION: 0, + AudioAttributes.USAGE_GAME: 3, + } + return usage_map.get(self._usage, 3) + + +# ═══════════════════════════════════════════════════════════════ +# AudioFormat +# ═══════════════════════════════════════════════════════════════ + +class AudioFormat(Stub): + """AudioFormat — 音频格式""" + + ENCODING_INVALID = 0 + ENCODING_DEFAULT = 1 + ENCODING_PCM_16BIT = 2 + ENCODING_PCM_8BIT = 3 + ENCODING_PCM_FLOAT = 4 + ENCODING_AC3 = 5 + ENCODING_E_AC3 = 6 + ENCODING_DTS = 7 + ENCODING_DTS_HD = 8 + ENCODING_MP3 = 9 + ENCODING_AAC = 10 + ENCODING_AAC_LC = 11 + ENCODING_AAC_HE_V1 = 12 + ENCODING_AAC_HE_V2 = 13 + ENCODING_AAC_ELD = 14 + ENCODING_AAC_XHE = 15 + ENCODING_AMRNB = 16 + ENCODING_AMRWB = 17 + ENCODING_OPUS = 18 + + CHANNEL_OUT_DEFAULT = 0x000 + CHANNEL_OUT_MONO = 0x004 + CHANNEL_OUT_STEREO = 0x00C + CHANNEL_OUT_QUAD = 0x01C + CHANNEL_OUT_SURROUND = 0x03C + CHANNEL_OUT_5POINT1 = 0x0FC + CHANNEL_OUT_7POINT1 = 0x3FC + + CHANNEL_IN_DEFAULT = 0x000 + CHANNEL_IN_MONO = 0x010 + CHANNEL_IN_STEREO = 0x020 + + def __init__(self): + super().__init__() + self._sample_rate = 44100 + self._encoding = AudioFormat.ENCODING_PCM_16BIT + self._channel_mask = AudioFormat.CHANNEL_OUT_STEREO + self._channel_count = 2 + + def getSampleRate(self) -> int: + return self._sample_rate + + def getEncoding(self) -> int: + return self._encoding + + def getChannelMask(self) -> int: + return self._channel_mask + + def getChannelCount(self) -> int: + return self._channel_count + + @staticmethod + def toChannelMask(channelCount: int) -> int: + return AudioFormat.CHANNEL_OUT_MONO if channelCount == 1 else AudioFormat.CHANNEL_OUT_STEREO + + +# ═══════════════════════════════════════════════════════════════ +# MediaPlayer +# ═══════════════════════════════════════════════════════════════ + +class MediaPlayer(Stub): + """MediaPlayer — 媒体播放器""" + + MEDIA_INFO_UNKNOWN = 1 + MEDIA_INFO_VIDEO_TRACK_LAGGING = 700 + MEDIA_INFO_VIDEO_RENDERING_START = 3 + MEDIA_INFO_BUFFERING_START = 701 + MEDIA_INFO_BUFFERING_END = 702 + MEDIA_INFO_BAD_INTERLEAVING = 800 + MEDIA_INFO_NOT_SEEKABLE = 801 + MEDIA_INFO_METADATA_UPDATE = 802 + MEDIA_INFO_AUDIO_NOT_PLAYING = 804 + MEDIA_INFO_VIDEO_NOT_PLAYING = 805 + MEDIA_INFO_SUBTITLE_TIMED_OUT = 902 + MEDIA_INFO_UNSUPPORTED_SUBTITLE = 901 + + MEDIA_ERROR_UNKNOWN = 1 + MEDIA_ERROR_SERVER_DIED = 100 + MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK = 200 + MEDIA_ERROR_TIMED_OUT = -110 + MEDIA_ERROR_IO = -1004 + MEDIA_ERROR_MALFORMED = -1007 + MEDIA_ERROR_UNSUPPORTED = -1010 + + # OnPreparedListener + class OnPreparedListener(Stub): + def onPrepared(self, mp: "MediaPlayer"): + pass + + # OnCompletionListener + class OnCompletionListener(Stub): + def onCompletion(self, mp: "MediaPlayer"): + pass + + # OnErrorListener + class OnErrorListener(Stub): + def onError(self, mp: "MediaPlayer", what: int, extra: int) -> bool: + return False + + # OnInfoListener + class OnInfoListener(Stub): + def onInfo(self, mp: "MediaPlayer", what: int, extra: int) -> bool: + return False + + # OnSeekCompleteListener + class OnSeekCompleteListener(Stub): + def onSeekComplete(self, mp: "MediaPlayer"): + pass + + # OnVideoSizeChangedListener + class OnVideoSizeChangedListener(Stub): + def onVideoSizeChanged(self, mp: "MediaPlayer", width: int, height: int): + pass + + def __init__(self): + super().__init__() + self._data_source = None + self._prepared = False + self._playing = False + self._looping = False + self._volume_left = 1.0 + self._volume_right = 1.0 + self._current_position = 0 + self._duration = 0 + self._video_width = 0 + self._video_height = 0 + self._screen_on = False + self._wake_mode = 0 + self._audio_attributes = None + self._display = None + self._surface = None + + # Listeners + self._on_prepared_listener = None + self._on_completion_listener = None + self._on_error_listener = None + self._on_info_listener = None + self._on_seek_complete_listener = None + self._on_video_size_changed_listener = None + + def setDataSource(self, path: str = None, uri=None, headers: Dict = None): + self._data_source = path or str(uri) + + def prepare(self): + self._prepared = True + + def prepareAsync(self): + self._prepared = True + if self._on_prepared_listener: + self._on_prepared_listener.onPrepared(self) + + def start(self): + self._playing = True + + def stop(self): + self._playing = False + + def pause(self): + self._playing = False + + def reset(self): + self._playing = False + self._prepared = False + self._current_position = 0 + + def release(self): + self._playing = False + self._prepared = False + + def seekTo(self, msec: int): + self._current_position = max(0, min(msec, self._duration)) + if self._on_seek_complete_listener: + self._on_seek_complete_listener.onSeekComplete(self) + + def getCurrentPosition(self) -> int: + return self._current_position + + def getDuration(self) -> int: + return self._duration + + def isPlaying(self) -> bool: + return self._playing + + def isLooping(self) -> bool: + return self._looping + + def setLooping(self, looping: bool): + self._looping = looping + + def setVolume(self, leftVolume: float, rightVolume: float): + self._volume_left = leftVolume + self._volume_right = rightVolume + + def getVolume(self) -> Tuple[float, float]: + return (self._volume_left, self._volume_right) + + def setScreenOnWhilePlaying(self, screenOn: bool): + self._screen_on = screenOn + + def setWakeMode(self, context, mode: int): + self._wake_mode = mode + + def setAudioAttributes(self, attributes: AudioAttributes): + self._audio_attributes = attributes + + def setDisplay(self, surface_holder): + self._display = surface_holder + + def getVideoWidth(self) -> int: + return self._video_width + + def getVideoHeight(self) -> int: + return self._video_height + + def setOnPreparedListener(self, listener: "MediaPlayer.OnPreparedListener"): + self._on_prepared_listener = listener + + def setOnCompletionListener(self, listener: "MediaPlayer.OnCompletionListener"): + self._on_completion_listener = listener + + def setOnErrorListener(self, listener: "MediaPlayer.OnErrorListener"): + self._on_error_listener = listener + + def setOnInfoListener(self, listener: "MediaPlayer.OnInfoListener"): + self._on_info_listener = listener + + def setOnSeekCompleteListener(self, listener: "MediaPlayer.OnSeekCompleteListener"): + self._on_seek_complete_listener = listener + + def setOnVideoSizeChangedListener(self, listener: "MediaPlayer.OnVideoSizeChangedListener"): + self._on_video_size_changed_listener = listener + + @staticmethod + def create(context, resid: int = 0) -> "MediaPlayer": + mp = MediaPlayer() + mp._prepared = True + return mp + + +# ═══════════════════════════════════════════════════════════════ +# MediaRecorder +# ═══════════════════════════════════════════════════════════════ + +class MediaRecorder(Stub): + """MediaRecorder — 媒体录制器""" + + class AudioSource: + DEFAULT = 0 + MIC = 1 + VOICE_UPLINK = 2 + VOICE_DOWNLINK = 3 + VOICE_CALL = 4 + CAMCORDER = 5 + VOICE_RECOGNITION = 6 + VOICE_COMMUNICATION = 7 + REMOTE_SUBMIX = 8 + UNPROCESSED = 9 + + class VideoSource: + DEFAULT = 0 + CAMERA = 1 + SURFACE = 2 + + class OutputFormat: + DEFAULT = 0 + THREE_GPP = 1 + MPEG_4 = 2 + AMR_NB = 3 + AMR_WB = 4 + AAC_ADIF = 5 + AAC_ADTS = 6 + OUTPUT_FORMAT_RTP_AVP = 7 + MPEG_2_TS = 8 + WEBM = 9 + HEIF = 10 + OGG = 11 + + class AudioEncoder: + DEFAULT = 0 + AMR_NB = 1 + AMR_WB = 2 + AAC = 3 + HE_AAC = 4 + AAC_ELD = 5 + VORBIS = 6 + OPUS = 7 + LPCM = 8 + + class VideoEncoder: + DEFAULT = 0 + H_263 = 1 + H_264 = 2 + MPEG_4_SP = 3 + VP8 = 4 + HEVC = 5 + VP9 = 6 + AV1 = 7 + + def __init__(self): + super().__init__() + self._audio_source = 0 + self._video_source = 0 + self._output_format = 0 + self._audio_encoder = 0 + self._video_encoder = 0 + self._output_file = None + self._preview_display = None + self._recording = False + + def setAudioSource(self, audio_source: int): + self._audio_source = audio_source + + def setVideoSource(self, video_source: int): + self._video_source = video_source + + def setOutputFormat(self, output_format: int): + self._output_format = output_format + + def setAudioEncoder(self, audio_encoder: int): + self._audio_encoder = audio_encoder + + def setVideoEncoder(self, video_encoder: int): + self._video_encoder = video_encoder + + def setOutputFile(self, path: str): + self._output_file = path + + def setPreviewDisplay(self, surface_holder): + self._preview_display = surface_holder + + def prepare(self): + pass + + def start(self): + self._recording = True + + def stop(self): + self._recording = False + + def reset(self): + self._recording = False + + def release(self): + self._recording = False + + def getMaxAmplitude(self) -> int: + return 0 + + +# ═══════════════════════════════════════════════════════════════ +# SoundPool +# ═══════════════════════════════════════════════════════════════ + +class SoundPool(Stub): + """SoundPool — 音效池""" + + def __init__(self, maxStreams: int = 1, streamType: int = 3, srcQuality: int = 0): + super().__init__() + self._max_streams = maxStreams + self._stream_type = streamType + self._src_quality = srcQuality + self._sounds: Dict[int, str] = {} + self._playing: Dict[int, float] = {} + self._on_load_complete_listener = None + self._next_id = 1 + + def load(self, path: str, priority: int = 1) -> int: + sound_id = self._next_id + self._next_id += 1 + self._sounds[sound_id] = path + if self._on_load_complete_listener: + self._on_load_complete_listener.onLoadComplete(self, sound_id, 0) + return sound_id + + def load(self, context, resId: int, priority: int) -> int: + return self.load(str(resId), priority) + + def play(self, soundID: int, leftVolume: float, rightVolume: float, + priority: int, loop: int, rate: float) -> int: + stream_id = self._next_id + self._next_id += 1 + self._playing[stream_id] = 0.0 + return stream_id + + def pause(self, streamID: int): + pass + + def resume(self, streamID: int): + pass + + def autoPause(self): + pass + + def autoResume(self): + pass + + def release(self): + self._sounds.clear() + self._playing.clear() + + def setVolume(self, streamID: int, leftVolume: float, rightVolume: float): + pass + + def setRate(self, streamID: int, rate: float): + pass + + def setPriority(self, streamID: int, priority: int): + pass + + def setLoop(self, streamID: int, loop: int): + pass + + def setOnLoadCompleteListener(self, listener): + self._on_load_complete_listener = listener + + +# ═══════════════════════════════════════════════════════════════ +# AudioManager +# ═══════════════════════════════════════════════════════════════ + +class AudioManager(Stub): + """AudioManager — 音频管理器""" + + MODE_NORMAL = 0 + MODE_RINGTONE = 1 + MODE_IN_CALL = 2 + MODE_IN_COMMUNICATION = 3 + + STREAM_VOICE_CALL = 0 + STREAM_SYSTEM = 1 + STREAM_RING = 2 + STREAM_MUSIC = 3 + STREAM_ALARM = 4 + STREAM_NOTIFICATION = 5 + STREAM_BLUETOOTH_SCO = 6 + STREAM_DTMF = 8 + STREAM_TTS = 9 + STREAM_ACCESSIBILITY = 10 + + ADJUST_RAISE = 1 + ADJUST_LOWER = -1 + ADJUST_SAME = 0 + ADJUST_MUTE = -100 + ADJUST_UNMUTE = 100 + ADJUST_TOGGLE_MUTE = 101 + + FLAG_PLAY_SOUND = 1 + FLAG_SHOW_UI = 2 + FLAG_REMOVE_SOUND_AND_VIBRATE = 4 + FLAG_ALLOW_RINGER_MODES = 8 + FLAG_VIBRATE = 16 + FLAG_BYPASS_INTERRUPTION_POLICY = 32 + FLAG_BYPASS_MUTE = 64 + FLAG_LOW_LATENCY = 128 + + RINGER_MODE_NORMAL = 2 + RINGER_MODE_SILENT = 0 + RINGER_MODE_VIBRATE = 1 + + def __init__(self): + super().__init__() + self._mode = AudioManager.MODE_NORMAL + self._ringer_mode = AudioManager.RINGER_MODE_NORMAL + self._speakerphone_on = False + self._bluetooth_sco_on = False + self._wired_headset_on = False + self._stream_volumes = { + AudioManager.STREAM_VOICE_CALL: 4, + AudioManager.STREAM_SYSTEM: 7, + AudioManager.STREAM_RING: 5, + AudioManager.STREAM_MUSIC: 10, + AudioManager.STREAM_ALARM: 7, + AudioManager.STREAM_NOTIFICATION: 5, + } + self._parameters: Dict[str, str] = {} + + def getStreamVolume(self, streamType: int) -> int: + return self._stream_volumes.get(streamType, 0) + + def getStreamMaxVolume(self, streamType: int) -> int: + return 15 + + def setStreamVolume(self, streamType: int, index: int, flags: int = 0): + if streamType in self._stream_volumes: + self._stream_volumes[streamType] = max(0, min(15, index)) + + def adjustVolume(self, direction: int, flags: int = 0): + pass + + def adjustStreamVolume(self, streamType: int, direction: int, flags: int = 0): + current = self.getStreamVolume(streamType) + if direction == AudioManager.ADJUST_RAISE: + self.setStreamVolume(streamType, current + 1) + elif direction == AudioManager.ADJUST_LOWER: + self.setStreamVolume(streamType, current - 1) + + def getMode(self) -> int: + return self._mode + + def setMode(self, mode: int): + self._mode = mode + + def setSpeakerphoneOn(self, on: bool): + self._speakerphone_on = on + + def isSpeakerphoneOn(self) -> bool: + return self._speakerphone_on + + def isWiredHeadsetOn(self) -> bool: + return self._wired_headset_on + + def isBluetoothScoOn(self) -> bool: + return self._bluetooth_sco_on + + def setBluetoothScoOn(self, on: bool): + self._bluetooth_sco_on = on + + def setRingerMode(self, ringerMode: int): + self._ringer_mode = ringerMode + + def getRingerMode(self) -> int: + return self._ringer_mode + + def loadSoundEffects(self): + pass + + def unloadSoundEffects(self): + pass + + def getParameters(self, keys: str) -> str: + return ",".join(f"{k}={v}" for k, v in self._parameters.items() if k in keys) + + def setParameters(self, keyValuePairs: str): + for pair in keyValuePairs.split(";"): + if "=" in pair: + k, v = pair.split("=", 1) + self._parameters[k.strip()] = v.strip() + + +# ═══════════════════════════════════════════════════════════════ +# AudioTrack +# ═══════════════════════════════════════════════════════════════ + +class AudioTrack(Stub): + """AudioTrack — 音频轨道""" + + STATE_UNINITIALIZED = 0 + STATE_INITIALIZED = 1 + STATE_NO_STATIC_DATA = 2 + MODE_STATIC = 0 + MODE_STREAM = 1 + WRITE_BLOCKING = -1 + WRITE_NON_BLOCKING = 0 + SUCCESS = 0 + ERROR = -1 + ERROR_BAD_VALUE = -2 + ERROR_INVALID_OPERATION = -3 + ERROR_DEAD_OBJECT = -6 + ERROR_WAS_BLOCKED = -8 + + PERFORMANCE_MODE_NONE = 0 + PERFORMANCE_MODE_LOW_LATENCY = 1 + PERFORMANCE_MODE_POWER_SAVING = 2 + + def __init__(self, streamType: int, sampleRateInHz: int, channelConfig: int, + audioFormat: int, bufferSizeInBytes: int, mode: int): + super().__init__() + self._state = AudioTrack.STATE_INITIALIZED + self._playing = False + self._sample_rate = sampleRateInHz + self._channel_config = channelConfig + self._audio_format = audioFormat + self._buffer_size = bufferSizeInBytes + self._mode = mode + self._stream_type = streamType + self._volume = 1.0 + self._playback_rate = sampleRateInHz + self._buffer = bytearray(bufferSizeInBytes) + + def play(self): + self._playing = True + + def pause(self): + self._playing = False + + def stop(self): + self._playing = False + + def flush(self): + pass + + def release(self): + self._state = AudioTrack.STATE_UNINITIALIZED + self._playing = False + + def write(self, audioData, offsetInBytes: int = 0, sizeInBytes: int = -1, + writeMode: int = WRITE_BLOCKING) -> int: + if sizeInBytes < 0: + sizeInBytes = len(audioData) - offsetInBytes + if self._buffer and offsetInBytes + sizeInBytes <= len(self._buffer): + self._buffer[offsetInBytes:offsetInBytes + sizeInBytes] = audioData[offsetInBytes:offsetInBytes + sizeInBytes] + return sizeInBytes + + def getPlayState(self) -> int: + return 3 if self._playing else 1 + + def getState(self) -> int: + return self._state + + def getSampleRate(self) -> int: + return self._sample_rate + + def getPlaybackRate(self) -> int: + return self._playback_rate + + def setPlaybackRate(self, sampleRateInHz: int): + self._playback_rate = sampleRateInHz + + def setVolume(self, volume: float): + self._volume = max(0.0, min(1.0, volume)) + + def getVolume(self) -> float: + return self._volume + + def getAudioFormat(self) -> int: + return self._audio_format + + def getChannelConfiguration(self) -> int: + return self._channel_config + + def getChannelCount(self) -> int: + return 2 if self._channel_config == AudioFormat.CHANNEL_OUT_STEREO else 1 + + def getNotificationMarkerPosition(self) -> int: + return 0 + + def setNotificationMarkerPosition(self, marker: int): + pass + + def getPositionNotificationPeriod(self) -> int: + return 0 + + def setPositionNotificationPeriod(self, period: int): + pass + + @staticmethod + def getMinBufferSize(sampleRateInHz: int, channelConfig: int, audioFormat: int) -> int: + return sampleRateInHz * 2 * 2 # Conservative estimate + + @staticmethod + def getNativeOutputSampleRate(streamType: int) -> int: + return 44100 + + @staticmethod + def getMaxVolume() -> float: + return 1.0 + + @staticmethod + def getMinVolume() -> float: + return 0.0 + + +# ═══════════════════════════════════════════════════════════════ +# AudioRecord +# ═══════════════════════════════════════════════════════════════ + +class AudioRecord(Stub): + """AudioRecord — 音频录制器""" + + STATE_UNINITIALIZED = 0 + STATE_INITIALIZED = 1 + SUCCESS = 0 + ERROR = -1 + ERROR_BAD_VALUE = -2 + ERROR_INVALID_OPERATION = -3 + ERROR_DEAD_OBJECT = -6 + + def __init__(self, audioSource: int, sampleRateInHz: int, channelConfig: int, + audioFormat: int, bufferSizeInBytes: int): + super().__init__() + self._state = AudioRecord.STATE_INITIALIZED + self._recording = False + self._audio_source = audioSource + self._sample_rate = sampleRateInHz + self._channel_config = channelConfig + self._audio_format = audioFormat + self._buffer_size = bufferSizeInBytes + self._buffer = bytearray(bufferSizeInBytes) + + def startRecording(self): + self._recording = True + + def stop(self): + self._recording = False + + def release(self): + self._state = AudioRecord.STATE_UNINITIALIZED + self._recording = False + + def read(self, audioData, offsetInBytes: int, sizeInBytes: int) -> int: + return min(sizeInBytes, len(audioData) - offsetInBytes) + + def getState(self) -> int: + return self._state + + def getSampleRate(self) -> int: + return self._sample_rate + + def getRecordingState(self) -> int: + return 3 if self._recording else 1 + + def getAudioFormat(self) -> int: + return self._audio_format + + def getChannelConfiguration(self) -> int: + return self._channel_config + + def getChannelCount(self) -> int: + return 2 if self._channel_config == AudioFormat.CHANNEL_IN_STEREO else 1 + + @staticmethod + def getMinBufferSize(sampleRateInHz: int, channelConfig: int, audioFormat: int) -> int: + return sampleRateInHz * 2 * 2 + + def getAudioSource(self) -> int: + return self._audio_source + + +# ═══════════════════════════════════════════════════════════════ +# Ringtone +# ═══════════════════════════════════════════════════════════════ + +class Ringtone(Stub): + """Ringtone — 铃声""" + + def __init__(self, context=None): + super().__init__() + self._title = "" + self._stream_type = AudioManager.STREAM_RING + self._playing = False + self._volume = 1.0 + + def setStreamType(self, streamType: int): + self._stream_type = streamType + + def getStreamType(self) -> int: + return self._stream_type + + def setTitle(self, title: str): + self._title = title + + def getTitle(self, context=None) -> str: + return self._title + + def play(self): + self._playing = True + + def stop(self): + self._playing = False + + def isPlaying(self) -> bool: + return self._playing + + def setVolume(self, volume: float): + self._volume = max(0.0, min(1.0, volume)) + + def getVolume(self) -> float: + return self._volume + + def getAudioAttributes(self) -> AudioAttributes: + attrs = AudioAttributes() + if self._stream_type == AudioManager.STREAM_RING: + attrs._usage = AudioAttributes.USAGE_NOTIFICATION_RINGTONE + elif self._stream_type == AudioManager.STREAM_ALARM: + attrs._usage = AudioAttributes.USAGE_ALARM + else: + attrs._usage = AudioAttributes.USAGE_NOTIFICATION + return attrs + + +# ═══════════════════════════════════════════════════════════════ +# RingtoneManager +# ═══════════════════════════════════════════════════════════════ + +class RingtoneManager(Stub): + """RingtoneManager — 铃声管理器""" + + TYPE_RINGTONE = 1 + TYPE_NOTIFICATION = 2 + TYPE_ALARM = 4 + TYPE_ALL = 7 + + ACTION_RINGTONE_PICKER = "android.intent.action.RINGTONE_PICKER" + EXTRA_RINGTONE_TYPE = "android.intent.extra.ringtone.TYPE" + EXTRA_RINGTONE_TITLE = "android.intent.extra.ringtone.TITLE" + EXTRA_RINGTONE_EXISTING_URI = "android.intent.extra.ringtone.EXISTING_URI" + EXTRA_RINGTONE_DEFAULT_URI = "android.intent.extra.ringtone.DEFAULT_URI" + EXTRA_RINGTONE_SHOW_DEFAULT = "android.intent.extra.ringtone.SHOW_DEFAULT" + EXTRA_RINGTONE_INCLUDE_DRM = "android.intent.extra.ringtone.INCLUDE_DRM" + EXTRA_RINGTONE_PICKED_URI = "android.intent.extra.ringtone.PICKED_URI" + + def __init__(self, context): + super().__init__() + self._context = context + self._type = RingtoneManager.TYPE_RINGTONE + self._cursor = [] + self._cursor_position = -1 + + def setType(self, type_: int): + self._type = type_ + + def getCursor(self): + return self._cursor + + def getRingtoneUri(self, position: int): + return None + + def getRingtonePosition(self, uri) -> int: + return 0 + + @staticmethod + def getRingtone(context, uri) -> Ringtone: + return Ringtone(context) + + @staticmethod + def getActualDefaultRingtoneUri(context, type_: int): + return None + + @staticmethod + def setActualDefaultRingtoneUri(context, type_: int, ringtoneUri): + pass + + @staticmethod + def getDefaultUri(type_: int): + return None + + @staticmethod + def getValidRingtoneUri(context): + return None + + @staticmethod + def inferStreamType(type_: int) -> int: + if type_ == RingtoneManager.TYPE_RINGTONE: + return AudioManager.STREAM_RING + elif type_ == RingtoneManager.TYPE_NOTIFICATION: + return AudioManager.STREAM_NOTIFICATION + elif type_ == RingtoneManager.TYPE_ALARM: + return AudioManager.STREAM_ALARM + return AudioManager.STREAM_RING + + +# ═══════════════════════════════════════════════════════════════ +# MediaMetadataRetriever +# ═══════════════════════════════════════════════════════════════ + +class MediaMetadataRetriever(Stub): + """MediaMetadataRetriever — 媒体元数据检索器""" + + METADATA_KEY_ALBUM = "album" + METADATA_KEY_ARTIST = "artist" + METADATA_KEY_TITLE = "title" + METADATA_KEY_DURATION = "duration" + METADATA_KEY_CD_TRACK_NUMBER = "cd_track_number" + METADATA_KEY_COMPOSER = "composer" + METADATA_KEY_DATE = "date" + METADATA_KEY_GENRE = "genre" + METADATA_KEY_MIMETYPE = "mimetype" + METADATA_KEY_NUM_TRACKS = "num_tracks" + METADATA_KEY_WRITER = "writer" + METADATA_KEY_YEAR = "year" + METADATA_KEY_VIDEO_WIDTH = "video_width" + METADATA_KEY_VIDEO_HEIGHT = "video_height" + METADATA_KEY_HAS_AUDIO = "has_audio" + METADATA_KEY_HAS_VIDEO = "has_video" + METADATA_KEY_BITRATE = "bitrate" + METADATA_KEY_LOCATION = "location" + + def __init__(self): + super().__init__() + self._metadata: Dict[str, str] = {} + + def setDataSource(self, path: str): + resolved = resolve_android_path(path) + if os.path.exists(resolved): + size = os.path.getsize(resolved) + self._metadata = { + MediaMetadataRetriever.METADATA_KEY_DURATION: "30000", + MediaMetadataRetriever.METADATA_KEY_TITLE: os.path.basename(resolved), + MediaMetadataRetriever.METADATA_KEY_MIMETYPE: "video/mp4", + MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH: "1920", + MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT: "1080", + MediaMetadataRetriever.METADATA_KEY_HAS_VIDEO: "yes", + MediaMetadataRetriever.METADATA_KEY_HAS_AUDIO: "yes", + MediaMetadataRetriever.METADATA_KEY_BITRATE: str(size * 8 // 30), + } + + def setDataSource(self, path: str, headers: Dict[str, str]): + self.setDataSource(path) + + def extractMetadata(self, keyCode: str) -> Optional[str]: + return self._metadata.get(keyCode) + + def getFrameAtTime(self, timeUs: int = -1, option: int = 0) -> Optional["Bitmap"]: + if HAS_PIL: + from PIL import Image + from .graphics import Bitmap + img = Image.new("RGB", (1920, 1080), (64, 64, 64)) + bm = Bitmap(1920, 1080, Bitmap.Config.ARGB_8888) + bm._image = img + return bm + return None + + def getScaledFrameAtTime(self, timeUs: int, option: int, width: int, height: int) -> Optional["Bitmap"]: + if HAS_PIL: + from PIL import Image + from .graphics import Bitmap + img = Image.new("RGB", (width, height), (64, 64, 64)) + bm = Bitmap(width, height, Bitmap.Config.ARGB_8888) + bm._image = img + return bm + return None + + def release(self): + self._metadata.clear() + + +# ═══════════════════════════════════════════════════════════════ +# MediaCodec +# ═══════════════════════════════════════════════════════════════ + +class MediaCodec(Stub): + """MediaCodec — 媒体编解码器""" + + BUFFER_FLAG_KEY_FRAME = 1 + BUFFER_FLAG_CODEC_CONFIG = 2 + BUFFER_FLAG_END_OF_STREAM = 4 + BUFFER_FLAG_PARTIAL_FRAME = 8 + BUFFER_FLAG_MUXER_DATA = 16 + + CONFIGURE_FLAG_ENCODE = 1 + CONFIGURE_FLAG_DECODE = 0 + + CRYPTO_MODE_UNENCRYPTED = 0 + CRYPTO_MODE_AES_CTR = 1 + CRYPTO_MODE_AES_WV = 2 + CRYPTO_MODE_AES_CBC = 3 + + INFO_TRY_AGAIN_LATER = -1 + INFO_OUTPUT_FORMAT_CHANGED = -2 + INFO_OUTPUT_BUFFERS_CHANGED = -3 + + MEDIA_CODEC_UNKNOWN = 0 + MEDIA_CODEC_DECODER = 1 + MEDIA_CODEC_ENCODER = 2 + + PARAMETER_KEY_SUSPEND = "suspend" + PARAMETER_KEY_VIDEO_BITRATE = "video-bitrate" + PARAMETER_KEY_REQUEST_SYNC_FRAME = "request-sync" + PARAMETER_KEY_DROP_BEFORE = "drop-before" + PARAMETER_KEY_DROP_AFTER = "drop-after" + PARAMETER_KEY_OFFSET_TIME = "offset-time" + PARAMETER_KEY_PRIORITY = "priority" + PARAMETER_KEY_OPERATING_RATE = "operating-rate" + PARAMETER_KEY_INTRA_REFRESH_PERIOD = "intra-refresh-period" + PARAMETER_KEY_LOW_LATENCY = "low-latency" + + def __init__(self, name: str): + super().__init__() + self._name = name + self._configured = False + self._started = False + self._format = MediaFormat() + + @staticmethod + def createDecoderByType(mimeType: str) -> "MediaCodec": + return MediaCodec(f"decoder.{mimeType}") + + @staticmethod + def createEncoderByType(mimeType: str) -> "MediaCodec": + return MediaCodec(f"encoder.{mimeType}") + + def configure(self, format: "MediaFormat", surface, crypto, flags: int): + self._format = format + self._configured = True + + def start(self): + self._started = True + + def stop(self): + self._started = False + + def flush(self): + pass + + def release(self): + self._started = False + self._configured = False + + def getInputBuffers(self) -> List[Any]: + return [bytearray(4096)] + + def getOutputBuffers(self) -> List[Any]: + return [bytearray(4096)] + + def dequeueInputBuffer(self, timeoutUs: int) -> int: + return 0 + + def queueInputBuffer(self, index: int, offset: int, size: int, + presentationTimeUs: int, flags: int): + pass + + def dequeueOutputBuffer(self, info: "MediaCodec.BufferInfo", timeoutUs: int) -> int: + return MediaCodec.INFO_TRY_AGAIN_LATER + + def releaseOutputBuffer(self, index: int, render: bool): + pass + + def getOutputFormat(self) -> "MediaFormat": + return self._format + + def getInputImage(self, index: int): + return None + + def getOutputImage(self, index: int): + return None + + def getName(self) -> str: + return self._name + + def getCodecInfo(self): + return None + + +# ═══════════════════════════════════════════════════════════════ +# MediaCodecBufferInfo (nested class reference) +# ═══════════════════════════════════════════════════════════════ + +class MediaCodecBufferInfo(Stub): + """MediaCodec.BufferInfo — 编解码器缓冲信息""" + + def __init__(self): + super().__init__() + self.offset = 0 + self.size = 0 + self.presentationTimeUs = 0 + self.flags = 0 + + def set(self, offset: int, size: int, presentationTimeUs: int, flags: int): + self.offset = offset + self.size = size + self.presentationTimeUs = presentationTimeUs + self.flags = flags + + def duplicate(self) -> "MediaCodecBufferInfo": + info = MediaCodecBufferInfo() + info.set(self.offset, self.size, self.presentationTimeUs, self.flags) + return info + + +# ═══════════════════════════════════════════════════════════════ +# MediaFormat +# ═══════════════════════════════════════════════════════════════ + +class MediaFormat(Stub): + """MediaFormat — 媒体格式""" + + KEY_MIME = "mime" + KEY_WIDTH = "width" + KEY_HEIGHT = "height" + KEY_FRAME_RATE = "frame-rate" + KEY_BIT_RATE = "bitrate" + KEY_COLOR_FORMAT = "color-format" + KEY_I_FRAME_INTERVAL = "i-frame-interval" + KEY_CHANNEL_COUNT = "channel-count" + KEY_SAMPLE_RATE = "sample-rate" + KEY_DURATION = "durationUs" + KEY_MAX_INPUT_SIZE = "max-input-size" + KEY_AAC_PROFILE = "aac-profile" + KEY_LEVEL = "level" + KEY_PROFILE = "profile" + KEY_LANGUAGE = "language" + KEY_IS_AUTOSELECT = "is-autoselect" + KEY_IS_DEFAULT = "is-default" + KEY_IS_FORCED_SUBTITLE = "is-forced-subtitle" + KEY_PIXEL_ASPECT_RATIO_WIDTH = "pixel-aspect-ratio-width" + KEY_PIXEL_ASPECT_RATIO_HEIGHT = "pixel-aspect-ratio-height" + KEY_SLICE_HEIGHT = "slice-height" + KEY_STRIDE = "stride" + KEY_TEMPORAL_LAYERING = "temporal-layering" + KEY_REPEAT_PREVIOUS_FRAME_AFTER = "repeat-previous-frame-after" + KEY_PRIORITY = "priority" + KEY_OPERATING_RATE = "operating-rate" + KEY_INTRA_REFRESH_PERIOD = "intra-refresh-period" + KEY_LATENCY = "latency" + KEY_MAX_B_FRAMES = "max-bframes" + KEY_HDR10_PLUS_INFO = "hdr10-plus-info" + + MIMETYPE_AUDIO_AAC = "audio/mp4a-latm" + MIMETYPE_AUDIO_AMR_NB = "audio/3gpp" + MIMETYPE_AUDIO_AMR_WB = "audio/amr-wb" + MIMETYPE_AUDIO_FLAC = "audio/flac" + MIMETYPE_AUDIO_MPEG = "audio/mpeg" + MIMETYPE_AUDIO_OPUS = "audio/opus" + MIMETYPE_AUDIO_RAW = "audio/raw" + MIMETYPE_AUDIO_VORBIS = "audio/vorbis" + MIMETYPE_VIDEO_AV1 = "video/av01" + MIMETYPE_VIDEO_AVC = "video/avc" + MIMETYPE_VIDEO_DOLBY_VISION = "video/dolby-vision" + MIMETYPE_VIDEO_H263 = "video/3gpp" + MIMETYPE_VIDEO_HEVC = "video/hevc" + MIMETYPE_VIDEO_MPEG2 = "video/mpeg2" + MIMETYPE_VIDEO_MPEG4 = "video/mp4v-es" + MIMETYPE_VIDEO_VP8 = "video/x-vnd.on2.vp8" + MIMETYPE_VIDEO_VP9 = "video/x-vnd.on2.vp9" + MIMETYPE_VIDEO_RAW = "video/raw" + MIMETYPE_TEXT_CEA_608 = "text/cea-608" + MIMETYPE_TEXT_CEA_708 = "text/cea-708" + MIMETYPE_TEXT_VTT = "text/vtt" + MIMETYPE_IMAGE_ANDROID_HEIC = "image/vnd.android.heic" + + def __init__(self): + super().__init__() + self._properties: Dict[str, Any] = {} + + def setString(self, key: str, value: str): + self._properties[key] = value + + def setInteger(self, key: str, value: int): + self._properties[key] = value + + def setFloat(self, key: str, value: float): + self._properties[key] = value + + def setByteBuffer(self, key: str, buf): + self._properties[key] = buf + + def setFeatureEnabled(self, feature: str, enabled: bool): + self._properties[feature] = enabled + + def getString(self, key: str) -> Optional[str]: + v = self._properties.get(key) + return str(v) if v is not None else None + + def getInteger(self, key: str, defaultValue: int = 0) -> int: + v = self._properties.get(key) + return int(v) if v is not None else defaultValue + + def getFloat(self, key: str, defaultValue: float = 0.0) -> float: + v = self._properties.get(key) + return float(v) if v is not None else defaultValue + + def getByteBuffer(self, key: str): + return self._properties.get(key) + + def containsKey(self, key: str) -> bool: + return key in self._properties + + def keys(self) -> List[str]: + return list(self._properties.keys()) + + @staticmethod + def createVideoFormat(mime: str, width: int, height: int) -> "MediaFormat": + fmt = MediaFormat() + fmt.setString(MediaFormat.KEY_MIME, mime) + fmt.setInteger(MediaFormat.KEY_WIDTH, width) + fmt.setInteger(MediaFormat.KEY_HEIGHT, height) + return fmt + + @staticmethod + def createAudioFormat(mime: str, sampleRate: int, channelCount: int) -> "MediaFormat": + fmt = MediaFormat() + fmt.setString(MediaFormat.KEY_MIME, mime) + fmt.setInteger(MediaFormat.KEY_SAMPLE_RATE, sampleRate) + fmt.setInteger(MediaFormat.KEY_CHANNEL_COUNT, channelCount) + return fmt + + @staticmethod + def createSubtitleFormat(mime: str, language: str) -> "MediaFormat": + fmt = MediaFormat() + fmt.setString(MediaFormat.KEY_MIME, mime) + fmt.setString(MediaFormat.KEY_LANGUAGE, language) + return fmt + + +# ═══════════════════════════════════════════════════════════════ +# MediaMuxer +# ═══════════════════════════════════════════════════════════════ + +class MediaMuxer(Stub): + """MediaMuxer — 媒体混合器""" + + OUTPUT_FORMAT_MPEG_4 = 0 + OUTPUT_FORMAT_WEBM = 1 + OUTPUT_FORMAT_THREE_GPP = 2 + OUTPUT_FORMAT_HEIF = 3 + OUTPUT_FORMAT_OGG = 4 + + def __init__(self, path: str, format: int): + super().__init__() + self._path = path + self._format = format + self._started = False + self._tracks: Dict[int, MediaFormat] = {} + self._next_track = 0 + + def addTrack(self, format: MediaFormat) -> int: + idx = self._next_track + self._next_track += 1 + self._tracks[idx] = format + return idx + + def start(self): + self._started = True + + def stop(self): + self._started = False + + def release(self): + self._started = False + self._tracks.clear() + + def writeSampleData(self, trackIndex: int, byteBuf, bufferInfo: MediaCodecBufferInfo): + pass + + def setOrientationHint(self, degrees: int): + pass + + def setLocation(self, latitude: float, longitude: float): + pass + + def getTrackFormat(self, index: int) -> Optional[MediaFormat]: + return self._tracks.get(index) + + +# ═══════════════════════════════════════════════════════════════ +# MediaExtractor +# ═══════════════════════════════════════════════════════════════ + +class MediaExtractor(Stub): + """MediaExtractor — 媒体提取器""" + + SEEK_TO_NEXT_SYNC = 0 + SEEK_TO_PREVIOUS_SYNC = 1 + SEEK_TO_CLOSEST_SYNC = 2 + SEEK_TO_CLOSEST_SYNC = 2 + SAMPLE_FLAG_SYNC = 1 + SAMPLE_FLAG_ENCRYPTED = 2 + + def __init__(self): + super().__init__() + self._tracks: List[MediaFormat] = [] + self._selected_tracks: Set[int] = set() + self._current_track = 0 + + def setDataSource(self, path: str): + pass + + def setDataSource(self, context, uri, headers: Dict[str, str] = None): + pass + + def getTrackCount(self) -> int: + return len(self._tracks) + + def getTrackFormat(self, index: int) -> Optional[MediaFormat]: + if 0 <= index < len(self._tracks): + return self._tracks[index] + return None + + def selectTrack(self, index: int): + self._selected_tracks.add(index) + + def unselectTrack(self, index: int): + self._selected_tracks.discard(index) + + def readSampleData(self, byteBuf, offset: int) -> int: + return 0 + + def getSampleTrackIndex(self) -> int: + return 0 + + def getSampleTime(self) -> int: + return 0 + + def advance(self) -> bool: + return False + + def release(self): + self._tracks.clear() + self._selected_tracks.clear() + + def seekTo(self, timeUs: int, mode: int): + pass + + def getSampleFlags(self) -> int: + return 0 + + def getCachedDuration(self) -> int: + return 0 + + def hasCachedReachedEndOfStream(self) -> bool: + return False + + def getSampleSize(self) -> int: + return 0 + + +# ═══════════════════════════════════════════════════════════════ +# FaceDetector / FaceDetectorFace +# ═══════════════════════════════════════════════════════════════ + +class FaceDetectorFace(Stub): + """FaceDetector.Face — 检测到的人脸""" + + CONFIDENCE_THRESHOLD = 0.4 + EULER_X = 0 + EULER_Y = 1 + EULER_Z = 2 + + def __init__(self): + super().__init__() + self._confidence = 0.0 + self._mid_point_x = 0.0 + self._mid_point_y = 0.0 + self._eyes_distance = 0.0 + self._pose_euler_x = 0.0 + self._pose_euler_y = 0.0 + self._pose_euler_z = 0.0 + + def confidence(self) -> float: + return self._confidence + + def getMidPoint(self, point: PointF): + point.set(self._mid_point_x, self._mid_point_y) + + def eyesDistance(self) -> float: + return self._eyes_distance + + def pose(self, euler: int) -> float: + if euler == FaceDetectorFace.EULER_X: + return self._pose_euler_x + elif euler == FaceDetectorFace.EULER_Y: + return self._pose_euler_y + elif euler == FaceDetectorFace.EULER_Z: + return self._pose_euler_z + return 0.0 + + +class FaceDetector(Stub): + """FaceDetector — 人脸检测器""" + + def __init__(self, width: int, height: int, maxFaces: int): + super().__init__() + self._width = width + self._height = height + self._max_faces = maxFaces + + def findFaces(self, bitmap: "Bitmap", faces: List[FaceDetectorFace]) -> int: + return 0 + + +# ═══════════════════════════════════════════════════════════════ +# ThumbnailUtils +# ═══════════════════════════════════════════════════════════════ + +class ThumbnailUtils(Stub): + """ThumbnailUtils — 缩略图工具""" + + OPTIONS_RECYCLE_INPUT = 256 + + @staticmethod + def createVideoThumbnail(filePath: str, kind: int) -> Optional["Bitmap"]: + if HAS_PIL: + from PIL import Image + from .graphics import Bitmap + img = Image.new("RGB", (320, 240), (32, 32, 32)) + bm = Bitmap(320, 240, Bitmap.Config.ARGB_8888) + bm._image = img + return bm + return None + + @staticmethod + def createImageThumbnail(filePath: str, kind: int) -> Optional["Bitmap"]: + resolved = resolve_android_path(filePath) + if not os.path.exists(resolved): + return None + if HAS_PIL: + from PIL import Image + from .graphics import Bitmap + img = Image.open(resolved) + img.thumbnail((320, 240), Image.LANCZOS) + bm = Bitmap(img.width, img.height, Bitmap.Config.ARGB_8888) + if img.mode != "RGBA": + img = img.convert("RGBA") + bm._image = img + return bm + return None + + @staticmethod + def extractThumbnail(source: "Bitmap", width: int, height: int, + options: int = 0) -> Optional["Bitmap"]: + if HAS_PIL and hasattr(source, "_image") and source._image: + from PIL import Image + img = source._image.copy() + img.thumbnail((width, height), Image.LANCZOS) + bm = Bitmap(img.width, img.height, source._config) + bm._image = img + if options & ThumbnailUtils.OPTIONS_RECYCLE_INPUT: + source.recycle() + return bm + return Bitmap.createScaledBitmap(source, width, height) + + +# ═══════════════════════════════════════════════════════════════ +# MediaScannerConnection / MediaScannerConnectionClient +# ═══════════════════════════════════════════════════════════════ + +class MediaScannerConnectionClient(Stub): + """MediaScannerConnection.MediaScannerConnectionClient — 扫描客户端接口""" + + def onMediaScannerConnected(self): + pass + + def onScanCompleted(self, path: str, uri): + pass + + +class MediaScannerConnection(Stub): + """MediaScannerConnection — 媒体扫描连接""" + + def __init__(self, context, client: MediaScannerConnectionClient = None): + super().__init__() + self._client = client + self._connected = False + + def connect(self): + self._connected = True + if self._client: + self._client.onMediaScannerConnected() + + def disconnect(self): + self._connected = False + + def isConnected(self) -> bool: + return self._connected + + def scanFile(self, path: str, mimeType: str): + if self._client: + self._client.onScanCompleted(path, None) + + @staticmethod + def scanFile(context, paths: List[str], mimeTypes: List[str], + callback: MediaScannerConnectionClient): + for path in paths: + if callback: + callback.onScanCompleted(path, None) + + +# ═══════════════════════════════════════════════════════════════ +# MediaActionSound +# ═══════════════════════════════════════════════════════════════ + +class MediaActionSound(Stub): + """MediaActionSound — 媒体操作音效""" + + SHUTTER_CLICK = 0 + FOCUS_COMPLETE = 1 + START_VIDEO_RECORDING = 2 + STOP_VIDEO_RECORDING = 3 + + def __init__(self): + super().__init__() + + def play(self, soundName: int): + pass + + def load(self, soundName: int): + pass + + def release(self): + pass + + +# ═══════════════════════════════════════════════════════════════ +# ToneGenerator +# ═══════════════════════════════════════════════════════════════ + +class ToneGenerator(Stub): + """ToneGenerator — 音调发生器""" + + TONE_DTMF_0 = 0 + TONE_DTMF_1 = 1 + TONE_DTMF_2 = 2 + TONE_DTMF_3 = 3 + TONE_DTMF_4 = 4 + TONE_DTMF_5 = 5 + TONE_DTMF_6 = 6 + TONE_DTMF_7 = 7 + TONE_DTMF_8 = 8 + TONE_DTMF_9 = 9 + TONE_DTMF_S = 10 + TONE_DTMF_P = 11 + TONE_DTMF_A = 12 + TONE_DTMF_B = 13 + TONE_DTMF_C = 14 + TONE_DTMF_D = 15 + TONE_SUP_CALL_WAITING = 16 + TONE_SUP_RINGTONE = 17 + TONE_PROP_BEEP = 24 + TONE_PROP_ACK = 25 + TONE_PROP_NACK = 26 + TONE_PROP_PROMPT = 27 + TONE_PROP_BEEP2 = 28 + TONE_SUP_INTERCEPT = 29 + TONE_SUP_INTERCEPT_ABBREV = 30 + TONE_SUP_CONGESTION = 31 + TONE_SUP_CONGESTION_ABBREV = 32 + TONE_SUP_CONFIRM = 33 + TONE_SUP_RADIO_ACK = 34 + TONE_SUP_RADIO_NOTAVAIL = 35 + TONE_SUP_ERROR = 36 + TONE_SUP_CALL_WAITING = 37 + TONE_SUP_RINGTONE = 38 + TONE_PROP_BEEP = 39 + TONE_PROP_ACK = 40 + TONE_PROP_NACK = 41 + TONE_PROP_PROMPT = 42 + TONE_PROP_BEEP2 = 43 + TONE_SUP_INTERCEPT = 44 + TONE_PROP_END_EMERGENCY = 45 + TONE_CDMA_PRESSHOLDKEY_LITE = 46 + TONE_CDMA_ALERT_SIGNAL_RELEASE = 47 + TONE_CDMA_NETWORK_USA_RINGBACK = 48 + TONE_CDMA_INTERCEPT = 49 + TONE_CDMA_ABBR_INTERCEPT = 50 + TONE_CDMA_REORDER = 51 + TONE_CDMA_ABBR_REORDER = 52 + TONE_CDMA_NETWORK_BUSY = 53 + TONE_CDMA_CONFIRM = 54 + TONE_CDMA_ANSWER = 55 + TONE_CDMA_NETWORK_CALLWAITING = 56 + TONE_CDMA_PRESSHOLDKEY_LITE = 57 + TONE_CDMA_ONE_MIN_BEEP = 58 + TONE_CDMA_SIGNAL_OFF = 59 + TONE_CDMA_SIGNAL_ON = 60 + TONE_CDMA_HIGH_LITE = 61 + TONE_CDMA_MED_LITE = 62 + TONE_CDMA_LOW_LITE = 63 + TONE_CDMA_LOW_PBX_LITE = 64 + TONE_CDMA_HIGH_PBX_LITE = 65 + TONE_CDMA_MED_PBX_LITE = 66 + TONE_CDMA_PBX_OFF = 67 + TONE_CDMA_PBX_ON = 68 + TONE_CDMA_ALERT_CALL_GUARD = 69 + TONE_CDMA_SOFT_ERROR_LITE = 70 + TONE_CDMA_ABBR_ALERT = 71 + TONE_CDMA_NETWORK_BUSY_ONE_SHOT = 72 + TONE_CDMA_NETWORK_BUSY = 73 + TONE_CDMA_NETWORK_BUSY_ONE_SHOT = 74 + TONE_CDMA_ABBR_ALERT = 75 + TONE_CDMA_SOFT_ERROR_LITE = 76 + TONE_CDMA_ALERT_CALL_GUARD = 77 + TONE_CDMA_LOW_PBX_LITE = 78 + TONE_CDMA_MED_PBX_LITE = 79 + TONE_CDMA_HIGH_PBX_LITE = 80 + TONE_CDMA_PBX_OFF = 81 + TONE_CDMA_PBX_ON = 82 + TONE_CDMA_PRESSHOLDKEY_LITE = 83 + TONE_CDMA_ONE_MIN_BEEP = 84 + TONE_CDMA_SIGNAL_OFF = 85 + TONE_CDMA_SIGNAL_ON = 86 + TONE_CDMA_HIGH_LITE = 87 + TONE_CDMA_MED_LITE = 88 + TONE_CDMA_LOW_LITE = 89 + TONE_CDMA_ALERT_AUTO_REDIAL = 90 + TONE_CDMA_ALERT_CALL_GUARD = 91 + TONE_PROP_BEEP = 92 + TONE_PROP_ACK = 93 + TONE_PROP_NACK = 94 + TONE_PROP_PROMPT = 95 + TONE_PROP_BEEP2 = 96 + TONE_SUP_INTERCEPT = 97 + TONE_SUP_INTERCEPT_ABBREV = 98 + TONE_SUP_CONGESTION = 99 + TONE_SUP_CONGESTION_ABBREV = 100 + TONE_SUP_CONFIRM = 101 + TONE_SUP_RADIO_ACK = 102 + TONE_SUP_RADIO_NOTAVAIL = 103 + TONE_SUP_ERROR = 104 + TONE_SUP_CALL_WAITING = 105 + TONE_SUP_RINGTONE = 106 + + MIN_VOLUME = 0 + MAX_VOLUME = 100 + + def __init__(self, streamType: int, volume: int): + super().__init__() + self._stream_type = streamType + self._volume = max(0, min(100, volume)) + + def startTone(self, toneType: int, durationMs: int = -1): + pass + + def stopTone(self): + pass + + def release(self): + pass + + def getAudioSessionId(self) -> int: + return 0 + + +# ═══════════════════════════════════════════════════════════════ +# ExifInterface +# ═══════════════════════════════════════════════════════════════ + +class ExifInterface(Stub): + """ExifInterface — EXIF 接口""" + + TAG_APERTURE = "FNumber" + TAG_DATETIME = "DateTime" + TAG_EXPOSURE_TIME = "ExposureTime" + TAG_FLASH = "Flash" + TAG_FOCAL_LENGTH = "FocalLength" + TAG_GPS_ALTITUDE = "GPSAltitude" + TAG_GPS_ALTITUDE_REF = "GPSAltitudeRef" + TAG_GPS_DATESTAMP = "GPSDateStamp" + TAG_GPS_LATITUDE = "GPSLatitude" + TAG_GPS_LATITUDE_REF = "GPSLatitudeRef" + TAG_GPS_LONGITUDE = "GPSLongitude" + TAG_GPS_LONGITUDE_REF = "GPSLongitudeRef" + TAG_GPS_PROCESSING_METHOD = "GPSProcessingMethod" + TAG_GPS_TIMESTAMP = "GPSTimeStamp" + TAG_IMAGE_LENGTH = "ImageLength" + TAG_IMAGE_WIDTH = "ImageWidth" + TAG_ISO = "ISOSpeedRatings" + TAG_MAKE = "Make" + TAG_MODEL = "Model" + TAG_ORIENTATION = "Orientation" + TAG_WHITE_BALANCE = "WhiteBalance" + + ORIENTATION_NORMAL = 1 + ORIENTATION_ROTATE_90 = 6 + ORIENTATION_ROTATE_180 = 3 + ORIENTATION_ROTATE_270 = 8 + ORIENTATION_FLIP_HORIZONTAL = 2 + ORIENTATION_FLIP_VERTICAL = 4 + ORIENTATION_TRANSPOSE = 5 + ORIENTATION_TRANSVERSE = 7 + ORIENTATION_UNDEFINED = 0 + + WHITEBALANCE_AUTO = 0 + WHITEBALANCE_MANUAL = 1 + + FLAG_NO_FLASH = 0 + FLAG_FIRED = 1 + FLAG_STROBE_RETURN_LIGHT_DETECTED = 2 + FLAG_STROBE_RETURN_LIGHT_NOT_DETECTED = 4 + FLAG_COMPULSORY_FIRE = 8 + FLAG_COMPULSORY_SUPPRESSION = 16 + FLAG_AUTO_MODE = 24 + FLAG_AUTO_MODE_RED_EYE = 25 + FLAG_NO_STROBE_FUNCTION = 32 + FLAG_RED_EYE_SUPPORT = 64 + + def __init__(self, filename: str): + super().__init__() + self._filename = resolve_android_path(filename) + self._attributes: Dict[str, str] = {} + self._load_exif() + + def _load_exif(self): + """尝试从文件中读取 EXIF 数据""" + if not self._filename or not os.path.exists(self._filename): + return + if HAS_PIL: + from PIL import Image + from PIL import ExifTags + try: + img = Image.open(self._filename) + exif_data = img._getexif() + if exif_data: + for tag_id, value in exif_data.items(): + tag_name = ExifTags.TAGS.get(tag_id, str(tag_id)) + self._attributes[str(tag_name)] = str(value) + except Exception: + self._attributes[self.TAG_MAKE] = "Unknown" + self._attributes[self.TAG_MODEL] = "Android Device" + self._attributes[self.TAG_ORIENTATION] = str(self.ORIENTATION_NORMAL) + self._attributes[self.TAG_IMAGE_WIDTH] = "1920" + self._attributes[self.TAG_IMAGE_LENGTH] = "1080" + else: + self._attributes[self.TAG_MAKE] = "Unknown" + self._attributes[self.TAG_MODEL] = "Android Device" + self._attributes[self.TAG_ORIENTATION] = str(self.ORIENTATION_NORMAL) + + def getAttribute(self, tag: str) -> Optional[str]: + return self._attributes.get(tag) + + def getAttributeInt(self, tag: str, defaultValue: int) -> int: + v = self._attributes.get(tag) + if v is not None: + try: + return int(v) + except (ValueError, TypeError): + return defaultValue + return defaultValue + + def getAttributeDouble(self, tag: str, defaultValue: float) -> float: + v = self._attributes.get(tag) + if v is not None: + try: + # Handle rational strings like "1/100" + if "/" in str(v): + num, den = str(v).split("/") + return float(num) / float(den) + return float(v) + except (ValueError, TypeError, ZeroDivisionError): + return defaultValue + return defaultValue + + def setAttribute(self, tag: str, value: str): + self._attributes[tag] = value + + def saveAttributes(self): + if not self._filename or not HAS_PIL: + return + from PIL import Image + try: + img = Image.open(self._filename) + exif_bytes = img.info.get("exif", b"") + img.save(self._filename, exif=exif_bytes) + except Exception: + pass + + def hasThumbnail(self) -> bool: + return False + + def getThumbnail(self) -> Optional[bytes]: + return None + + def getThumbnailRange(self) -> Optional[Tuple[int, int]]: + return None + + def getAttributeRange(self, tag: str) -> Optional[Tuple[int, int]]: + return None + + def setIsUri(self, isUri: bool): + pass + + def flipHorizontally(self): + pass + + def flipVertically(self): + pass + + def rotate(self, degree: int): + pass + + +# ═══════════════════════════════════════════════════════════════ +# CamcorderProfile +# ═══════════════════════════════════════════════════════════════ + +class CamcorderProfile(Stub): + """CamcorderProfile — 摄像机配置""" + + QUALITY_LOW = 0 + QUALITY_HIGH = 1 + QUALITY_QCIF = 2 + QUALITY_CIF = 3 + QUALITY_480P = 4 + QUALITY_720P = 5 + QUALITY_1080P = 6 + QUALITY_QVGA = 7 + QUALITY_2160P = 8 + QUALITY_VGA = 9 + QUALITY_4KDCI = 10 + QUALITY_QHD = 11 + QUALITY_2K = 12 + + def __init__(self): + super().__init__() + self.quality = CamcorderProfile.QUALITY_HIGH + self.fileFormat = MediaRecorder.OutputFormat.MPEG_4 + self.duration = 30 + self.videoCodec = MediaRecorder.VideoEncoder.H_264 + self.videoBitRate = 20000000 + self.videoFrameRate = 30 + self.videoFrameWidth = 1920 + self.videoFrameHeight = 1080 + self.audioCodec = MediaRecorder.AudioEncoder.AAC + self.audioBitRate = 192000 + self.audioSampleRate = 44100 + self.audioChannels = 2 + + @staticmethod + def get(cameraId: int, quality: int) -> Optional["CamcorderProfile"]: + if quality in (CamcorderProfile.QUALITY_LOW, CamcorderProfile.QUALITY_HIGH): + profile = CamcorderProfile() + profile.quality = quality + if quality == CamcorderProfile.QUALITY_LOW: + profile.videoFrameWidth = 640 + profile.videoFrameHeight = 480 + profile.videoBitRate = 500000 + profile.audioBitRate = 96000 + return profile + return None + + @staticmethod + def hasProfile(cameraId: int, quality: int) -> bool: + return True + + @staticmethod + def getAll(cameraId: int) -> List[int]: + return [ + CamcorderProfile.QUALITY_LOW, + CamcorderProfile.QUALITY_HIGH, + CamcorderProfile.QUALITY_480P, + CamcorderProfile.QUALITY_720P, + CamcorderProfile.QUALITY_1080P, + ] + + +# ═══════════════════════════════════════════════════════════════ +# EncoderProfiles +# ═══════════════════════════════════════════════════════════════ + +class EncoderProfiles(Stub): + """EncoderProfiles — 编码器配置 (API 31+)""" + + class VideoProfile(Stub): + def __init__(self): + super().__init__() + self.codec = "" + self.bitrate = 0 + self.width = 0 + self.height = 0 + self.frameRate = 0 + self.profile = 0 + self.bitDepth = 8 + self.chromaSubsampling = 420 + self.hdrFormat = 0 + + class AudioProfile(Stub): + def __init__(self): + super().__init__() + self.codec = "" + self.bitrate = 0 + self.sampleRate = 0 + self.channels = 0 + self.profile = 0 + + def __init__(self): + super().__init__() + self._default_duration = 30 + self._recommended_file_format = MediaRecorder.OutputFormat.MPEG_4 + self._video_profiles: List[EncoderProfiles.VideoProfile] = [] + self._audio_profiles: List[EncoderProfiles.AudioProfile] = [] + + def getDefaultDuration(self) -> int: + return self._default_duration + + def getRecommendedFileFormat(self) -> int: + return self._recommended_file_format + + def getVideoProfiles(self) -> List["VideoProfile"]: + return list(self._video_profiles) + + def getAudioProfiles(self) -> List["AudioProfile"]: + return list(self._audio_profiles) + + @staticmethod + def get(cameraId: int, quality: int) -> Optional["EncoderProfiles"]: + profiles = EncoderProfiles() + + vp = EncoderProfiles.VideoProfile() + vp.codec = MediaFormat.MIMETYPE_VIDEO_AVC + vp.bitrate = 20000000 + vp.width = 1920 + vp.height = 1080 + vp.frameRate = 30 + vp.profile = 8 # High Profile + profiles._video_profiles.append(vp) + + ap = EncoderProfiles.AudioProfile() + ap.codec = MediaFormat.MIMETYPE_AUDIO_AAC + ap.bitrate = 192000 + ap.sampleRate = 44100 + ap.channels = 2 + ap.profile = 2 # AAC LC + profiles._audio_profiles.append(ap) + + return profiles + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "MediaPlayer", + "MediaRecorder", + "SoundPool", + "AudioManager", + "AudioTrack", + "AudioRecord", + "Ringtone", + "RingtoneManager", + "MediaMetadataRetriever", + "MediaCodec", + "MediaCodecBufferInfo", + "MediaFormat", + "MediaMuxer", + "MediaExtractor", + "FaceDetector", + "FaceDetectorFace", + "ThumbnailUtils", + "MediaScannerConnection", + "MediaScannerConnectionClient", + "AudioAttributes", + "AudioFormat", + "MediaActionSound", + "ToneGenerator", + "ExifInterface", + "CamcorderProfile", + "EncoderProfiles", +] \ No newline at end of file diff --git a/android_pyapi/android/net.py b/android_pyapi/android/net.py new file mode 100644 index 0000000..3a6d6dc --- /dev/null +++ b/android_pyapi/android/net.py @@ -0,0 +1,1397 @@ +""" +Android Network 组件 — ConnectivityManager, NetworkInfo, Uri_Builder 等 +方法签名完全对齐 Android SDK +""" + +import os +import sys +import socket +import struct +import threading +from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union +from urllib.parse import urlparse, urlunparse, quote, unquote + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, + _sdcard_root, _app_data_dir, _package_name, +) + + +# ═══════════════════════════════════════════════════════════════ +# Uri (re-export from content) +# ═══════════════════════════════════════════════════════════════ + +# Uri is defined in android.content; re-export the reference here. +from .content import Uri + +Uri_Builder = Uri.Builder + + +# ═══════════════════════════════════════════════════════════════ +# LocalSocket / LocalSocketAddress +# ═══════════════════════════════════════════════════════════════ + +class LocalSocketAddress(Stub): + """Android LocalSocketAddress""" + + class Namespace(Stub): + ABSTRACT = 0 + RESERVED = 1 + FILESYSTEM = 2 + + def __init__(self, name: str, namespace: int = Namespace.ABSTRACT): + super().__init__() + self._name = name + self._namespace = namespace + + def getName(self) -> str: + return self._name + + def getNamespace(self) -> int: + return self._namespace + + +class LocalSocket(Stub): + """Android LocalSocket — 基于 Unix domain socket 实现""" + + def __init__(self, sock_type: int = 1): # SOCK_STREAM + super().__init__() + self._sock: Optional[socket.socket] = None + self._sock_type = sock_type + self._input_stream: Optional[bytes] = b"" + self._output_stream: Optional[bytes] = b"" + self._closed = False + self._so_timeout: float = 0.0 + self._address: Optional[LocalSocketAddress] = None + + def connect(self, address: LocalSocketAddress, timeout: int = 0): + self._address = address + ns = address.getNamespace() + if ns == LocalSocketAddress.Namespace.ABSTRACT: + sock_path = "\0" + address.getName() + elif ns == LocalSocketAddress.Namespace.FILESYSTEM: + sock_path = address.getName() + else: + sock_path = os.path.join("/dev/socket", address.getName()) + try: + self._sock = socket.socket(socket.AF_UNIX, self._sock_type) + if timeout > 0: + self._sock.settimeout(timeout / 1000.0) + self._sock.connect(sock_path) + except (OSError, socket.error) as e: + raise AndroidOnlyError(f"LocalSocket.connect failed: {e}") + + def bind(self, address: LocalSocketAddress): + self._address = address + ns = address.getNamespace() + if ns == LocalSocketAddress.Namespace.ABSTRACT: + sock_path = "\0" + address.getName() + elif ns == LocalSocketAddress.Namespace.FILESYSTEM: + sock_path = address.getName() + else: + sock_path = os.path.join("/dev/socket", address.getName()) + try: + self._sock = socket.socket(socket.AF_UNIX, self._sock_type) + self._sock.bind(sock_path) + except (OSError, socket.error) as e: + raise AndroidOnlyError(f"LocalSocket.bind failed: {e}") + + def getInputStream(self): + return self._input_stream + + def getOutputStream(self): + return self._output_stream + + def close(self): + self._closed = True + if self._sock: + try: + self._sock.close() + except Exception: + pass + self._sock = None + + def setSoTimeout(self, timeout: int): + self._so_timeout = timeout / 1000.0 + if self._sock: + self._sock.settimeout(self._so_timeout) + + def getSoTimeout(self) -> int: + return int(self._so_timeout * 1000) + + def shutdownInput(self): + if self._sock: + try: + self._sock.shutdown(socket.SHUT_RD) + except Exception: + pass + + def shutdownOutput(self): + if self._sock: + try: + self._sock.shutdown(socket.SHUT_WR) + except Exception: + pass + + def isClosed(self) -> bool: + return self._closed + + def isConnected(self) -> bool: + return self._sock is not None + + def getRemoteSocketAddress(self) -> Optional[LocalSocketAddress]: + return self._address + + def toString(self) -> str: + return f"LocalSocket(address={self._address})" + + +# ═══════════════════════════════════════════════════════════════ +# NetworkUtils +# ═══════════════════════════════════════════════════════════════ + +class NetworkUtils(Stub): + """NetworkUtils — 网络工具""" + + @staticmethod + def getNetworkPartOfAddress(addr: str, prefix_len: int) -> str: + return addr + + @staticmethod + def intToInetAddress(host_address: int) -> str: + try: + return socket.inet_ntoa(struct.pack("!I", host_address & 0xFFFFFFFF)) + except Exception: + return "0.0.0.0" + + @staticmethod + def inetAddressToInt(addr: str) -> int: + try: + return struct.unpack("!I", socket.inet_aton(addr))[0] + except Exception: + return 0 + + @staticmethod + def isIPv6ULA(addr: str) -> bool: + return addr.startswith("fc") or addr.startswith("fd") + + @staticmethod + def isIPv6GlobalMulticast(addr: str) -> bool: + return addr.startswith("ff") + + @staticmethod + def prefixLengthToSubnetMask(prefix_len: int) -> int: + return (0xFFFFFFFF << (32 - prefix_len)) & 0xFFFFFFFF if prefix_len <= 32 else 0 + + +# ═══════════════════════════════════════════════════════════════ +# InetAddresses +# ═══════════════════════════════════════════════════════════════ + +class InetAddresses(Stub): + """InetAddresses — 地址解析工具""" + + @staticmethod + def isNumeric(address: str) -> bool: + try: + socket.inet_aton(address) + return True + except OSError: + return False + + @staticmethod + def parseNumericAddress(address: str) -> str: + return address + + @staticmethod + def getAddressFamily(address: str) -> int: + return 2 # AF_INET + + +# ═══════════════════════════════════════════════════════════════ +# NetworkSpecifier / MatchAllNetworkSpecifier +# ═══════════════════════════════════════════════════════════════ + +class NetworkSpecifier(Stub): + """NetworkSpecifier — 网络说明符基类""" + + def __init__(self): + super().__init__() + + def satisfiedBy(self, other: "NetworkSpecifier") -> bool: + return self is other + + def equals(self, other) -> bool: + return self is other + + def hashCode(self) -> int: + return hash(self.__class__.__name__) & 0x7FFFFFFF + + +class MatchAllNetworkSpecifier(NetworkSpecifier): + """匹配所有网络的说明符""" + + def __init__(self): + super().__init__() + + def satisfiedBy(self, other: NetworkSpecifier) -> bool: + return True + + def toString(self) -> str: + return "MatchAllNetworkSpecifier" + + +class WifiAwareNetworkSpecifier(NetworkSpecifier): + """WiFi Aware 网络说明符""" + + def __init__(self, role: int, client_id: int, peer_id: int, peer_mac: Optional[str] = None): + super().__init__() + self._role = role + self._client_id = client_id + self._peer_id = peer_id + self._peer_mac = peer_mac + + def getRole(self) -> int: + return self._role + + def getClientId(self) -> int: + return self._client_id + + def toString(self) -> str: + return f"WifiAwareNetworkSpecifier(role={self._role}, client={self._client_id})" + + +class EthernetNetworkSpecifier(NetworkSpecifier): + """以太网网络说明符""" + + def __init__(self, data: Optional[str] = None): + super().__init__() + self._data = data + + def getData(self) -> Optional[str]: + return self._data + + def toString(self) -> str: + return f"EthernetNetworkSpecifier(data={self._data})" + + +class TelephonyNetworkSpecifier(NetworkSpecifier): + """电话网络说明符""" + + def __init__(self, subscription_id: int = 0): + super().__init__() + self._subscription_id = subscription_id + + def getSubscriptionId(self) -> int: + return self._subscription_id + + def toString(self) -> str: + return f"TelephonyNetworkSpecifier(subId={self._subscription_id})" + + +# ═══════════════════════════════════════════════════════════════ +# NetworkState +# ═══════════════════════════════════════════════════════════════ + +class NetworkState(Stub): + """NetworkState — 网络状态""" + + def __init__(self, network: Optional["Network"] = None, + network_info: Optional["NetworkInfo"] = None, + link_properties: Optional["LinkProperties"] = None, + network_capabilities: Optional["NetworkCapabilities"] = None, + subscriber_id: Optional[str] = None): + super().__init__() + self.network = network + self.network_info = network_info + self.link_properties = link_properties + self.network_capabilities = network_capabilities + self.subscriber_id = subscriber_id + + def getNetwork(self) -> Optional["Network"]: + return self.network + + def getNetworkInfo(self) -> Optional["NetworkInfo"]: + return self.network_info + + def getLinkProperties(self) -> Optional["LinkProperties"]: + return self.link_properties + + def getNetworkCapabilities(self) -> Optional["NetworkCapabilities"]: + return self.network_capabilities + + def toString(self) -> str: + return f"NetworkState(network={self.network})" + + +# ═══════════════════════════════════════════════════════════════ +# NetworkInfo +# ═══════════════════════════════════════════════════════════════ + +class NetworkInfo(Stub): + """NetworkInfo — 网络连接信息""" + + class DetailedState(Stub): + CONNECTED = "CONNECTED" + CONNECTING = "CONNECTING" + DISCONNECTED = "DISCONNECTED" + SUSPENDED = "SUSPENDED" + IDLE = "IDLE" + FAILED = "FAILED" + BLOCKED = "BLOCKED" + VERIFYING_POOR_CONNECTION = "VERIFYING_POOR_CONNECTION" + CAPTIVE_PORTAL_CHECK = "CAPTIVE_PORTAL_CHECK" + OBTAINING_IPADDR = "OBTAINING_IPADDR" + + class State(Stub): + CONNECTED = "CONNECTED" + CONNECTING = "CONNECTING" + DISCONNECTED = "DISCONNECTED" + SUSPENDED = "SUSPENDED" + UNKNOWN = "UNKNOWN" + + def __init__(self, type_: int = 0, subtype: int = 0, + state: str = "DISCONNECTED", detailed_state: str = "DISCONNECTED", + type_name: str = "", subtype_name: str = "", + extra_info: Optional[str] = None, reason: Optional[str] = None, + failover: bool = False, roaming: bool = False, + is_available: bool = True): + super().__init__() + self._type = type_ + self._subtype = subtype + self._state = state + self._detailed_state = detailed_state + self._type_name = type_name or self._default_type_name(type_) + self._subtype_name = subtype_name + self._extra_info = extra_info + self._reason = reason + self._failover = failover + self._roaming = roaming + self._is_available = is_available + self._is_connected = (state == "CONNECTED") + self._is_connecting = (state == "CONNECTING") + + def _default_type_name(self, type_: int) -> str: + names = { + 0: "MOBILE", 1: "WIFI", 6: "WIMAX", 7: "BLUETOOTH", + 9: "ETHERNET", 17: "VPN", + } + return names.get(type_, "UNKNOWN") + + def getType(self) -> int: + return self._type + + def getSubtype(self) -> int: + return self._subtype + + def isConnected(self) -> bool: + return self._state == "CONNECTED" + + def isConnectedOrConnecting(self) -> bool: + return self._state in ("CONNECTED", "CONNECTING") + + def getState(self) -> str: + return self._state + + def getDetailedState(self) -> str: + return self._detailed_state + + def getTypeName(self) -> str: + return self._type_name + + def getSubtypeName(self) -> str: + return self._subtype_name + + def getExtraInfo(self) -> Optional[str]: + return self._extra_info + + def getReason(self) -> Optional[str]: + return self._reason + + def getFailover(self) -> bool: + return self._failover + + def getRoaming(self) -> bool: + return self._roaming + + def isAvailable(self) -> bool: + return self._is_available + + def isFailover(self) -> bool: + return self._failover + + def isRoaming(self) -> bool: + return self._roaming + + def toString(self) -> str: + return (f"NetworkInfo(type={self._type_name}[{self._type}], " + f"state={self._state}/{self._detailed_state}, " + f"roaming={self._roaming}, available={self._is_available})") + + def hashCode(self) -> int: + return self._type + + def equals(self, other) -> bool: + if isinstance(other, NetworkInfo): + return self._type == other._type and self._state == other._state + return False + + +# ═══════════════════════════════════════════════════════════════ +# Network +# ═══════════════════════════════════════════════════════════════ + +class Network(Stub): + """Network — 网络句柄""" + + def __init__(self, net_id: int = 0): + super().__init__() + self._net_id = net_id + + def getNetworkHandle(self) -> int: + return self._net_id + + def getNetworkCapabilities(self) -> Optional["NetworkCapabilities"]: + return None + + def getLinkProperties(self) -> Optional["LinkProperties"]: + return None + + def bindSocket(self, socket_obj: Any): + pass + + def bindSocketToNetwork(self, socket_obj: Any) -> bool: + return True + + def equals(self, other) -> bool: + if isinstance(other, Network): + return self._net_id == other._net_id + return False + + def hashCode(self) -> int: + return self._net_id + + def toString(self) -> str: + return f"Network({self._net_id})" + + +# ═══════════════════════════════════════════════════════════════ +# NetworkCapabilities +# ═══════════════════════════════════════════════════════════════ + +class NetworkCapabilities(Stub): + """NetworkCapabilities — 网络能力""" + + NET_CAPABILITY_INTERNET = 12 + NET_CAPABILITY_NOT_METERED = 11 + NET_CAPABILITY_NOT_ROAMING = 18 + NET_CAPABILITY_VALIDATED = 16 + NET_CAPABILITY_CAPTIVE_PORTAL = 17 + NET_CAPABILITY_NOT_VPN = 15 + NET_CAPABILITY_MMS = 0 + NET_CAPABILITY_SUPL = 1 + NET_CAPABILITY_DUN = 2 + NET_CAPABILITY_FOTA = 3 + NET_CAPABILITY_IMS = 4 + NET_CAPABILITY_CBS = 5 + NET_CAPABILITY_WIFI_P2P = 6 + NET_CAPABILITY_IA = 7 + NET_CAPABILITY_RCS = 8 + NET_CAPABILITY_XCAP = 9 + NET_CAPABILITY_EIMS = 10 + NET_CAPABILITY_NOT_CONGESTED = 13 + NET_CAPABILITY_NOT_RESTRICTED = 14 + NET_CAPABILITY_TRUSTED = 19 + NET_CAPABILITY_NOT_VCN_MANAGED = 20 + NET_CAPABILITY_PRIORITIZE_LATENCY = 21 + NET_CAPABILITY_PRIORITIZE_BANDWIDTH = 22 + + TRANSPORT_WIFI = 1 + TRANSPORT_CELLULAR = 0 + TRANSPORT_ETHERNET = 3 + TRANSPORT_BLUETOOTH = 2 + TRANSPORT_VPN = 4 + TRANSPORT_WIFI_AWARE = 5 + TRANSPORT_LOWPAN = 6 + TRANSPORT_TEST = 7 + + SIGNAL_STRENGTH_UNSPECIFIED = -2147483648 + + def __init__(self): + super().__init__() + self._capabilities: Set[int] = set() + self._transports: Set[int] = set() + self._link_upstream_bw = 0 + self._link_downstream_bw = 0 + self._signal_strength = self.SIGNAL_STRENGTH_UNSPECIFIED + self._network_specifier: Optional[NetworkSpecifier] = None + self._owner_uid = -1 + self._ssid: Optional[str] = None + self._administrator_uids: List[int] = [] + self._enterprise_ids: List[int] = [] + + def hasCapability(self, capability: int) -> bool: + return capability in self._capabilities + + def hasTransport(self, transport: int) -> bool: + return transport in self._transports + + def addCapability(self, capability: int) -> "NetworkCapabilities": + self._capabilities.add(capability) + return self + + def removeCapability(self, capability: int) -> "NetworkCapabilities": + self._capabilities.discard(capability) + return self + + def getCapabilities(self) -> List[int]: + return sorted(self._capabilities) + + def getLinkUpstreamBandwidthKbps(self) -> int: + return self._link_upstream_bw + + def getLinkDownstreamBandwidthKbps(self) -> int: + return self._link_downstream_bw + + def setLinkUpstreamBandwidthKbps(self, bw: int): + self._link_upstream_bw = bw + + def setLinkDownstreamBandwidthKbps(self, bw: int): + self._link_downstream_bw = bw + + def addTransportType(self, transport: int) -> "NetworkCapabilities": + self._transports.add(transport) + return self + + def removeTransportType(self, transport: int) -> "NetworkCapabilities": + self._transports.discard(transport) + return self + + def getTransportInfo(self) -> Optional[Any]: + return None + + def setNetworkSpecifier(self, specifier: NetworkSpecifier): + self._network_specifier = specifier + + def getNetworkSpecifier(self) -> Optional[NetworkSpecifier]: + return self._network_specifier + + def getSignalStrength(self) -> int: + return self._signal_strength + + def setSignalStrength(self, strength: int): + self._signal_strength = strength + + def getOwnerUid(self) -> int: + return self._owner_uid + + def setOwnerUid(self, uid: int): + self._owner_uid = uid + + def getSsid(self) -> Optional[str]: + return self._ssid + + def setSsid(self, ssid: str): + self._ssid = ssid + + def getAdministratorUids(self) -> List[int]: + return list(self._administrator_uids) + + def setAdministratorUids(self, uids: List[int]): + self._administrator_uids = list(uids) + + def equals(self, other) -> bool: + if isinstance(other, NetworkCapabilities): + return (self._capabilities == other._capabilities + and self._transports == other._transports) + return False + + def hashCode(self) -> int: + return hash(frozenset(self._capabilities)) ^ hash(frozenset(self._transports)) + + def toString(self) -> str: + caps = ",".join(str(c) for c in sorted(self._capabilities)) + trans = ",".join(str(t) for t in sorted(self._transports)) + return f"NetworkCapabilities(caps=[{caps}], transports=[{trans}])" + + +# ═══════════════════════════════════════════════════════════════ +# NetworkRequest +# ═══════════════════════════════════════════════════════════════ + +class NetworkRequest(Stub): + """NetworkRequest — 网络请求""" + + class Builder(Stub): + """Builder 模式""" + + def __init__(self): + super().__init__() + self._capabilities: Set[int] = set() + self._transports: Set[int] = set() + self._network_specifier: Optional[NetworkSpecifier] = None + self._clear_capabilities: Set[int] = set() + + def addCapability(self, capability: int) -> "NetworkRequest.Builder": + self._capabilities.add(capability) + return self + + def removeCapability(self, capability: int) -> "NetworkRequest.Builder": + self._capabilities.discard(capability) + self._clear_capabilities.add(capability) + return self + + def addTransportType(self, transport: int) -> "NetworkRequest.Builder": + self._transports.add(transport) + return self + + def removeTransportType(self, transport: int) -> "NetworkRequest.Builder": + self._transports.discard(transport) + return self + + def setNetworkSpecifier(self, specifier: NetworkSpecifier) -> "NetworkRequest.Builder": + self._network_specifier = specifier + return self + + def build(self) -> "NetworkRequest": + request = NetworkRequest() + request._capabilities = set(self._capabilities) + request._transports = set(self._transports) + request._network_specifier = self._network_specifier + request._request_id = id(request) + return request + + def __init__(self): + super().__init__() + self._capabilities: Set[int] = set() + self._transports: Set[int] = set() + self._network_specifier: Optional[NetworkSpecifier] = None + self._request_id = 0 + + def hasCapability(self, capability: int) -> bool: + return capability in self._capabilities + + def hasTransport(self, transport: int) -> bool: + return transport in self._transports + + def getCapabilities(self) -> Set[int]: + return set(self._capabilities) + + def getTransports(self) -> Set[int]: + return set(self._transports) + + def getNetworkSpecifier(self) -> Optional[NetworkSpecifier]: + return self._network_specifier + + def getRequestId(self) -> int: + return self._request_id + + def toString(self) -> str: + return f"NetworkRequest(id={self._request_id})" + + +# ═══════════════════════════════════════════════════════════════ +# NetworkCallback +# ═══════════════════════════════════════════════════════════════ + +class NetworkCallback(Stub): + """NetworkCallback — 网络回调""" + + def __init__(self, flags: int = 0): + super().__init__() + self._flags = flags + + def onAvailable(self, network: Network): + pass + + def onLost(self, network: Network): + pass + + def onCapabilitiesChanged(self, network: Network, capabilities: NetworkCapabilities): + pass + + def onLinkPropertiesChanged(self, network: Network, link_properties: "LinkProperties"): + pass + + def onNetworkSuspended(self, network: Network): + pass + + def onResumed(self, network: Network): + pass + + def onBlockedStatusChanged(self, network: Network, blocked: bool): + pass + + def onLosing(self, network: Network, max_ms_to_live: int): + pass + + def onPreCheck(self, network: Network) -> bool: + return True + + def onUnavailable(self): + pass + + +# ═══════════════════════════════════════════════════════════════ +# LinkAddress +# ═══════════════════════════════════════════════════════════════ + +class LinkAddress(Stub): + """LinkAddress — 链接地址""" + + def __init__(self, address: str = "0.0.0.0", + prefix_length: int = 24, + flags: int = 0, + scope: int = 0): + super().__init__() + self._address = address + self._prefix_length = prefix_length + self._flags = flags + self._scope = scope + self._is_ipv6 = ":" in address + + def getAddress(self) -> str: + return self._address + + def getPrefixLength(self) -> int: + return self._prefix_length + + def getFlags(self) -> int: + return self._flags + + def getScope(self) -> int: + return self._scope + + def isIpv6(self) -> bool: + return self._is_ipv6 + + def toString(self) -> str: + return f"{self._address}/{self._prefix_length}" + + def equals(self, other) -> bool: + if isinstance(other, LinkAddress): + return self._address == other._address + return False + + def hashCode(self) -> int: + return hash(self._address) & 0x7FFFFFFF + + +# ═══════════════════════════════════════════════════════════════ +# RouteInfo +# ═══════════════════════════════════════════════════════════════ + +class RouteInfo(Stub): + """RouteInfo — 路由信息""" + + RTN_UNICAST = 1 + RTN_UNREACHABLE = 2 + RTN_BROADCAST = 3 + RTN_THROW = 4 + RTN_OTHER = 5 + + def __init__(self, destination: Optional[LinkAddress] = None, + gateway: str = "", + interface_name: str = "", + is_default: bool = False, + type_: int = RTN_UNICAST): + super().__init__() + self._destination = destination + self._gateway = gateway + self._interface_name = interface_name + self._is_default = is_default + self._type = type_ + + def getDestination(self) -> Optional[LinkAddress]: + return self._destination + + def getGateway(self) -> str: + return self._gateway + + def getInterface(self) -> str: + return self._interface_name + + def getType(self) -> int: + return self._type + + def isDefaultRoute(self) -> bool: + return self._is_default + + def isIPv4Default(self) -> bool: + return self._is_default and self._destination is not None and not self._destination.isIpv6() + + def isIPv6Default(self) -> bool: + return self._is_default and self._destination is not None and self._destination.isIpv6() + + def toString(self) -> str: + dest = str(self._destination) if self._destination else "0.0.0.0/0" + gw = self._gateway or "0.0.0.0" + return f"RouteInfo({dest} -> {gw} via {self._interface_name})" + + def equals(self, other) -> bool: + if isinstance(other, RouteInfo): + return (self._gateway == other._gateway + and self._interface_name == other._interface_name) + return False + + def hashCode(self) -> int: + return hash(self._gateway) & 0x7FFFFFFF + + +# ═══════════════════════════════════════════════════════════════ +# LinkProperties +# ═══════════════════════════════════════════════════════════════ + +class LinkProperties(Stub): + """LinkProperties — 链接属性""" + + def __init__(self): + super().__init__() + self._link_addresses: List[LinkAddress] = [] + self._routes: List[RouteInfo] = [] + self._dns_servers: List[str] = [] + self._interface_name: str = "" + self._mtu: int = 1500 + self._http_proxy: Optional[ProxyInfo] = None + self._private_dns_server_name: str = "" + self._private_dns_active: bool = False + self._domains: str = "" + self._pcscf: List[str] = [] + + def getLinkAddresses(self) -> List[LinkAddress]: + return list(self._link_addresses) + + def getRoutes(self) -> List[RouteInfo]: + return list(self._routes) + + def getDnsServers(self) -> List[str]: + return list(self._dns_servers) + + def getInterfaceName(self) -> str: + return self._interface_name + + def setInterfaceName(self, name: str): + self._interface_name = name + + def addLinkAddress(self, address: LinkAddress): + if address not in self._link_addresses: + self._link_addresses.append(address) + + def removeLinkAddress(self, address: LinkAddress): + self._link_addresses = [a for a in self._link_addresses if a != address] + + def addRoute(self, route: RouteInfo): + if route not in self._routes: + self._routes.append(route) + + def removeRoute(self, route: RouteInfo): + self._routes = [r for r in self._routes if r != route] + + def addDnsServer(self, dns: str): + if dns not in self._dns_servers: + self._dns_servers.append(dns) + + def removeDnsServer(self, dns: str): + self._dns_servers = [d for d in self._dns_servers if d != dns] + + def getMtu(self) -> int: + return self._mtu + + def setMtu(self, mtu: int): + self._mtu = mtu + + def getHttpProxy(self) -> Optional["ProxyInfo"]: + return self._http_proxy + + def setHttpProxy(self, proxy: "ProxyInfo"): + self._http_proxy = proxy + + def getPrivateDnsServerName(self) -> str: + return self._private_dns_server_name + + def setPrivateDnsServerName(self, name: str): + self._private_dns_server_name = name + self._private_dns_active = bool(name) + + def isPrivateDnsActive(self) -> bool: + return self._private_dns_active + + def setLinkAddresses(self, addresses: List[LinkAddress]): + self._link_addresses = list(addresses) + + def setDnsServers(self, dns_servers: List[str]): + self._dns_servers = list(dns_servers) + + def getDomains(self) -> str: + return self._domains + + def setDomains(self, domains: str): + self._domains = domains + + def getPcscf(self) -> List[str]: + return list(self._pcscf) + + def addPcscf(self, addr: str): + if addr not in self._pcscf: + self._pcscf.append(addr) + + def setMtuV4(int_mtu: int): + pass + + def setMtuV6(int_mtu: int): + pass + + def clearLinkAddresses(self): + self._link_addresses.clear() + + def clearRoutes(self): + self._routes.clear() + + def clearDnsServers(self): + self._dns_servers.clear() + + def toString(self) -> str: + iface = self._interface_name or "none" + return f"LinkProperties(iface={iface}, mtu={self._mtu}, dns={self._dns_servers})" + + def equals(self, other) -> bool: + if isinstance(other, LinkProperties): + return (self._interface_name == other._interface_name + and self._mtu == other._mtu) + return False + + def hashCode(self) -> int: + return hash(self._interface_name) & 0x7FFFFFFF + + +# ═══════════════════════════════════════════════════════════════ +# DnsResolver +# ═══════════════════════════════════════════════════════════════ + +class DnsResolver(Stub): + """DnsResolver — DNS 解析器""" + + CLASS_IN = 1 + TYPE_A = 1 + TYPE_AAAA = 28 + + @staticmethod + def getInstance() -> "DnsResolver": + return DnsResolver() + + def query(self, hostname: str, callback: Any, flags: int = 0): + try: + result = socket.getaddrinfo(hostname, None) + callback.onAnswer(None, 0, result) + except socket.gaierror: + callback.onAnswer(None, -1, None) + + +# ═══════════════════════════════════════════════════════════════ +# DhcpInfo +# ═══════════════════════════════════════════════════════════════ + +class DhcpInfo(Stub): + """DhcpInfo — DHCP 信息""" + + def __init__(self): + super().__init__() + self.ipAddress = 0 + self.gateway = 0 + self.netmask = 0 + self.dns1 = 0 + self.dns2 = 0 + self.serverAddress = 0 + self.leaseDuration = 0 + + def toString(self) -> str: + return (f"DhcpInfo(ip={self.ipAddress}, gw={self.gateway}, " + f"mask={self.netmask}, dns1={self.dns1}, dns2={self.dns2})") + + +# ═══════════════════════════════════════════════════════════════ +# SSLSessionCache +# ═══════════════════════════════════════════════════════════════ + +class SSLSessionCache(Stub): + """SSLSessionCache — SSL 会话缓存""" + + def __init__(self, context_or_dir: Any): + super().__init__() + self._dir: Optional[str] = None + if isinstance(context_or_dir, str): + self._dir = context_or_dir + else: + self._dir = os.path.join(_app_data_dir, "ssl_cache") + + def getDir(self) -> Optional[str]: + return self._dir + + +# ═══════════════════════════════════════════════════════════════ +# TrafficStats +# ═══════════════════════════════════════════════════════════════ + +class TrafficStats(Stub): + """TrafficStats — 流量统计""" + + UID_TETHERING = "UNSUPPORTED" + UNSUPPORTED = -1 + TAG_SYSTEM_UPDATE = 0 + + @staticmethod + def getMobileTxBytes() -> int: + return 0 + + @staticmethod + def getMobileRxBytes() -> int: + return 0 + + @staticmethod + def getTotalTxBytes() -> int: + return 0 + + @staticmethod + def getTotalRxBytes() -> int: + return 0 + + @staticmethod + def getMobileTxPackets() -> int: + return 0 + + @staticmethod + def getMobileRxPackets() -> int: + return 0 + + @staticmethod + def getTotalTxPackets() -> int: + return 0 + + @staticmethod + def getTotalRxPackets() -> int: + return 0 + + @staticmethod + def getUidTxBytes(uid: int) -> int: + return 0 + + @staticmethod + def getUidRxBytes(uid: int) -> int: + return 0 + + @staticmethod + def getUidTxPackets(uid: int) -> int: + return 0 + + @staticmethod + def getUidRxPackets(uid: int) -> int: + return 0 + + @staticmethod + def getUidTcpTxBytes(uid: int) -> int: + return 0 + + @staticmethod + def getUidTcpRxBytes(uid: int) -> int: + return 0 + + @staticmethod + def getUidUdpTxBytes(uid: int) -> int: + return 0 + + @staticmethod + def getUidUdpRxBytes(uid: int) -> int: + return 0 + + @staticmethod + def setThreadStatsTag(tag: int): + pass + + @staticmethod + def clearThreadStatsTag(): + pass + + @staticmethod + def getThreadStatsTag() -> int: + return 0 + + @staticmethod + def setThreadStatsUid(uid: int): + pass + + @staticmethod + def clearThreadStatsUid(): + pass + + @staticmethod + def incrementOperationCount(uid: int, tag: int, count: int): + pass + + +# ═══════════════════════════════════════════════════════════════ +# Proxy / ProxyInfo +# ═══════════════════════════════════════════════════════════════ + +class Proxy(Stub): + """Proxy — 系统代理信息""" + + @staticmethod + def getDefaultHost() -> Optional[str]: + return None + + @staticmethod + def getDefaultPort() -> int: + return -1 + + +class ProxyInfo(Stub): + """ProxyInfo — 代理详细信息""" + + def __init__(self, host: str = "", port: int = 0, + pac_file_url: Optional[str] = None, + username: str = "", password: str = "", + exclusion_list: Optional[List[str]] = None): + super().__init__() + self._host = host + self._port = port + self._pac_file_url = pac_file_url + self._username = username + self._password = password + self._exclusion_list = list(exclusion_list) if exclusion_list else [] + self._valid = bool(host) or bool(pac_file_url) + + def getHost(self) -> str: + return self._host + + def getPort(self) -> int: + return self._port + + def getPacFileUrl(self) -> Optional[str]: + return self._pac_file_url + + def getUsername(self) -> str: + return self._username + + def getPassword(self) -> str: + return self._password + + def getExclusionList(self) -> List[str]: + return list(self._exclusion_list) + + def isValid(self) -> bool: + return self._valid + + def makeProxy(self, url: str): + return self + + def equals(self, other) -> bool: + if isinstance(other, ProxyInfo): + return self._host == other._host and self._port == other._port + return False + + def hashCode(self) -> int: + return hash(self._host) ^ self._port + + def toString(self) -> str: + pac = f" pac={self._pac_file_url}" if self._pac_file_url else "" + return f"ProxyInfo(host={self._host}:{self._port}{pac})" + + +# ═══════════════════════════════════════════════════════════════ +# ConnectivityManager +# ═══════════════════════════════════════════════════════════════ + +class ConnectivityManager(Stub): + """ConnectivityManager — 连接管理器""" + + TYPE_WIFI = 1 + TYPE_MOBILE = 0 + TYPE_BLUETOOTH = 7 + TYPE_ETHERNET = 9 + TYPE_VPN = 17 + TYPE_WIMAX = 6 + TYPE_DUMMY = 8 + TYPE_PROXY = 16 + + CONNECTIVITY_ACTION = "android.net.conn.CONNECTIVITY_CHANGE" + + DEFAULT_NETWORK_PREFERENCE = 1 + + def __init__(self): + super().__init__() + self._networks: Dict[int, "Network"] = {} + self._callbacks: List[Tuple[NetworkCallback, Optional[NetworkRequest]]] = [] + self._active_network_info = NetworkInfo( + type_=self.TYPE_WIFI, state="CONNECTED", detailed_state="CONNECTED", + type_name="WIFI", is_available=True, + ) + self._net_id_counter = 0 + self._network_caps: Dict[int, NetworkCapabilities] = {} + self._link_props: Dict[int, LinkProperties] = {} + + def getActiveNetworkInfo(self) -> Optional[NetworkInfo]: + return self._active_network_info + + def getNetworkInfo(self, network_type: int) -> Optional[NetworkInfo]: + network = self._networks.get(network_type) + if network: + return NetworkInfo(type_=network_type, state="CONNECTED", is_available=True) + return self._active_network_info + + def getNetworkInfoForUid(self, network: Network, uid: int) -> Optional[NetworkInfo]: + return self._active_network_info + + def getAllNetworks(self) -> List[Network]: + return list(self._networks.values()) + + def getActiveNetwork(self) -> Optional[Network]: + if self._networks: + nid = next(iter(self._networks)) + return self._networks[nid] + net = Network(1) + self._networks[1] = net + return net + + def getActiveNetworkForUid(self, uid: int) -> Optional[Network]: + return self.getActiveNetwork() + + def getNetworkCapabilities(self, network: Network) -> Optional[NetworkCapabilities]: + caps = self._network_caps.get(network.getNetworkHandle()) + if caps is None: + caps = NetworkCapabilities() + caps.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) + caps.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED) + caps.addCapability(NetworkCapabilities.NET_CAPABILITY_TRUSTED) + caps.addTransportType(NetworkCapabilities.TRANSPORT_WIFI) + self._network_caps[network.getNetworkHandle()] = caps + return caps + + def getLinkProperties(self, network: Network) -> Optional[LinkProperties]: + lp = self._link_props.get(network.getNetworkHandle()) + if lp is None: + lp = LinkProperties() + self._link_props[network.getNetworkHandle()] = lp + return lp + + def requestNetwork(self, request: NetworkRequest, callback: NetworkCallback, timeout_ms: int = 0, + handler: Any = None, network_specifier: int = 0) -> None: + self._callbacks.append((callback, request)) + net = self.getActiveNetwork() + if net: + try: + callback.onAvailable(net) + except Exception: + pass + + def registerDefaultNetworkCallback(self, callback: NetworkCallback, handler: Any = None) -> None: + self._callbacks.append((callback, None)) + net = self.getActiveNetwork() + if net: + try: + callback.onAvailable(net) + except Exception: + pass + + def registerNetworkCallback(self, request: NetworkRequest, callback: NetworkCallback, + handler: Any = None) -> None: + self._callbacks.append((callback, request)) + net = self.getActiveNetwork() + if net: + try: + callback.onAvailable(net) + except Exception: + pass + + def unregisterNetworkCallback(self, callback_or_request: Any): + if isinstance(callback_or_request, NetworkCallback): + self._callbacks = [ + (cb, req) for cb, req in self._callbacks + if cb is not callback_or_request + ] + elif isinstance(callback_or_request, NetworkRequest): + self._callbacks = [ + (cb, req) for cb, req in self._callbacks + if req is not callback_or_request + ] + + def bindProcessToNetwork(self, network: Optional[Network]) -> bool: + return True + + def getProcessDefaultNetwork(self) -> Optional[Network]: + return self.getActiveNetwork() + + @staticmethod + def setProcessDefaultNetwork(network: Optional[Network]) -> bool: + return True + + def getAllNetworkInfo(self) -> List[NetworkInfo]: + return [self._active_network_info] + + def getNetworkInfoForProcess(self) -> Optional[NetworkInfo]: + return self._active_network_info + + def isDefaultNetworkActive(self) -> bool: + return True + + def addDefaultNetworkActiveListener(self, listener: Any): + pass + + def removeDefaultNetworkActiveListener(self, listener: Any): + pass + + def reportBadNetwork(self, network: Network): + pass + + def setNetworkPreference(self, preference: int): + pass + + def getNetworkPreference(self) -> int: + return self.DEFAULT_NETWORK_PREFERENCE + + def startCaptivePortalApp(self, network: Network): + pass + + def setProcessDefaultNetworkForUid(self, uid: int) -> bool: + return True + + def registerNetworkAgent(self, agent: Any) -> int: + return 0 + + def toString(self) -> str: + return f"ConnectivityManager(networks={len(self._networks)})" + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "Uri", + "Uri_Builder", + "ConnectivityManager", + "NetworkInfo", + "Network", + "NetworkCapabilities", + "NetworkRequest", + "NetworkCallback", + "LinkProperties", + "LinkAddress", + "RouteInfo", + "DnsResolver", + "DhcpInfo", + "InetAddresses", + "SSLSessionCache", + "TrafficStats", + "Proxy", + "ProxyInfo", + "NetworkSpecifier", + "MatchAllNetworkSpecifier", + "WifiAwareNetworkSpecifier", + "EthernetNetworkSpecifier", + "TelephonyNetworkSpecifier", + "NetworkState", + "LocalSocket", + "LocalSocketAddress", + "NetworkUtils", +] \ No newline at end of file diff --git a/android_pyapi/android/net_wifi.py b/android_pyapi/android/net_wifi.py new file mode 100644 index 0000000..9371da6 --- /dev/null +++ b/android_pyapi/android/net_wifi.py @@ -0,0 +1,1020 @@ +""" +Android WiFi 组件 — WifiManager, WifiInfo, ScanResult 等 +方法签名完全对齐 Android SDK +""" + +import os +import sys +import json +import random +from typing import Any, Dict, List, Optional, Set, Tuple, Union +from datetime import datetime + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, + _sdcard_root, _app_data_dir, _package_name, +) + + +# ═══════════════════════════════════════════════════════════════ +# SupplicantState +# ═══════════════════════════════════════════════════════════════ + +class SupplicantState(Stub): + """SupplicantState — wpa_supplicant 状态枚举""" + + ASSOCIATED = "ASSOCIATED" + ASSOCIATING = "ASSOCIATING" + COMPLETED = "COMPLETED" + DISCONNECTED = "DISCONNECTED" + DORMANT = "DORMANT" + FOUR_WAY_HANDSHAKE = "FOUR_WAY_HANDSHAKE" + GROUP_HANDSHAKE = "GROUP_HANDSHAKE" + INACTIVE = "INACTIVE" + INTERFACE_DISABLED = "INTERFACE_DISABLED" + INVALID = "INVALID" + SCANNING = "SCANNING" + UNINITIALIZED = "UNINITIALIZED" + + _VALID_STATES = [ + "ASSOCIATED", "ASSOCIATING", "COMPLETED", "DISCONNECTED", + "DORMANT", "FOUR_WAY_HANDSHAKE", "GROUP_HANDSHAKE", "INACTIVE", + "INTERFACE_DISABLED", "INVALID", "SCANNING", "UNINITIALIZED", + ] + + def __init__(self, state: str = "DISCONNECTED"): + super().__init__() + self._state = state if state in self._VALID_STATES else "INVALID" + + def getState(self) -> str: + return self._state + + def toString(self) -> str: + return self._state + + @staticmethod + def isValid(state_str: str) -> bool: + return state_str in SupplicantState._VALID_STATES + + def compareTo(self, other: "SupplicantState") -> int: + if self._state == other._state: + return 0 + return -1 if (self._VALID_STATES.index(self._state) + < self._VALID_STATES.index(other._state)) else 1 + + def equals(self, other) -> bool: + if isinstance(other, SupplicantState): + return self._state == other._state + return False + + def hashCode(self) -> int: + return hash(self._state) & 0x7FFFFFFF + + +# ═══════════════════════════════════════════════════════════════ +# WifiSsid +# ═══════════════════════════════════════════════════════════════ + +class WifiSsid(Stub): + """WifiSsid — WiFi SSID 封装""" + + def __init__(self, ssid: str = ""): + super().__init__() + self._ssid = ssid + + @staticmethod + def createFromAsciiBytes(ssid_bytes: bytes) -> "WifiSsid": + try: + return WifiSsid(ssid_bytes.decode("utf-8")) + except UnicodeDecodeError: + return WifiSsid(repr(ssid_bytes)) + + @staticmethod + def createFromHex(hex_str: str) -> "WifiSsid": + try: + decoded = bytes.fromhex(hex_str).decode("utf-8", errors="replace") + return WifiSsid(decoded) + except Exception: + return WifiSsid(hex_str) + + def toString(self) -> str: + return self._ssid + + +# ═══════════════════════════════════════════════════════════════ +# WifiConfiguration +# ═══════════════════════════════════════════════════════════════ + +class WifiConfiguration(Stub): + """WifiConfiguration — WiFi 网络配置""" + + SECURITY_OPEN = 0 + SECURITY_WEP = 1 + SECURITY_PSK = 2 + SECURITY_EAP = 3 + SECURITY_SAE = 4 + SECURITY_OWE = 5 + + class KeyMgmt(Stub): + NONE = 0 + WPA_PSK = 1 + WPA_EAP = 2 + IEEE8021X = 3 + WPA2_PSK = 4 + OSEN = 5 + FT_PSK = 6 + FT_EAP = 7 + SAE = 8 + OWE = 9 + SUITE_B_192 = 10 + WPA3_SAE = 8 + WPA3_OWE = 9 + + class GroupCipher(Stub): + NONE = 0 + TKIP = 1 + CCMP = 2 + TKIP_CCMP = 3 + AES = 4 + SMS4 = 5 + GCMP_128 = 6 + GCMP_256 = 7 + BIP_GMAC_128 = 8 + BIP_GMAC_256 = 9 + BIP_CMAC_256 = 10 + + class PairwiseCipher(Stub): + NONE = 0 + TKIP = 1 + CCMP = 2 + NONE_ = 3 + GCMP_128 = 4 + GCMP_256 = 5 + SMS4 = 6 + + class AuthAlgorithm(Stub): + OPEN = 0 + SHARED = 1 + LEAP = 2 + + class Protocol(Stub): + RSN = 0 + WPA = 1 + OSEN = 2 + + class Status(Stub): + CURRENT = 0 + DISABLED = 1 + ENABLED = 2 + + def __init__(self): + super().__init__() + self.SSID: Optional[str] = None + self.BSSID: Optional[str] = None + self.preSharedKey: Optional[str] = None + self.status: int = WifiConfiguration.Status.DISABLED + self.networkId: int = -1 + self.allowedKeyManagement: Set[int] = set() + self.allowedGroupCiphers: Set[int] = set() + self.allowedPairwiseCiphers: Set[int] = set() + self.allowedAuthAlgorithms: Set[int] = set() + self.allowedProtocols: Set[int] = set() + self.hiddenSSID: bool = False + self.priority: int = 0 + self.wepKeys: List[Optional[str]] = [None, None, None, None] + self.wepTxKeyIndex: int = 0 + self.isEnterprise: bool = False + self._enterprise_config: Optional["WifiEnterpriseConfig"] = None + + def getNetworkId(self) -> int: + return self.networkId + + def toString(self) -> str: + ssid = self.SSID or "(none)" + return f"WifiConfiguration(SSID={ssid}, id={self.networkId})" + + def hashCode(self) -> int: + return hash(self.SSID) & 0x7FFFFFFF + + +# ═══════════════════════════════════════════════════════════════ +# WifiEnterpriseConfig +# ═══════════════════════════════════════════════════════════════ + +class WifiEnterpriseConfig(Stub): + """WifiEnterpriseConfig — 企业级 WiFi 配置""" + + def __init__(self): + super().__init__() + self._identity: str = "" + self._password: str = "" + self._ca_cert: Optional[str] = None + self._client_cert: Optional[str] = None + self._subject_match: str = "" + self._alt_subject_match: str = "" + self._domain_suffix_match: str = "" + self._eap_method: int = -1 + self._phase2_method: int = -1 + + def setIdentity(self, identity: str): + self._identity = identity + + def getIdentity(self) -> str: + return self._identity + + def setPassword(self, password: str): + self._password = password + + def getPassword(self) -> str: + return self._password + + def setCaCertificate(self, cert: Any): + pass + + def getCaCertificate(self) -> Optional[Any]: + return None + + def setClientCertificate(self, cert: Any): + pass + + def getClientCertificate(self) -> Optional[Any]: + return None + + def setSubjectMatch(self, match: str): + self._subject_match = match + + def getSubjectMatch(self) -> str: + return self._subject_match + + def setDomainSuffixMatch(self, match: str): + self._domain_suffix_match = match + + def getDomainSuffixMatch(self) -> str: + return self._domain_suffix_match + + def toString(self) -> str: + return f"WifiEnterpriseConfig(identity={self._identity})" + + +# ═══════════════════════════════════════════════════════════════ +# WifiInfo +# ═══════════════════════════════════════════════════════════════ + +class WifiInfo(Stub): + """WifiInfo — WiFi 连接信息""" + + LINK_SPEED_UNITS = "Mbps" + STANDARD_LEGACY = 1 + STANDARD_11N = 4 + STANDARD_11AC = 5 + STANDARD_11AX = 6 + STANDARD_11BE = 7 + SECURITY_TYPE_OPEN = 0 + SECURITY_TYPE_WEP = 1 + SECURITY_TYPE_PSK = 2 + SECURITY_TYPE_EAP = 3 + SECURITY_TYPE_SAE = 4 + SECURITY_TYPE_OWE = 5 + SECURITY_TYPE_WAPI_PSK = 6 + SECURITY_TYPE_PASSPOINT_R1_R2 = 7 + SECURITY_TYPE_PASSPOINT_R3 = 8 + + INVALID_RSSI = -127 + DEFAULT_RSSI = -60 + + def __init__(self): + super().__init__() + self._ssid: str = "" + self._bssid: str = "00:00:00:00:00:00" + self._rssi: int = self.INVALID_RSSI + self._link_speed: int = 0 + self._frequency: int = 0 + self._ip_address: int = 0 + self._mac_address: str = "02:00:00:00:00:00" + self._network_id: int = -1 + self._supplicant_state: SupplicantState = SupplicantState(SupplicantState.DISCONNECTED) + self._wifi_standard: int = self.STANDARD_LEGACY + self._is_hidden_ssid: bool = False + self._tx_link_speed: int = 0 + self._rx_link_speed: int = 0 + self._max_rx_link_speed: int = 0 + self._max_tx_link_speed: int = 0 + self._security_type: int = self.SECURITY_TYPE_OPEN + self._rssi_timestamp: int = 0 + + def getSSID(self) -> str: + return self._ssid + + def getBSSID(self) -> str: + return self._bssid + + def getRssi(self) -> int: + return self._rssi + + def getLinkSpeed(self) -> int: + return self._link_speed + + def getFrequency(self) -> int: + return self._frequency + + def getIpAddress(self) -> int: + return self._ip_address + + def getMacAddress(self) -> str: + return self._mac_address + + def getNetworkId(self) -> int: + return self._network_id + + def getSupplicantState(self) -> SupplicantState: + return self._supplicant_state + + def getWifiStandard(self) -> int: + return self._wifi_standard + + def isHiddenSSID(self) -> bool: + return self._is_hidden_ssid + + def getTxLinkSpeedMbps(self) -> int: + return self._tx_link_speed + + def getRxLinkSpeedMbps(self) -> int: + return self._rx_link_speed + + def getMaxSupportedRxLinkSpeedMbps(self) -> int: + return self._max_rx_link_speed + + def getMaxSupportedTxLinkSpeedMbps(self) -> int: + return self._max_tx_link_speed + + def getSecurityType(self) -> int: + return self._security_type + + def getRssiTimestamp(self) -> int: + return self._rssi_timestamp + + def toString(self) -> str: + return (f"WifiInfo(SSID={self._ssid}, BSSID={self._bssid}, " + f"rssi={self._rssi}, speed={self._link_speed} {self.LINK_SPEED_UNITS})") + + def hashCode(self) -> int: + return hash(self._bssid) & 0x7FFFFFFF + + +# ═══════════════════════════════════════════════════════════════ +# ScanResult +# ═══════════════════════════════════════════════════════════════ + +class ScanResult(Stub): + """ScanResult — WiFi 扫描结果""" + + WIFI_BAND_24_GHZ = 0 + WIFI_BAND_5_GHZ = 1 + WIFI_BAND_6_GHZ = 2 + CHANNEL_WIDTH_20MHZ = 0 + CHANNEL_WIDTH_40MHZ = 1 + CHANNEL_WIDTH_80MHZ = 2 + CHANNEL_WIDTH_160MHZ = 3 + CHANNEL_WIDTH_80MHZ_PLUS_MHZ = 4 + + UNSPECIFIED = -1 + + def __init__(self): + super().__init__() + self.SSID: str = "" + self.BSSID: str = "" + self.capabilities: str = "" + self.level: int = 0 + self.frequency: int = 0 + self.timestamp: int = 0 + self.channelWidth: int = self.CHANNEL_WIDTH_20MHZ + self.centerFreq0: int = 0 + self.centerFreq1: int = 0 + self.operatorFriendlyName: str = "" + self.venueName: str = "" + self.is80211mcResponder: bool = False + self.isPasspointNetwork: bool = False + self._wifi_standard: int = 0 + self._seen: int = 0 + self._distance: Optional[float] = None + self._distance_sd: Optional[float] = None + + def getSSID(self) -> str: + return self.SSID + + def getBSSID(self) -> str: + return self.BSSID + + def getCapabilities(self) -> str: + return self.capabilities + + def getLevel(self) -> int: + return self.level + + def getFrequency(self) -> int: + return self.frequency + + def getTimestamp(self) -> int: + return self.timestamp + + def getChannelWidth(self) -> int: + return self.channelWidth + + def getCenterFreq0(self) -> int: + return self.centerFreq0 + + def getCenterFreq1(self) -> int: + return self.centerFreq1 + + def getOperatorFriendlyName(self) -> str: + return self.operatorFriendlyName + + def getVenueName(self) -> str: + return self.venueName + + def is80211mcResponder(self) -> bool: + return self.is80211mcResponder + + def isPasspointNetwork(self) -> bool: + return self.isPasspointNetwork + + def getWifiStandard(self) -> int: + return self._wifi_standard + + def getDistance(self) -> Optional[float]: + return self._distance + + def getDistanceSd(self) -> Optional[float]: + return self._distance_sd + + def toString(self) -> str: + return f"ScanResult(SSID={self.SSID}, BSSID={self.BSSID}, level={self.level})" + + +# ═══════════════════════════════════════════════════════════════ +# WifiNetworkSpecifier +# ═══════════════════════════════════════════════════════════════ + +class WifiNetworkSpecifier(Stub): + """WifiNetworkSpecifier — WiFi 网络说明符""" + + def __init__(self, ssid: Optional[str] = None, bssid: Optional[str] = None, + band: int = 0, security_type: int = 0): + super().__init__() + self._ssid = ssid + self._bssid = bssid + self._band = band + self._security_type = security_type + + def getSsid(self) -> Optional[str]: + return self._ssid + + def getBssid(self) -> Optional[str]: + return self._bssid + + def getBand(self) -> int: + return self._band + + def toString(self) -> str: + return f"WifiNetworkSpecifier(SSID={self._ssid})" + + +# ═══════════════════════════════════════════════════════════════ +# WifiNetworkSuggestion +# ═══════════════════════════════════════════════════════════════ + +class WifiNetworkSuggestion(Stub): + """WifiNetworkSuggestion — WiFi 网络建议""" + + def __init__(self, ssid: str = "", bssid: Optional[str] = None, + is_hidden: bool = False, priority: int = 0, + wpa2_passphrase: Optional[str] = None, + wpa3_passphrase: Optional[str] = None, + is_owe: bool = False): + super().__init__() + self._ssid = ssid + self._bssid = bssid + self._is_hidden = is_hidden + self._priority = priority + self._wpa2_passphrase = wpa2_passphrase + self._wpa3_passphrase = wpa3_passphrase + self._is_owe = is_owe + + def getSsid(self) -> str: + return self._ssid + + def getBssid(self) -> Optional[str]: + return self._bssid + + def isHidden(self) -> bool: + return self._is_hidden + + def getPriority(self) -> int: + return self._priority + + def toString(self) -> str: + return f"WifiNetworkSuggestion(SSID={self._ssid})" + + +# ═══════════════════════════════════════════════════════════════ +# WifiManager helpers +# ═══════════════════════════════════════════════════════════════ + +class WifiManagerMulticastLock(Stub): + """WifiManager.MulticastLock""" + + def __init__(self, tag: str): + super().__init__() + self._tag = tag + self._held = False + self._ref_count = 0 + + def acquire(self): + self._held = True + self._ref_count += 1 + + def release(self): + if self._ref_count > 0: + self._ref_count -= 1 + if self._ref_count == 0: + self._held = False + + def isHeld(self) -> bool: + return self._held + + def toString(self) -> str: + return f"MulticastLock(tag={self._tag}, held={self._held})" + + +class WifiManagerLocalOnlyHotspotCallback(Stub): + """WifiManager.LocalOnlyHotspotCallback""" + + ERROR_NO_CHANNEL = 1 + ERROR_GENERIC = 2 + ERROR_INCOMPATIBLE_MODE = 3 + ERROR_TETHERING_DISALLOWED = 4 + + def onStarted(self, hotspot: Any): + pass + + def onStopped(self): + pass + + def onFailed(self, reason: int): + pass + + +class WifiManagerWpsCallback(Stub): + """WifiManager.WpsCallback""" + + def onStarted(self, pin: str): + pass + + def onSucceeded(self): + pass + + def onFailed(self, reason: int): + pass + + +# ═══════════════════════════════════════════════════════════════ +# WifiManager +# ═══════════════════════════════════════════════════════════════ + +class WifiManager(Stub): + """WifiManager — WiFi 管理器""" + + WIFI_STATE_DISABLING = 0 + WIFI_STATE_DISABLED = 1 + WIFI_STATE_ENABLING = 2 + WIFI_STATE_ENABLED = 3 + WIFI_STATE_UNKNOWN = 4 + + WIFI_MODE_FULL = 1 + WIFI_MODE_FULL_HIGH_PERF = 3 + WIFI_MODE_SCAN_ONLY = 2 + + ERROR_AUTHENTICATING = 1 + SAP_START_FAILURE_GENERAL = 0 + + ACTION_PICK_WIFI_NETWORK = "android.net.wifi.PICK_WIFI_NETWORK" + SUPPLICANT_CONNECTION_CHANGE_ACTION = "android.net.wifi.supplicant.CONNECTION_CHANGE" + SUPPLICANT_STATE_CHANGED_ACTION = "android.net.wifi.SUPPLICANT_STATE_CHANGED" + NETWORK_STATE_CHANGED_ACTION = "android.net.wifi.STATE_CHANGE" + SCAN_RESULTS_AVAILABLE_ACTION = "android.net.wifi.SCAN_RESULTS" + WIFI_STATE_CHANGED_ACTION = "android.net.wifi.WIFI_STATE_CHANGED" + RSSI_CHANGED_ACTION = "android.net.wifi.RSSI_CHANGED" + NETWORK_IDS_CHANGED_ACTION = "android.net.wifi.NETWORK_IDS_CHANGED" + + def __init__(self): + super().__init__() + self._wifi_state = self.WIFI_STATE_ENABLED + self._wifi_enabled = True + self._connection_info: Optional[WifiInfo] = None + self._scan_results: List[ScanResult] = [] + self._configured_networks: List[WifiConfiguration] = [] + self._network_suggestions: List[WifiNetworkSuggestion] = [] + self._listeners: Dict[str, List[Any]] = {} + self._next_network_id = 0 + self._p2p_channels: List[int] = [] + + def getConnectionInfo(self) -> Optional[WifiInfo]: + if self._connection_info is None: + info = WifiInfo() + info._ssid = '"mock_wifi"' + info._bssid = "00:1A:2B:3C:4D:5E" + info._rssi = -55 + info._link_speed = 1300 + info._frequency = 5180 + info._network_id = 0 + info._supplicant_state = SupplicantState(SupplicantState.COMPLETED) + self._connection_info = info + return self._connection_info + + def getScanResults(self) -> List[ScanResult]: + return list(self._scan_results) + + def startScan(self) -> bool: + return True + + def setWifiEnabled(self, enabled: bool) -> bool: + self._wifi_enabled = enabled + self._wifi_state = self.WIFI_STATE_ENABLED if enabled else self.WIFI_STATE_DISABLED + return True + + def isWifiEnabled(self) -> bool: + return self._wifi_enabled + + def getWifiState(self) -> int: + return self._wifi_state + + def getConfiguredNetworks(self) -> List[WifiConfiguration]: + return list(self._configured_networks) + + def addNetwork(self, config: WifiConfiguration) -> int: + config.networkId = self._next_network_id + self._next_network_id += 1 + self._configured_networks.append(config) + return config.networkId + + def updateNetwork(self, config: WifiConfiguration) -> int: + for i, c in enumerate(self._configured_networks): + if c.networkId == config.networkId: + self._configured_networks[i] = config + return config.networkId + return -1 + + def removeNetwork(self, net_id: int) -> bool: + self._configured_networks = [ + c for c in self._configured_networks if c.networkId != net_id + ] + return True + + def enableNetwork(self, net_id: int, disable_others: bool = False) -> bool: + for c in self._configured_networks: + if c.networkId == net_id: + c.status = WifiConfiguration.Status.ENABLED + elif disable_others: + c.status = WifiConfiguration.Status.DISABLED + return True + + def disableNetwork(self, net_id: int) -> bool: + for c in self._configured_networks: + if c.networkId == net_id: + c.status = WifiConfiguration.Status.DISABLED + return True + + def disconnect(self) -> bool: + return True + + def reconnect(self) -> bool: + return True + + def reassociate(self) -> bool: + return True + + def is5GHzBandSupported(self) -> bool: + return True + + def is6GHzBandSupported(self) -> bool: + import sys + return sys.version_info >= (3, 10) + + def isEasyConnectSupported(self) -> bool: + return False + + def getP2pChannelList(self) -> List[int]: + return list(self._p2p_channels) + + def startLocalOnlyHotspot(self, callback: WifiManagerLocalOnlyHotspotCallback, handler: Any = None): + try: + callback.onStarted("MockHotspot") + except Exception: + pass + + def addNetworkSuggestions(self, suggestions: List[WifiNetworkSuggestion]) -> int: + self._network_suggestions.extend(suggestions) + return 0 # STATUS_SUGGESTION_SUCCESS + + def removeNetworkSuggestions(self, suggestions: List[WifiNetworkSuggestion]) -> int: + for s in suggestions: + self._network_suggestions = [x for x in self._network_suggestions if x is not s] + return 0 + + def createMulticastLock(self, tag: str) -> WifiManagerMulticastLock: + return WifiManagerMulticastLock(tag) + + def getDhcpInfo(self): + from .net import DhcpInfo + return DhcpInfo() + + def pingSupplicant(self) -> bool: + return True + + def startScanActive(self) -> bool: + return True + + def setScanAlwaysAvailable(self, enabled: bool): + pass + + def isScanAlwaysAvailable(self) -> bool: + return True + + def saveConfiguration(self) -> bool: + return True + + def toString(self) -> str: + return f"WifiManager(state={self._wifi_state})" + + +# ═══════════════════════════════════════════════════════════════ +# WifiP2pManager +# ═══════════════════════════════════════════════════════════════ + +class WifiP2pDevice(Stub): + """WifiP2pDevice — P2P 设备""" + + CONNECTED = 0 + INVITED = 1 + FAILED = 2 + AVAILABLE = 3 + UNAVAILABLE = 4 + + def __init__(self): + super().__init__() + self.deviceAddress: str = "" + self.deviceName: str = "" + self.primaryDeviceType: str = "" + self.secondaryDeviceType: str = "" + self.wpsConfigMethods: int = 0 + self.deviceCapability: int = 0 + self.groupCapability: int = 0 + self.status: int = self.UNAVAILABLE + self.GO_PORT: int = 0 + + def getDeviceAddress(self) -> str: + return self.deviceAddress + + def getDeviceName(self) -> str: + return self.deviceName + + def isServiceDiscoveryCapable(self) -> bool: + return True + + def isGroupOwner(self) -> bool: + return self.groupCapability > 0 + + def toString(self) -> str: + return f"WifiP2pDevice(name={self.deviceName}, addr={self.deviceAddress})" + + +class WifiP2pConfig(Stub): + """WifiP2pConfig — P2P 配置""" + + class Builder(Stub): + def __init__(self): + super().__init__() + self._device_address = "" + self._network_name = "" + self._passphrase = "" + self._group_owner_band = 0 + + def setDeviceAddress(self, addr: str) -> "WifiP2pConfig.Builder": + self._device_address = addr + return self + + def setNetworkName(self, name: str) -> "WifiP2pConfig.Builder": + self._network_name = name + return self + + def setPassphrase(self, passphrase: str) -> "WifiP2pConfig.Builder": + self._passphrase = passphrase + return self + + def setGroupOwnerBand(self, band: int) -> "WifiP2pConfig.Builder": + self._group_owner_band = band + return self + + def build(self) -> "WifiP2pConfig": + config = WifiP2pConfig() + config.deviceAddress = self._device_address + config.networkName = self._network_name + config.passphrase = self._passphrase + return config + + def __init__(self): + super().__init__() + self.deviceAddress: str = "" + self.networkName: str = "" + self.passphrase: str = "" + + +class WifiP2pGroup(Stub): + """WifiP2pGroup — P2P 群组""" + + def __init__(self): + super().__init__() + self._network_name: str = "" + self._is_group_owner: bool = False + self._owner: Optional[WifiP2pDevice] = None + self._clients: List[WifiP2pDevice] = [] + self._passphrase: str = "" + self._interface: str = "" + + def getNetworkName(self) -> str: + return self._network_name + + def isGroupOwner(self) -> bool: + return self._is_group_owner + + def getOwner(self) -> Optional[WifiP2pDevice]: + return self._owner + + def getClientList(self) -> List[WifiP2pDevice]: + return list(self._clients) + + def getPassphrase(self) -> str: + return self._passphrase + + def getInterface(self) -> str: + return self._interface + + def toString(self) -> str: + return f"WifiP2pGroup(name={self._network_name})" + + +class WifiP2pManager(Stub): + """WifiP2pManager — P2P 管理器""" + + WIFI_P2P_STATE_ENABLED_ACTION = "android.net.wifi.p2p.STATE_CHANGED" + WIFI_P2P_STATE_CHANGED_ACTION = "android.net.wifi.p2p.STATE_CHANGED" + WIFI_P2P_PEERS_CHANGED_ACTION = "android.net.wifi.p2p.PEERS_CHANGED" + WIFI_P2P_CONNECTION_CHANGED_ACTION = "android.net.wifi.p2p.CONNECTION_CHANGED" + WIFI_P2P_THIS_DEVICE_CHANGED_ACTION = "android.net.wifi.p2p.THIS_DEVICE_CHANGED" + WIFI_P2P_DISCOVERY_CHANGED_ACTION = "android.net.wifi.p2p.DISCOVERY_CHANGED" + + class Channel(Stub): + """P2P 通道""" + + def __init__(self): + super().__init__() + + def __init__(self): + super().__init__() + self._channel: Optional[WifiP2pManager.Channel] = None + self._peers: List[WifiP2pDevice] = [] + + def initialize(self, context: Any, looper: Any, listener: Any) -> "WifiP2pManager.Channel": + self._channel = WifiP2pManager.Channel() + if listener: + try: + listener.onSuccess() + except Exception: + pass + return self._channel + + def discoverPeers(self, channel: "WifiP2pManager.Channel", listener: Any): + if listener: + try: + listener.onSuccess() + except Exception: + pass + + def discoverServices(self, channel: "WifiP2pManager.Channel", listener: Any): + if listener: + try: + listener.onSuccess() + except Exception: + pass + + def requestPeers(self, channel: "WifiP2pManager.Channel", listener: Any): + if listener: + try: + listener.onPeersAvailable(self._peers) + except Exception: + pass + + def requestGroupInfo(self, channel: "WifiP2pManager.Channel", listener: Any): + if listener: + try: + listener.onGroupInfoAvailable(WifiP2pGroup()) + except Exception: + pass + + def createGroup(self, channel: "WifiP2pManager.Channel", listener: Any): + if listener: + try: + listener.onSuccess() + except Exception: + pass + + def removeGroup(self, channel: "WifiP2pManager.Channel", listener: Any): + if listener: + try: + listener.onSuccess() + except Exception: + pass + + def connect(self, channel: "WifiP2pManager.Channel", config: WifiP2pConfig, listener: Any): + if listener: + try: + listener.onSuccess() + except Exception: + pass + + def cancelConnect(self, channel: "WifiP2pManager.Channel", listener: Any): + if listener: + try: + listener.onSuccess() + except Exception: + pass + + def stopPeerDiscovery(self, channel: "WifiP2pManager.Channel", listener: Any): + if listener: + try: + listener.onSuccess() + except Exception: + pass + + def requestDeviceInfo(self, channel: "WifiP2pManager.Channel", device_address: str, listener: Any): + if listener: + try: + listener.onDeviceInfoAvailable(WifiP2pDevice()) + except Exception: + pass + + def setDeviceName(self, channel: "WifiP2pManager.Channel", device_name: str, listener: Any): + if listener: + try: + listener.onSuccess() + except Exception: + pass + + def setWfdEnabled(self, channel: "WifiP2pManager.Channel", enabled: bool, listener: Any): + pass + + def toString(self) -> str: + return f"WifiP2pManager(peers={len(self._peers)})" + + +# ═══════════════════════════════════════════════════════════════ +# WifiConfigurationKeyMgmt / WifiConfiguration... aliases +# ═══════════════════════════════════════════════════════════════ + +WifiConfigurationKeyMgmt = WifiConfiguration.KeyMgmt +WifiConfigurationGroupCipher = WifiConfiguration.GroupCipher +WifiConfigurationPairwiseCipher = WifiConfiguration.PairwiseCipher +WifiConfigurationAuthAlgorithm = WifiConfiguration.AuthAlgorithm +WifiConfigurationProtocol = WifiConfiguration.Protocol +WifiConfigurationStatus = WifiConfiguration.Status + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "WifiManager", + "WifiInfo", + "WifiConfiguration", + "WifiConfigurationKeyMgmt", + "WifiConfigurationGroupCipher", + "WifiConfigurationPairwiseCipher", + "WifiConfigurationAuthAlgorithm", + "WifiConfigurationProtocol", + "WifiConfigurationStatus", + "ScanResult", + "WifiSsid", + "SupplicantState", + "WifiEnterpriseConfig", + "WifiNetworkSpecifier", + "WifiNetworkSuggestion", + "WifiManagerLocalOnlyHotspotCallback", + "WifiManagerWpsCallback", + "WifiManagerMulticastLock", + "WifiP2pManager", + "WifiP2pDevice", + "WifiP2pConfig", + "WifiP2pGroup", +] \ No newline at end of file diff --git a/android_pyapi/android/nfc.py b/android_pyapi/android/nfc.py new file mode 100644 index 0000000..a747fe9 --- /dev/null +++ b/android_pyapi/android/nfc.py @@ -0,0 +1,390 @@ +""" +Android NFC 组件 — NfcAdapter, NfcManager, Tag, NdefMessage 等 +方法签名完全对齐 Android SDK +""" + +import os +import sys +from typing import Any, Dict, List, Optional, Set, Tuple, Union + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, + _sdcard_root, _app_data_dir, _package_name, +) + + +# ═══════════════════════════════════════════════════════════════ +# NdefRecord +# ═══════════════════════════════════════════════════════════════ + +class NdefRecord(Stub): + """NdefRecord — NDEF 记录""" + + TNF_ABSOLUTE_URI = 3 + TNF_EMPTY = 0 + TNF_EXTERNAL_TYPE = 4 + TNF_MIME_MEDIA = 2 + TNF_UNCHANGED = 6 + TNF_UNKNOWN = 5 + TNF_WELL_KNOWN = 1 + + RTD_URI = "U" + RTD_TEXT = "T" + RTD_SMART_POSTER = "Sp" + RTD_ALTERNATIVE_CARRIER = "ac" + RTD_HANDOVER_CARRIER = "Hc" + RTD_HANDOVER_REQUEST = "Hr" + RTD_HANDOVER_SELECT = "Hs" + + def __init__(self, tnf: int = TNF_EMPTY, type_: bytes = b"", + id_: bytes = b"", payload: bytes = b""): + super().__init__() + self._tnf = tnf + self._type = type_ + self._id = id_ + self._payload = payload + + @staticmethod + def createUri(uri_spec: str) -> "NdefRecord": + return NdefRecord(NdefRecord.TNF_ABSOLUTE_URI, + type_=uri_spec.encode("utf-8"), + payload=uri_spec.encode("utf-8")) + + @staticmethod + def createMime(mime_type: str, data: bytes) -> "NdefRecord": + return NdefRecord(NdefRecord.TNF_MIME_MEDIA, + type_=mime_type.encode("utf-8"), + payload=data) + + @staticmethod + def createExternal(domain: str, type_: str, data: bytes) -> "NdefRecord": + full_type = f"{domain}:{type_}" + return NdefRecord(NdefRecord.TNF_EXTERNAL_TYPE, + type_=full_type.encode("utf-8"), + payload=data) + + @staticmethod + def createApplicationRecord(package_name: str) -> "NdefRecord": + return NdefRecord(NdefRecord.TNF_EXTERNAL_TYPE, + type_=package_name.encode("utf-8"), + payload=package_name.encode("utf-8")) + + def getTnf(self) -> int: + return self._tnf + + def getType(self) -> bytes: + return self._type + + def getId(self) -> bytes: + return self._id + + def getPayload(self) -> bytes: + return self._payload + + def toByteArray(self) -> bytes: + import struct + tnf_byte = struct.pack("B", self._tnf & 0x07) + type_len = len(self._type) + id_len = len(self._id) + payload_len = len(self._payload) + header = struct.pack("BB", type_len, id_len) + return tnf_byte + header + struct.pack(">I", payload_len) + \ + self._type + self._id + self._payload + + def toString(self) -> str: + return f"NdefRecord(tnf={self._tnf}, type={self._type})" + + +# ═══════════════════════════════════════════════════════════════ +# NdefMessage +# ═══════════════════════════════════════════════════════════════ + +class NdefMessage(Stub): + """NdefMessage — NDEF 消息""" + + def __init__(self, records: Union[List[NdefRecord], bytes, Any]): + super().__init__() + if isinstance(records, list): + self._records = list(records) + elif isinstance(records, bytes): + self._records = [] + else: + self._records = [] + + def getRecords(self) -> List[NdefRecord]: + return list(self._records) + + def getByteArrayLength(self) -> int: + return sum(len(r.toByteArray()) for r in self._records) + + def toByteArray(self) -> bytes: + data = b"" + for r in self._records: + data += r.toByteArray() + return data + + +# ═══════════════════════════════════════════════════════════════ +# Tag +# ═══════════════════════════════════════════════════════════════ + +class Tag(Stub): + """Tag — NFC 标签""" + + def __init__(self, id_: bytes = b"", tech_list: Optional[List[str]] = None): + super().__init__() + self._id = id_ + self._tech_list = tech_list or [] + + def getId(self) -> bytes: + return self._id + + def getTechList(self) -> List[str]: + return list(self._tech_list) + + def getTechListParcelable(self) -> Any: + return TechListParcelable(self._tech_list) + + def toString(self) -> str: + return f"Tag(id={self._id.hex()}, techs={self._tech_list})" + + +class TechListParcelable(Stub): + """TechListParcelable — 技术列表包裹""" + + def __init__(self, tech_list: List[str]): + super().__init__() + self._tech_list = list(tech_list) + + def getTechList(self) -> List[str]: + return list(self._tech_list) + + def toString(self) -> str: + return f"TechListParcelable(techs={self._tech_list})" + + +# ═══════════════════════════════════════════════════════════════ +# NfcAdapter callback classes +# ═══════════════════════════════════════════════════════════════ + +class NfcAdapterCreateBeamUrisCallback(Stub): + def createBeamUris(self, event: "NfcEvent") -> List[Any]: + return [] + + +class NfcAdapterOnNdefPushCompleteCallback(Stub): + def onNdefPushComplete(self, event: "NfcEvent"): + pass + + +class NdefMessageCallback(Stub): + def createNdefMessage(self, event: "NfcEvent") -> Optional[NdefMessage]: + return None + + +# ═══════════════════════════════════════════════════════════════ +# NfcEvent +# ═══════════════════════════════════════════════════════════════ + +class NfcEvent(Stub): + """NfcEvent — NFC 事件""" + + def __init__(self, nfc_adapter: Any = None): + super().__init__() + self.nfcAdapter = nfc_adapter + + def getNfcAdapter(self) -> Any: + return self.nfcAdapter + + +# ═══════════════════════════════════════════════════════════════ +# NfcAntennaInfo / ApduServiceInfo / CardEmulation / NfcFCardEmulation +# ═══════════════════════════════════════════════════════════════ + +class NfcAntennaInfo(Stub): + """NfcAntennaInfo — NFC 天线信息""" + + def __init__(self, x: float = 0.0, y: float = 0.0): + super().__init__() + self._x = x + self._y = y + + def getX(self) -> float: + return self._x + + def getY(self) -> float: + return self._y + + +class ApduServiceInfo(Stub): + """ApduServiceInfo — APDU 服务信息""" + + def __init__(self, description: str = ""): + super().__init__() + self._description = description + + def getDescription(self) -> str: + return self._description + + +class CardEmulation(Stub): + """CardEmulation — 卡模拟""" + + CATEGORY_PAYMENT = "payment" + CATEGORY_OTHER = "other" + + SELECTION_TYPE_ASK_IF_CONFLICT = 1 + SELECTION_TYPE_PREFER_DEFAULT = 2 + SELECTION_TYPE_USER_PROMPTED = 0 + + +class NfcFCardEmulation(Stub): + """NfcFCardEmulation — NFC-F 卡模拟""" + + EXTRA_NFC_F_CARD_EMULATION_PARAMS = "android.nfc.extra.EXTRA_NFC_F_CARD_EMULATION_PARAMS" + + @staticmethod + def getInstance(nfc_adapter: Any) -> "NfcFCardEmulation": + return NfcFCardEmulation() + + def enableService(self, activity: Any, service: Any) -> bool: + return True + + def disableService(self, activity: Any, service: Any) -> bool: + return True + + def setSystemCodeForService(self, activity: Any, service: Any, system_code: str) -> bool: + return True + + +# ═══════════════════════════════════════════════════════════════ +# NfcManager +# ═══════════════════════════════════════════════════════════════ + +class NfcManager(Stub): + """NfcManager — NFC 管理器""" + + def __init__(self, context: Any = None): + super().__init__() + self._context = context + self._default_adapter: Optional["NfcAdapter"] = None + + def getDefaultAdapter(self) -> Optional["NfcAdapter"]: + if self._default_adapter is None: + self._default_adapter = NfcAdapter() + return self._default_adapter + + +# ═══════════════════════════════════════════════════════════════ +# NfcAdapter +# ═══════════════════════════════════════════════════════════════ + +class NfcAdapter(Stub): + """NfcAdapter — NFC 适配器""" + + ACTION_NDEF_DISCOVERED = "android.nfc.action.NDEF_DISCOVERED" + ACTION_TECH_DISCOVERED = "android.nfc.action.TECH_DISCOVERED" + ACTION_TAG_DISCOVERED = "android.nfc.action.TAG_DISCOVERED" + + FLAG_READER_NFC_A = 1 + FLAG_READER_NFC_B = 2 + FLAG_READER_NFC_F = 4 + FLAG_READER_NFC_V = 8 + FLAG_READER_NFC_BARCODE = 16 + FLAG_READER_SKIP_NDEF_CHECK = 128 + FLAG_READER_NO_PLATFORM_SOUNDS = 256 + + FLAG_NDEF_PUSH_NO_CONFIRM = 1 + + _default_adapter: Optional["NfcAdapter"] = None + + def __init__(self): + super().__init__() + self._enabled = True + self._ndef_push_message: Optional[NdefMessage] = None + self._ndef_push_callback: Optional[NdefMessageCallback] = None + self._push_complete_callback: Optional[NfcAdapterOnNdefPushCompleteCallback] = None + self._beam_uri_callback: Optional[NfcAdapterCreateBeamUrisCallback] = None + + @staticmethod + def getDefaultAdapter(context: Any = None) -> Optional["NfcAdapter"]: + if NfcAdapter._default_adapter is None: + NfcAdapter._default_adapter = NfcAdapter() + return NfcAdapter._default_adapter + + def isEnabled(self) -> bool: + return self._enabled + + def enable(self) -> bool: + self._enabled = True + return True + + def disable(self) -> bool: + self._enabled = False + return True + + def setNdefPushMessage(self, message: NdefMessage, activity: Any, + vararg_activities: Any = None): + self._ndef_push_message = message + + def setNdefPushMessageCallback(self, callback: NdefMessageCallback, activity: Any, + vararg_activities: Any = None): + self._ndef_push_callback = callback + + def setOnNdefPushCompleteCallback(self, callback: NfcAdapterOnNdefPushCompleteCallback, + activity: Any, vararg_activities: Any = None): + self._push_complete_callback = callback + + def setBeamUrisCallback(self, callback: NfcAdapterCreateBeamUrisCallback, activity: Any): + self._beam_uri_callback = callback + + def enableForegroundDispatch(self, activity: Any, intent: Any, + filters: Any, tech_lists: Any): + pass + + def disableForegroundDispatch(self, activity: Any): + pass + + def enableReaderMode(self, activity: Any, callback: Any, flags: int, extras: Any = None): + pass + + def disableReaderMode(self, activity: Any): + pass + + def invokeBeam(self, activity: Any) -> bool: + return True + + def isSecureNfcSupported(self) -> bool: + return False + + def isSecureNfcEnabled(self) -> bool: + return False + + def enableSecureNfc(self, enable: bool) -> bool: + return True + + def toString(self) -> str: + return f"NfcAdapter(enabled={self._enabled})" + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "NfcAdapter", + "NfcManager", + "Tag", + "NdefMessage", + "NdefRecord", + "NfcEvent", + "NfcAdapterCreateBeamUrisCallback", + "NfcAdapterOnNdefPushCompleteCallback", + "NdefMessageCallback", + "TechListParcelable", + "NfcAntennaInfo", + "ApduServiceInfo", + "CardEmulation", + "NfcFCardEmulation", +] \ No newline at end of file diff --git a/android_pyapi/android/os.py b/android_pyapi/android/os.py new file mode 100644 index 0000000..0eb3e02 --- /dev/null +++ b/android_pyapi/android/os.py @@ -0,0 +1,1660 @@ +""" +Android OS 组件 — Bundle, Handler, Looper, Message, Build 等 +方法签名完全对齐 Android SDK +""" + +import asyncio +import functools +import heapq +import os as _os +import sys +import threading +import time as _time +from datetime import datetime +from typing import Any, Callable, Dict, List, Optional, Set, Tuple, TypeVar, Union + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, + _sdcard_root, _app_data_dir, _package_name, + HAS_PSUTIL, +) + + +# ═══════════════════════════════════════════════════════════════ +# Build +# ═══════════════════════════════════════════════════════════════ + +class Build(Stub): + """Build — 设备信息""" + + class VERSION(Stub): + """版本信息""" + SDK_INT = 34 # Android 14 + RELEASE = "14" + INCREMENTAL = "20240301" + CODENAME = "REL" + SECURITY_PATCH = "2024-03-05" + BASE_OS = "" + PREVIEW_SDK_INT = 0 + RESOURCES_SDK_INT = 34 + MEDIA_PERFORMANCE_CLASS = 0 + + class VERSION_CODES(Stub): + """版本代码常量""" + BASE = 1 + BASE_1_1 = 2 + CUPCAKE = 3 + DONUT = 4 + ECLAIR = 5 + ECLAIR_0_1 = 6 + ECLAIR_MR1 = 7 + FROYO = 8 + GINGERBREAD = 9 + GINGERBREAD_MR1 = 10 + HONEYCOMB = 11 + HONEYCOMB_MR1 = 12 + HONEYCOMB_MR2 = 13 + ICE_CREAM_SANDWICH = 14 + ICE_CREAM_SANDWICH_MR1 = 15 + JELLY_BEAN = 16 + JELLY_BEAN_MR1 = 17 + JELLY_BEAN_MR2 = 18 + KITKAT = 19 + KITKAT_WATCH = 20 + LOLLIPOP = 21 + LOLLIPOP_MR1 = 22 + M = 23 + N = 24 + N_MR1 = 25 + O = 26 + O_MR1 = 27 + P = 28 + Q = 29 + R = 30 + S = 31 + S_V2 = 32 + TIRAMISU = 33 + UPSIDE_DOWN_CAKE = 34 + + VERSION = VERSION() + BOARD = "redfin" + BOOTLOADER = "r7.0-12345" + BRAND = "google" + CPU_ABI = "arm64-v8a" + CPU_ABI2 = "" + DEVICE = "redfin" + DISPLAY = "AP1A.240305.001" + FINGERPRINT = "google/redfin/redfin:14/AP1A.240305.001/12345678:user/release-keys" + HARDWARE = "redfin" + HOST = "build-test-01" + ID = "AP1A.240305.001" + MANUFACTURER = "Google" + MODEL = "Pixel 5" + ODM_SKU = None + PRODUCT = "redfin" + RADIO = "" + SERIAL = "unknown" + SKU = None + SOC_MANUFACTURER = "Qualcomm" + SOC_MODEL = "Snapdragon 765G" + SUPPORTED_32_BIT_ABIS = ["armeabi-v7a", "armeabi"] + SUPPORTED_64_BIT_ABIS = ["arm64-v8a"] + SUPPORTED_ABIS = ["arm64-v8a", "armeabi-v7a", "armeabi"] + TAGS = "release-keys" + TIME = int(_time.time() * 1000) + TYPE = "user" + USER = "build-user" + + @staticmethod + def getRadioVersion() -> str: + return "" + + @staticmethod + def getSerial() -> str: + return "unknown" + + @staticmethod + def getFingerprint() -> str: + return Build.FINGERPRINT + + +# ═══════════════════════════════════════════════════════════════ +# SystemClock +# ═══════════════════════════════════════════════════════════════ + +class SystemClock(Stub): + """SystemClock — 系统时钟""" + + @staticmethod + def elapsedRealtime() -> int: + """返回自启动以来的毫秒数""" + return int(_time.monotonic() * 1000) + + @staticmethod + def elapsedRealtimeNanos() -> int: + return int(_time.monotonic_ns()) + + @staticmethod + def uptimeMillis() -> int: + """返回自启动以来（不含深度睡眠）的毫秒数""" + return int(_time.monotonic() * 1000) + + @staticmethod + def currentThreadTimeMillis() -> int: + return int(_time.clock_gettime(_time.CLOCK_THREAD_CPUTIME_ID) * 1000) + + @staticmethod + def sleep(ms: int): + _time.sleep(ms / 1000.0) + + @staticmethod + def setCurrentTimeMillis(millis: int) -> bool: + return False + + +# ═══════════════════════════════════════════════════════════════ +# Environment +# ═══════════════════════════════════════════════════════════════ + +class Environment(Stub): + """Environment — 环境目录""" + + MEDIA_BAD_REMOVAL = "bad_removal" + MEDIA_CHECKING = "checking" + MEDIA_EJECTING = "ejecting" + MEDIA_MOUNTED = "mounted" + MEDIA_MOUNTED_READ_ONLY = "mounted_ro" + MEDIA_NOFS = "nofs" + MEDIA_REMOVED = "removed" + MEDIA_SHARED = "shared" + MEDIA_UNKNOWN = "unknown" + MEDIA_UNMOUNTABLE = "unmountable" + MEDIA_UNMOUNTED = "unmounted" + + DIRECTORY_ALARMS = "Alarms" + DIRECTORY_DCIM = "DCIM" + DIRECTORY_DOCUMENTS = "Documents" + DIRECTORY_DOWNLOADS = "Download" + DIRECTORY_MOVIES = "Movies" + DIRECTORY_MUSIC = "Music" + DIRECTORY_NOTIFICATIONS = "Notifications" + DIRECTORY_PICTURES = "Pictures" + DIRECTORY_PODCASTS = "Podcasts" + DIRECTORY_RINGTONES = "Ringtones" + DIRECTORY_AUDIOBOOKS = "Audiobooks" + DIRECTORY_SCREENSHOTS = "Screenshots" + + @staticmethod + def getExternalStorageDirectory() -> str: + return _sdcard_root + + @staticmethod + def getExternalStoragePublicDirectory(type_: str) -> str: + path = _os.path.join(_sdcard_root, type_) + _os.makedirs(path, exist_ok=True) + return path + + @staticmethod + def getDataDirectory() -> str: + return _os.path.join(_app_data_dir, "data") + + @staticmethod + def getDownloadCacheDirectory() -> str: + return _os.path.join(_app_data_dir, "cache", "download") + + @staticmethod + def getRootDirectory() -> str: + return _os.path.abspath(_os.sep) + + @staticmethod + def getStorageDirectory(user_handle: Any = None) -> str: + return _sdcard_root + + @staticmethod + def getExternalStorageState(path: Optional[str] = None) -> str: + return Environment.MEDIA_MOUNTED + + @staticmethod + def isExternalStorageRemovable(path: Optional[str] = None) -> bool: + return False + + @staticmethod + def isExternalStorageEmulated(path: Optional[str] = None) -> bool: + return True + + @staticmethod + def isExternalStorageLegacy(path: Optional[str] = None) -> bool: + return True + + +# ═══════════════════════════════════════════════════════════════ +# Process +# ═══════════════════════════════════════════════════════════════ + +class Process(Stub): + """Process — 进程信息""" + + # 进程优先级 + THREAD_PRIORITY_DEFAULT = 0 + THREAD_PRIORITY_LOWEST = -19 + THREAD_PRIORITY_BACKGROUND = 10 + THREAD_PRIORITY_FOREGROUND = -2 + THREAD_PRIORITY_DISPLAY = -4 + THREAD_PRIORITY_URGENT_DISPLAY = -8 + THREAD_PRIORITY_AUDIO = -16 + THREAD_PRIORITY_URGENT_AUDIO = -19 + THREAD_PRIORITY_MORE_FAVORABLE = -1 + THREAD_PRIORITY_LESS_FAVORABLE = 1 + + SIGNAL_KILL = 9 + SIGNAL_QUIT = 3 + SIGNAL_USR1 = 10 + SIGNAL_USR2 = 12 + + @staticmethod + def myTid() -> int: + return threading.get_ident() + + @staticmethod + def myUid() -> int: + return 10001 + + @staticmethod + def myPid() -> int: + return _os.getpid() + + @staticmethod + def killProcess(pid: int): + pass + + @staticmethod + def sendSignal(pid: int, signal: int): + pass + + @staticmethod + def setThreadPriority(priority: int): + pass + + @staticmethod + def setThreadPriority(tid: int, priority: int): + pass + + @staticmethod + def getElapsedCpuTime() -> int: + return int(_time.clock_gettime(_time.CLOCK_PROCESS_CPUTIME_ID) * 1000) + + @staticmethod + def supportsProcesses() -> bool: + return True + + +# ═══════════════════════════════════════════════════════════════ +# BaseBundle / PersistableBundle +# ═══════════════════════════════════════════════════════════════ + +class BaseBundle(Stub): + """BaseBundle — Bundle 基类""" + + def __init__(self): + super().__init__() + self._map: Dict[str, Any] = {} + self._class_loader = None + + def getString(self, key: str, default: Optional[str] = None) -> Optional[str]: + v = self._map.get(key, default) + return str(v) if v is not None else default + + def getInt(self, key: str, default: int = 0) -> int: + v = self._map.get(key, default) + try: + return int(v) if v is not None else default + except (ValueError, TypeError): + return default + + def getLong(self, key: str, default: int = 0) -> int: + return self.getInt(key, default) + + def getFloat(self, key: str, default: float = 0.0) -> float: + v = self._map.get(key, default) + try: + return float(v) if v is not None else default + except (ValueError, TypeError): + return default + + def getDouble(self, key: str, default: float = 0.0) -> float: + return self.getFloat(key, default) + + def getBoolean(self, key: str, default: bool = False) -> bool: + v = self._map.get(key, default) + if isinstance(v, bool): + return v + if isinstance(v, str): + return v.lower() in ("true", "1", "yes") + return bool(v) if v is not None else default + + def getByte(self, key: str, default: int = 0) -> int: + return self.getInt(key, default) + + def getChar(self, key: str, default: str = "") -> str: + return str(self._map.get(key, default)) + + def getShort(self, key: str, default: int = 0) -> int: + return self.getInt(key, default) + + def getCharSequence(self, key: str, default: Optional[str] = None) -> Optional[str]: + return self.getString(key, default) + + def getSerializable(self, key: str, default: Any = None) -> Any: + return self._map.get(key, default) + + def getStringArrayList(self, key: str) -> Optional[List[str]]: + v = self._map.get(key) + if isinstance(v, list): + return [str(x) for x in v] + return None + + def getIntegerArrayList(self, key: str) -> Optional[List[int]]: + v = self._map.get(key) + if isinstance(v, list): + return [int(x) for x in v if isinstance(x, (int, float))] + return None + + def containsKey(self, key: str) -> bool: + return key in self._map + + def isEmpty(self) -> bool: + return len(self._map) == 0 + + def size(self) -> int: + return len(self._map) + + def clear(self): + self._map.clear() + + def keySet(self) -> Set[str]: + return set(self._map.keys()) + + def hasKey(self, key: str) -> bool: + return key in self._map + + def toString(self) -> str: + return f"Bundle({self._map})" + + def __len__(self) -> int: + return len(self._map) + + def __contains__(self, key: str) -> bool: + return key in self._map + + def __getitem__(self, key: str): + return self._map[key] + + def __setitem__(self, key: str, value: Any): + self._map[key] = value + + def __delitem__(self, key: str): + self._map.pop(key, None) + + +class PersistableBundle(BaseBundle): + """PersistableBundle — 可持久化的 Bundle""" + + def __init__(self, capacity: int = 0): + super().__init__() + + def putPersistableBundle(self, key: str, value: "PersistableBundle"): + self._map[key] = value + + def getPersistableBundle(self, key: str) -> Optional["PersistableBundle"]: + v = self._map.get(key) + return v if isinstance(v, PersistableBundle) else None + + +# ═══════════════════════════════════════════════════════════════ +# Bundle +# ═══════════════════════════════════════════════════════════════ + +class Bundle(BaseBundle): + """Bundle — 键值对数据容器""" + + EMPTY: "Bundle" = None # 在类加载后初始化 + + def __init__(self, capacity: int = 0): + super().__init__() + self._capacity = capacity + + def putString(self, key: str, value: Optional[str]): + self._map[key] = value + + def putInt(self, key: str, value: int): + self._map[key] = value + + def putLong(self, key: str, value: int): + self._map[key] = value + + def putFloat(self, key: str, value: float): + self._map[key] = value + + def putDouble(self, key: str, value: float): + self._map[key] = value + + def putBoolean(self, key: str, value: bool): + self._map[key] = value + + def putByte(self, key: str, value: int): + self._map[key] = value + + def putChar(self, key: str, value: str): + self._map[key] = value + + def putShort(self, key: str, value: int): + self._map[key] = value + + def putCharSequence(self, key: str, value: Optional[str]): + self._map[key] = value + + def putSerializable(self, key: str, value: Any): + self._map[key] = value + + def putParcelable(self, key: str, value: Any): + self._map[key] = value + + def putStringArrayList(self, key: str, value: Optional[List[str]]): + self._map[key] = value + + def putIntegerArrayList(self, key: str, value: Optional[List[int]]): + self._map[key] = value + + def putAll(self, bundle: "Bundle"): + if bundle: + self._map.update(bundle._map) + + def getParcelable(self, key: str, default: Any = None) -> Any: + return self._map.get(key, default) + + def getBundle(self, key: str) -> Optional["Bundle"]: + v = self._map.get(key) + return v if isinstance(v, Bundle) else None + + def putBundle(self, key: str, value: Optional["Bundle"]): + self._map[key] = value + + def describeContents(self) -> int: + return 0 + + def clone(self) -> "Bundle": + b = Bundle() + b._map = dict(self._map) + return b + + def deepCopy(self) -> "Bundle": + import copy + b = Bundle() + b._map = copy.deepcopy(self._map) + return b + + def filterValues(self): + pass + + def getPairValue(self) -> Optional[str]: + return None + + def setClassLoader(self, loader: Any): + self._class_loader = loader + + def getClassLoader(self) -> Any: + return self._class_loader + + @staticmethod + def forPair(key: str, value: str) -> "Bundle": + b = Bundle() + b.putString(key, value) + return b + + +Bundle.EMPTY = Bundle() + + +# ═══════════════════════════════════════════════════════════════ +# Parcel / Parcelable +# ═══════════════════════════════════════════════════════════════ + +class Parcelable(Stub): + """Parcelable 接口""" + + CONTENTS_FILE_DESCRIPTOR = "CONTENTS_FILE_DESCRIPTOR" + PARCELABLE_WRITE_RETURN_VALUE = 1 + PARCELABLE_ELIDE_DUPLICATES = 2 + + def describeContents(self) -> int: + return 0 + + def writeToParcel(self, dest: "Parcel", flags: int): + pass + + class Creator: + def createFromParcel(self, source: "Parcel"): + return None + def newArray(self, size: int): + return [None] * size + + class ClassLoaderCreator: + def createFromParcel(self, source: "Parcel", loader: Any): + return None + def newArray(self, size: int): + return [None] * size + + +class Parcel(Stub): + """Parcel — 序列化数据容器""" + + STRING_CREATOR = "STRING_CREATOR" + STRING_LIST_CREATOR = "STRING_LIST_CREATOR" + INT_CREATOR = "INT_CREATOR" + + def __init__(self): + super().__init__() + self._data: Dict[str, Any] = {} + self._position = 0 + self._size = 0 + + @staticmethod + def obtain() -> "Parcel": + return Parcel() + + def recycle(self): + self._data.clear() + self._position = 0 + self._size = 0 + + def writeInt(self, value: int): + self._data.setdefault("_ints", []).append(value) + self._size += 4 + + def writeLong(self, value: int): + self._data.setdefault("_longs", []).append(value) + self._size += 8 + + def writeFloat(self, value: float): + self._data.setdefault("_floats", []).append(value) + self._size += 4 + + def writeDouble(self, value: float): + self._data.setdefault("_doubles", []).append(value) + self._size += 8 + + def writeString(self, value: Optional[str]): + strs = self._data.setdefault("_strings", []) + strs.append(value) + self._size += len(value) + 4 if value else 4 + + def writeBoolean(self, value: bool): + self.writeInt(1 if value else 0) + + def writeByte(self, value: int): + self.writeInt(value & 0xFF) + + def writeParcelable(self, p: Parcelable, flags: int): + pass + + def writeStringArray(self, values: Optional[List[str]]): + self._data["_string_array"] = values + + def writeIntArray(self, values: Optional[List[int]]): + self._data["_int_array"] = values + + def writeLongArray(self, values: Optional[List[int]]): + self._data["_long_array"] = values + + def readInt(self) -> int: + ints = self._data.get("_ints", []) + if ints: + return ints.pop(0) + return 0 + + def readLong(self) -> int: + longs = self._data.get("_longs", []) + if longs: + return longs.pop(0) + return 0 + + def readFloat(self) -> float: + floats = self._data.get("_floats", []) + if floats: + return floats.pop(0) + return 0.0 + + def readDouble(self) -> float: + doubles = self._data.get("_doubles", []) + if doubles: + return doubles.pop(0) + return 0.0 + + def readString(self) -> Optional[str]: + strs = self._data.get("_strings", []) + if strs: + return strs.pop(0) + return None + + def readBoolean(self) -> bool: + return self.readInt() != 0 + + def readByte(self) -> int: + return self.readInt() & 0xFF + + def dataAvail(self) -> int: + return self._size - self._position + + def dataPosition(self) -> int: + return self._position + + def setDataPosition(self, pos: int): + self._position = pos + + def dataSize(self) -> int: + return self._size + + def dataCapacity(self) -> int: + return self._size + + def setDataCapacity(self, capacity: int): + pass + + def appendFrom(self, parcel: "Parcel", offset: int, length: int): + pass + + def marshall(self) -> bytes: + import json + return json.dumps(self._data).encode("utf-8") + + @staticmethod + def unmarshall(data: bytes) -> "Parcel": + import json + p = Parcel() + try: + p._data = json.loads(data.decode("utf-8")) + except Exception: + pass + return p + + def writeValue(self, v: Any): + self._data["_value"] = v + + def readValue(self) -> Any: + return self._data.get("_value") + + def hasFileDescriptors(self) -> bool: + return False + + def toString(self) -> str: + return f"Parcel({self._size} bytes)" + + +# ═══════════════════════════════════════════════════════════════ +# Message +# ═══════════════════════════════════════════════════════════════ + +class Message(Stub): + """Message — Handler 消息""" + + def __init__(self): + super().__init__() + self.what = 0 + self.arg1 = 0 + self.arg2 = 0 + self.obj: Any = None + self.data: Optional[Bundle] = None + self.replyTo: Optional["Messenger"] = None + self._target: Optional["Handler"] = None + self._callback: Optional[Callable] = None + self.when: int = 0 + self._sending = False + + @staticmethod + def obtain(handler: Optional["Handler"] = None, what: int = 0) -> "Message": + msg = Message() + if handler: + msg._target = handler + msg.what = what + return msg + + def sendToTarget(self): + if self._target: + self._target.sendMessage(self) + + def getTarget(self) -> Optional["Handler"]: + return self._target + + def setTarget(self, handler: "Handler"): + self._target = handler + + def getCallback(self) -> Optional[Callable]: + return self._callback + + def copyFrom(self, other: "Message"): + self.what = other.what + self.arg1 = other.arg1 + self.arg2 = other.arg2 + self.obj = other.obj + self.data = other.data + self.replyTo = other.replyTo + + def recycle(self): + self.what = 0 + self.arg1 = 0 + self.arg2 = 0 + self.obj = None + self.data = None + self._target = None + self._callback = None + + def isAsynchronous(self) -> bool: + return False + + def setAsynchronous(self, async_: bool): + pass + + def toString(self) -> str: + return f"Message(what={self.what}, arg1={self.arg1}, arg2={self.arg2})" + + +# ═══════════════════════════════════════════════════════════════ +# Looper +# ═══════════════════════════════════════════════════════════════ + +class Looper(Stub): + """Looper — 消息循环""" + + _main_looper: Optional["Looper"] = None + _thread_local = threading.local() + + def __init__(self): + super().__init__() + self._thread = threading.current_thread() + self._running = False + self._message_queue: List[Message] = [] + self._quit_allowed = True + + @staticmethod + def prepare(): + looper = Looper() + Looper._thread_local.looper = looper + return looper + + @staticmethod + def prepareMainLooper(): + if Looper._main_looper is None: + Looper._main_looper = Looper.prepare() + + @staticmethod + def getMainLooper() -> "Looper": + if Looper._main_looper is None: + Looper.prepareMainLooper() + return Looper._main_looper + + @staticmethod + def myLooper() -> Optional["Looper"]: + return getattr(Looper._thread_local, "looper", None) + + @staticmethod + def loop(): + looper = Looper.myLooper() + if looper is None: + raise RuntimeError("No Looper prepared") + looper._running = True + + def quit(self): + self._running = False + + def quitSafely(self): + self._running = False + + def isCurrentThread(self) -> bool: + return threading.current_thread() == self._thread + + def getThread(self) -> threading.Thread: + return self._thread + + def getQueue(self): + return self._message_queue + + def dump(self, pw: Any, prefix: str): + pass + + def toString(self) -> str: + return f"Looper({self._thread.name})" + + +# ═══════════════════════════════════════════════════════════════ +# Handler +# ═══════════════════════════════════════════════════════════════ + +class Handler(Stub): + """Handler — 消息处理器""" + + def __init__(self, looper: Optional[Looper] = None, callback: Optional[Callable] = None): + super().__init__() + self._looper = looper or Looper.getMainLooper() + self._callback = callback + self._async = False + + def handleMessage(self, msg: Message): + pass + + def dispatchMessage(self, msg: Message): + if msg._callback: + msg._callback() + elif self._callback: + self._callback(msg) + else: + self.handleMessage(msg) + + def post(self, r: Callable) -> bool: + msg = Message.obtain(self) + msg._callback = r + return self.sendMessage(msg) + + def postDelayed(self, r: Callable, delay_ms: int) -> bool: + msg = Message.obtain(self) + msg._callback = r + msg.when = int(_time.time() * 1000) + delay_ms + return self.sendMessageDelayed(msg, delay_ms) + + def postAtTime(self, r: Callable, uptime_ms: int) -> bool: + msg = Message.obtain(self) + msg._callback = r + msg.when = uptime_ms + return self.sendMessageAtTime(msg, uptime_ms) + + def sendMessage(self, msg: Message) -> bool: + msg._target = self + self.dispatchMessage(msg) + return True + + def sendEmptyMessage(self, what: int) -> bool: + msg = Message.obtain(self, what) + return self.sendMessage(msg) + + def sendMessageDelayed(self, msg: Message, delay_ms: int) -> bool: + msg._target = self + msg.when = int(_time.time() * 1000) + delay_ms + self.dispatchMessage(msg) + return True + + def sendMessageAtTime(self, msg: Message, uptime_ms: int) -> bool: + msg._target = self + msg.when = uptime_ms + self.dispatchMessage(msg) + return True + + def sendMessageAtFrontOfQueue(self, msg: Message) -> bool: + msg._target = self + self.dispatchMessage(msg) + return True + + def removeCallbacks(self, r: Callable): + pass + + def removeMessages(self, what: int): + pass + + def obtainMessage(self, what: int = 0) -> Message: + return Message.obtain(self, what) + + def hasMessages(self, what: int) -> bool: + return False + + def getLooper(self) -> Looper: + return self._looper + + def toString(self) -> str: + return f"Handler({self.__class__.__name__})" + + +# ═══════════════════════════════════════════════════════════════ +# HandlerThread +# ═══════════════════════════════════════════════════════════════ + +class HandlerThread(threading.Thread, Stub): + """HandlerThread — 带 Looper 的工作线程""" + + def __init__(self, name: str, priority: int = Process.THREAD_PRIORITY_DEFAULT): + super().__init__() + Stub.__init__(self) + self._name = name + self._priority = priority + self._looper: Optional[Looper] = None + self._started = threading.Event() + + def run(self): + Looper.prepare() + self._looper = Looper.myLooper() + self._started.set() + Looper.loop() + + def getLooper(self) -> Optional[Looper]: + self._started.wait() + return self._looper + + def getThreadId(self) -> int: + return self.ident or 0 + + def quit(self) -> bool: + if self._looper: + self._looper.quit() + return True + return False + + def quitSafely(self) -> bool: + return self.quit() + + +# ═══════════════════════════════════════════════════════════════ +# AsyncTask +# ═══════════════════════════════════════════════════════════════ + +class AsyncTask(Stub): + """AsyncTask — 异步任务""" + + Status = type("Status", (), {"PENDING": 0, "RUNNING": 1, "FINISHED": 2}) + + SERIAL_EXECUTOR = None + THREAD_POOL_EXECUTOR = None + + def __init__(self): + super().__init__() + self._status = AsyncTask.Status.PENDING + self._result: Any = None + self._cancelled = False + + def doInBackground(self, *params) -> Any: + raise NotImplementedError + + def onPreExecute(self): + pass + + def onPostExecute(self, result: Any): + pass + + def onProgressUpdate(self, *values): + pass + + def onCancelled(self, result: Any = None): + pass + + def execute(self, *params) -> "AsyncTask": + self._status = AsyncTask.Status.RUNNING + self.onPreExecute() + try: + self._result = self.doInBackground(*params) + except Exception as e: + self._result = e + self._status = AsyncTask.Status.FINISHED + if not self._cancelled: + self.onPostExecute(self._result) + return self + + def executeOnExecutor(self, exec: Any, *params) -> "AsyncTask": + return self.execute(*params) + + def get(self) -> Any: + return self._result + + def getStatus(self) -> int: + return self._status + + def isCancelled(self) -> bool: + return self._cancelled + + def cancel(self, may_interrupt_if_running: bool) -> bool: + self._cancelled = True + return True + + def publishProgress(self, *values): + self.onProgressUpdate(*values) + + +# ═══════════════════════════════════════════════════════════════ +# CountDownTimer +# ═══════════════════════════════════════════════════════════════ + +class CountDownTimer(Stub): + """CountDownTimer — 倒计时""" + + def __init__(self, millis_in_future: int, count_down_interval: int): + super().__init__() + self._millis_in_future = millis_in_future + self._interval = count_down_interval + self._cancelled = False + + def onTick(self, millis_until_finished: int): + pass + + def onFinish(self): + pass + + def start(self) -> "CountDownTimer": + self._cancelled = False + remaining = self._millis_in_future + while remaining > 0 and not self._cancelled: + self.onTick(remaining) + _time.sleep(self._interval / 1000.0) + remaining -= self._interval + if not self._cancelled: + self.onFinish() + return self + + def cancel(self): + self._cancelled = True + + +# ═══════════════════════════════════════════════════════════════ +# Messenger +# ═══════════════════════════════════════════════════════════════ + +class Messenger(Stub): + """Messenger — 跨进程消息传递""" + + def __init__(self, handler: Handler): + super().__init__() + self._handler = handler + + def send(self, message: Message): + self._handler.sendMessage(message) + + def getBinder(self): + return None + + @staticmethod + def obtain(handler: Handler) -> "Messenger": + return Messenger(handler) + + +# ═══════════════════════════════════════════════════════════════ +# PowerManager / PowerManagerWakeLock +# ═══════════════════════════════════════════════════════════════ + +class PowerManager(Stub): + """PowerManager — 电源管理""" + + ACQUIRE_CAUSES_WAKEUP = 0x10000000 + DOZE_WAKE_LOCK = 0x00000040 + DRAW_WAKE_LOCK = 0x00000080 + FULL_WAKE_LOCK = 0x0000001A + LOCATION_HARDWARE_POWER_MODE = 0x00000080 + ON_AFTER_RELEASE = 0x20000000 + PARTIAL_WAKE_LOCK = 0x00000001 + PROXIMITY_SCREEN_OFF_WAKE_LOCK = 0x00000020 + SCREEN_BRIGHT_WAKE_LOCK = 0x0000000A + SCREEN_DIM_WAKE_LOCK = 0x00000006 + WAKE_LOCK_LEVEL_MASK = 0x0000FFFF + + def __init__(self): + super().__init__() + self._is_interactive = True + self._is_power_save = False + self._is_device_idle = False + + def newWakeLock(self, level_and_flags: int, tag: str) -> "PowerManagerWakeLock": + return PowerManagerWakeLock(level_and_flags, tag) + + def isInteractive(self) -> bool: + return self._is_interactive + + def isPowerSaveMode(self) -> bool: + return self._is_power_save + + def isDeviceIdleMode(self) -> bool: + return self._is_device_idle + + def isIgnoringBatteryOptimizations(self, package_name: str) -> bool: + return True + + def isSustainedPerformanceModeSupported(self) -> bool: + return False + + def reboot(self, reason: Optional[str] = None): + pass + + def goToSleep(self, time_ms: int): + pass + + def wakeUp(self, time_ms: int): + pass + + def userActivity(self, when: int, no_change_lights: bool = False): + pass + + +class PowerManagerWakeLock(Stub): + """PowerManagerWakeLock — 唤醒锁""" + + def __init__(self, level_and_flags: int, tag: str): + super().__init__() + self._level_and_flags = level_and_flags + self._tag = tag + self._held = False + self._work_source = None + self._history_tag = None + + def acquire(self, timeout_ms: int = 0): + self._held = True + sys.stderr.write(f"[PowerManager] acquire wakelock: {self._tag}\n") + + def acquireLocked(self): + self._held = True + + def release(self, flags: int = 0): + self._held = False + sys.stderr.write(f"[PowerManager] release wakelock: {self._tag}\n") + + def isHeld(self) -> bool: + return self._held + + def setWorkSource(self, work_source: Any): + self._work_source = work_source + + def setReferenceCounted(self, value: bool): + pass + + def setHistoryTag(self, tag: str): + self._history_tag = tag + + def toString(self) -> str: + return f"WakeLock({self._tag}, held={self._held})" + + +# ═══════════════════════════════════════════════════════════════ +# Vibrator / VibratorEffect +# ═══════════════════════════════════════════════════════════════ + +class Vibrator(Stub): + """Vibrator — 振动器""" + + def __init__(self): + super().__init__() + + def vibrate(self, milliseconds: int): + sys.stderr.write(f"[Vibrator] vibrate: {milliseconds}ms\n") + + def vibrate(self, pattern: List[int], repeat: int): + sys.stderr.write(f"[Vibrator] vibrate pattern: {pattern}, repeat={repeat}\n") + + def cancel(self): + sys.stderr.write("[Vibrator] cancel\n") + + def hasVibrator(self) -> bool: + return True + + def hasAmplitudeControl(self) -> bool: + return False + + def areEffectsSupported(self, effect_ids: List[int]) -> List[int]: + return [0] * len(effect_ids) + + def areAllEffectsSupported(self, effect_ids: List[int]) -> List[int]: + return [0] * len(effect_ids) + + +class VibratorEffect(Stub): + """VibratorEffect — 振动效果""" + + def __init__(self, effect_id: int = 0): + super().__init__() + self._effect_id = effect_id + + @staticmethod + def createOneShot(milliseconds: int, amplitude: int) -> "VibratorEffect": + return VibratorEffect(0) + + @staticmethod + def createWaveform(pattern: List[int], repeat: int) -> "VibratorEffect": + return VibratorEffect(0) + + @staticmethod + def createPredefined(effect_id: int) -> "VibratorEffect": + return VibratorEffect(effect_id) + + +# ═══════════════════════════════════════════════════════════════ +# BatteryManager +# ═══════════════════════════════════════════════════════════════ + +class BatteryManager(Stub): + """BatteryManager — 电池管理""" + + BATTERY_PROPERTY_CHARGE_COUNTER = 1 + BATTERY_PROPERTY_CURRENT_NOW = 2 + BATTERY_PROPERTY_CURRENT_AVERAGE = 3 + BATTERY_PROPERTY_CAPACITY = 4 + BATTERY_PROPERTY_STATUS = 5 + BATTERY_PROPERTY_ENERGY_COUNTER = 6 + BATTERY_PROPERTY_BATTERY_NOW = 7 + BATTERY_PROPERTY_BATTERY_LOW = 8 + + BATTERY_STATUS_UNKNOWN = 1 + BATTERY_STATUS_CHARGING = 2 + BATTERY_STATUS_DISCHARGING = 3 + BATTERY_STATUS_NOT_CHARGING = 4 + BATTERY_STATUS_FULL = 5 + + BATTERY_HEALTH_UNKNOWN = 1 + BATTERY_HEALTH_GOOD = 2 + BATTERY_HEALTH_OVERHEAT = 3 + BATTERY_HEALTH_DEAD = 4 + BATTERY_HEALTH_OVER_VOLTAGE = 5 + BATTERY_HEALTH_UNSPECIFIED_FAILURE = 6 + BATTERY_HEALTH_COLD = 7 + + EXTRA_STATUS = "status" + EXTRA_HEALTH = "health" + EXTRA_PRESENT = "present" + EXTRA_LEVEL = "level" + EXTRA_SCALE = "scale" + EXTRA_ICON_SMALL = "icon-small" + EXTRA_PLUGGED = "plugged" + EXTRA_VOLTAGE = "voltage" + EXTRA_TEMPERATURE = "temperature" + EXTRA_TECHNOLOGY = "technology" + EXTRA_BATTERY_LOW = "battery_low" + EXTRA_CHARGE_COUNTER = "charge_counter" + + BATTERY_PLUGGED_AC = 1 + BATTERY_PLUGGED_USB = 2 + BATTERY_PLUGGED_WIRELESS = 4 + + def __init__(self): + super().__init__() + self._capacity = 85 + self._status = self.BATTERY_STATUS_CHARGING + self._health = self.BATTERY_HEALTH_GOOD + self._present = True + self._level = 85 + self._plugged = self.BATTERY_PLUGGED_AC + self._voltage = 4200 + self._temperature = 250 + self._technology = "Li-ion" + self._charge_counter = 3500000 + self._current_now = -500000 + self._current_avg = -450000 + self._energy_counter = 15000000 + + def getIntProperty(self, prop_id: int) -> int: + if prop_id == self.BATTERY_PROPERTY_CAPACITY: + return self._capacity + if prop_id == self.BATTERY_PROPERTY_STATUS: + return self._status + if prop_id == self.BATTERY_PROPERTY_CHARGE_COUNTER: + return self._charge_counter + if prop_id == self.BATTERY_PROPERTY_CURRENT_NOW: + return self._current_now + if prop_id == self.BATTERY_PROPERTY_CURRENT_AVERAGE: + return self._current_avg + if prop_id == self.BATTERY_PROPERTY_ENERGY_COUNTER: + return self._energy_counter + return -1 + + def getLongProperty(self, prop_id: int) -> int: + return self.getIntProperty(prop_id) + + def isCharging(self) -> bool: + return self._status == self.BATTERY_STATUS_CHARGING + + def computeChargeTimeRemaining(self) -> int: + return 1800000 # 30 minutes + + def toString(self) -> str: + return f"BatteryManager(level={self._level}%, charging={self.isCharging()})" + + +# ═══════════════════════════════════════════════════════════════ +# 异常类 +# ═══════════════════════════════════════════════════════════════ + +class NetworkOnMainThreadException(RuntimeError): + """网络操作在主线程上执行""" + pass + + +class TransactionTooLargeException(RuntimeError): + """事务数据太大""" + pass + + +class OperationCanceledException(RuntimeError): + """操作被取消""" + pass + + +# ═══════════════════════════════════════════════════════════════ +# 其他工具类 +# ═══════════════════════════════════════════════════════════════ + +class ConditionVariable(Stub): + """ConditionVariable — 条件变量""" + + def __init__(self): + super().__init__() + self._cond = threading.Condition() + self._open = False + + def block(self, timeout_ms: int = 0): + with self._cond: + if timeout_ms <= 0: + while not self._open: + self._cond.wait() + else: + if not self._open: + self._cond.wait(timeout_ms / 1000.0) + + def open(self): + with self._cond: + self._open = True + self._cond.notify_all() + + def close(self): + with self._cond: + self._open = False + + +class Semaphore(Stub): + """Semaphore — 信号量""" + + def __init__(self, permits: int): + super().__init__() + self._sem = threading.Semaphore(permits) + + def acquire(self): + self._sem.acquire() + + def tryAcquire(self) -> bool: + return self._sem.acquire(blocking=False) + + def release(self): + self._sem.release() + + def availablePermits(self) -> int: + return self._sem._value + + +class TokenWatcher(Stub): + """TokenWatcher — 令牌监视器""" + + def __init__(self, handler: Handler, tag: str): + super().__init__() + + def acquire(self, token: Any, tag: str): + pass + + def release(self, token: Any): + pass + + def isAcquired(self) -> bool: + return False + + def dump(self): + pass + + +class WorkSource(Stub): + """WorkSource — 工作来源""" + + def __init__(self, uid: int = 0): + super().__init__() + self._uids: List[int] = [uid] if uid else [] + + def add(self, uid: int): + if uid not in self._uids: + self._uids.append(uid) + + def remove(self, uid: int): + if uid in self._uids: + self._uids.remove(uid) + + def get(self, index: int) -> int: + if 0 <= index < len(self._uids): + return self._uids[index] + return 0 + + def size(self) -> int: + return len(self._uids) + + def clear(self): + self._uids.clear() + + def set(self, ws: "WorkSource"): + if ws: + self._uids = list(ws._uids) + + def toString(self) -> str: + return f"WorkSource({self._uids})" + + +class UserHandle(Stub): + """UserHandle — 用户句柄""" + + USER_ALL = -1 + USER_CURRENT = -2 + USER_CURRENT_OR_SELF = -3 + USER_NULL = -10000 + USER_OWNER = 0 + USER_SYSTEM = 0 + + def __init__(self, user_id: int = 0): + super().__init__() + self._user_id = user_id + + @staticmethod + def myUserId() -> int: + return 0 + + @staticmethod + def getUserHandleForUid(uid: int) -> "UserHandle": + return UserHandle(uid // 100000) + + @staticmethod + def getUserId(uid: int) -> int: + return uid // 100000 + + @staticmethod + def getUid(user_id: int, app_id: int) -> int: + return user_id * 100000 + app_id + + @staticmethod + def getAppId(uid: int) -> int: + return uid % 100000 + + def getIdentifier(self) -> int: + return self._user_id + + def hashCode(self) -> int: + return self._user_id + + def toString(self) -> str: + return f"UserHandle({self._user_id})" + + +class DropBoxManager(Stub): + """DropBoxManager — 系统日志收集""" + + IS_EMPTY = 0 + IS_TEXT = 1 + IS_GZIPPED = 2 + + class Entry(Stub): + def __init__(self, tag: str, milliseconds: int): + super().__init__() + self._tag = tag + self._millis = milliseconds + self._text = "" + + def getTag(self) -> str: + return self._tag + + def getTimeMillis(self) -> int: + return self._millis + + def getText(self, max_bytes: int) -> Optional[str]: + return self._text + + def getFlags(self, max_bytes: int) -> int: + return DropBoxManager.IS_TEXT + + def close(self): + pass + + def __init__(self): + super().__init__() + self._entries: List[DropBoxManager.Entry] = [] + + def addText(self, tag: str, text: str): + entry = DropBoxManager.Entry(tag, int(_time.time() * 1000)) + entry._text = text + self._entries.append(entry) + + def getNextEntry(self, tag: str, milliseconds: int) -> Optional[Entry]: + for entry in self._entries: + if entry.getTimeMillis() > milliseconds: + if not tag or entry.getTag() == tag: + return entry + return None + + def dump(self, pw: Any, prefix: str): + pass + + +class FileObserver(Stub): + """FileObserver — 文件监听""" + + ACCESS = 0x00000001 + MODIFY = 0x00000002 + ATTRIB = 0x00000004 + CLOSE_WRITE = 0x00000008 + CLOSE_NOWRITE = 0x00000010 + OPEN = 0x00000020 + MOVED_FROM = 0x00000040 + MOVED_TO = 0x00000080 + CREATE = 0x00000100 + DELETE = 0x00000200 + DELETE_SELF = 0x00000400 + MOVE_SELF = 0x00000800 + ALL_EVENTS = 0x00000FFF + + def __init__(self, path: str): + super().__init__() + self._path = path + self._watching = False + + def startWatching(self): + self._watching = True + + def stopWatching(self): + self._watching = False + + def onEvent(self, event: int, path: Optional[str]): + pass + + def finalize(self): + pass + + +class FileUtils(Stub): + """FileUtils — 文件工具""" + + @staticmethod + def readFileToString(file: Any) -> str: + return "" + + @staticmethod + def stringToFile(file: Any, string: str): + pass + + @staticmethod + def copyFile(src: Any, dest: Any) -> bool: + return True + + @staticmethod + def deleteDirectory(dir_: Any) -> bool: + return True + + @staticmethod + def deleteOlderFiles(dir_: Any, min_count: int, min_age_ms: int): + pass + + +class PatternMatcher(Stub): + """PatternMatcher — 模式匹配器""" + + PATTERN_LITERAL = 0 + PATTERN_PREFIX = 1 + PATTERN_SIMPLE_GLOB = 2 + PATTERN_ADVANCED_GLOB = 3 + PATTERN_SUFFIX = 4 + + def __init__(self, pattern: str, type_: int): + super().__init__() + self._pattern = pattern + self._type = type_ + + def getPath(self) -> str: + return self._pattern + + def getType(self) -> int: + return self._type + + def match(self, str_: str) -> bool: + if self._type == self.PATTERN_LITERAL: + return str_ == self._pattern + if self._type == self.PATTERN_PREFIX: + return str_.startswith(self._pattern) + if self._type == self.PATTERN_SUFFIX: + return str_.endswith(self._pattern) + if self._type == self.PATTERN_SIMPLE_GLOB: + import fnmatch + return fnmatch.fnmatch(str_, self._pattern) + return str_ == self._pattern + + def toString(self) -> str: + return f"PatternMatcher({self._pattern}, type={self._type})" + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "Bundle", + "BaseBundle", + "PersistableBundle", + "Handler", + "Looper", + "Message", + "HandlerThread", + "PowerManager", + "PowerManagerWakeLock", + "Vibrator", + "VibratorEffect", + "Build", + "SystemClock", + "Environment", + "Parcel", + "Parcelable", + "Process", + "AsyncTask", + "CountDownTimer", + "Messenger", + "BatteryManager", + "PatternMatcher", + "ConditionVariable", + "Semaphore", + "TokenWatcher", + "WorkSource", + "UserHandle", + "DropBoxManager", + "FileObserver", + "FileUtils", + "NetworkOnMainThreadException", + "TransactionTooLargeException", + "OperationCanceledException", +] \ No newline at end of file diff --git a/android_pyapi/android/preference.py b/android_pyapi/android/preference.py new file mode 100644 index 0000000..f666cc1 --- /dev/null +++ b/android_pyapi/android/preference.py @@ -0,0 +1,654 @@ +""" +Android Preference 组件 — Preference, PreferenceScreen, PreferenceManager 等 +方法签名完全对齐 Android SDK +""" + +import os +import sys +import json +from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, + _sdcard_root, _app_data_dir, _package_name, +) + + +# ═══════════════════════════════════════════════════════════════ +# PreferenceChangeListener +# ═══════════════════════════════════════════════════════════════ + +class PreferenceChangeListener(Stub): + """OnPreferenceChangeListener — 偏好变化监听器""" + + def onPreferenceChange(self, preference: "Preference", new_value: Any) -> bool: + return True + + +class PreferenceOnPreferenceClickListener(Stub): + """OnPreferenceClickListener — 偏好点击监听器""" + + def onPreferenceClick(self, preference: "Preference") -> bool: + return True + + +# ═══════════════════════════════════════════════════════════════ +# PreferenceManager +# ═══════════════════════════════════════════════════════════════ + +class PreferenceManager(Stub): + """PreferenceManager — 偏好管理器""" + + KEY_HAS_SET_DEFAULT_VALUES = "_has_set_default_values" + + def __init__(self, context: Any): + super().__init__() + self._context = context + self._shared_prefs_name: str = f"{_package_name}_preferences" + self._shared_prefs_mode: int = 0 + self._prefs_data: Dict[str, Any] = {} + self._prefs_path = os.path.join(_app_data_dir, "shared_prefs", + f"{self._shared_prefs_name}.json") + self._load() + + def _load(self): + os.makedirs(os.path.dirname(self._prefs_path), exist_ok=True) + if os.path.exists(self._prefs_path): + try: + with open(self._prefs_path, "r") as f: + self._prefs_data = json.load(f) + except (json.JSONDecodeError, OSError): + self._prefs_data = {} + else: + self._prefs_data = {} + + def _save(self): + os.makedirs(os.path.dirname(self._prefs_path), exist_ok=True) + with open(self._prefs_path, "w") as f: + json.dump(self._prefs_data, f) + + def getSharedPreferences(self) -> Any: + return self._prefs_data + + def setSharedPreferencesName(self, name: str): + self._shared_prefs_name = name + self._prefs_path = os.path.join(_app_data_dir, "shared_prefs", + f"{name}.json") + self._load() + + def setSharedPreferencesMode(self, mode: int): + self._shared_prefs_mode = mode + + @staticmethod + def getDefaultSharedPreferences(context: Any) -> Any: + mgr = PreferenceManager(context) + return mgr.getSharedPreferences() + + @staticmethod + def setDefaultValues(context: Any, res_id: int, read_again: bool): + pass + + @staticmethod + def setDefaultValues(context: Any, shared_prefs_name: str, + shared_prefs_mode: int, res_id: int, + read_again: bool): + pass + + def getPreference(self, key: str, default: Any = None) -> Any: + return self._prefs_data.get(key, default) + + def putPreference(self, key: str, value: Any): + self._prefs_data[key] = value + self._save() + + def removePreference(self, key: str): + if key in self._prefs_data: + del self._prefs_data[key] + self._save() + + +# ═══════════════════════════════════════════════════════════════ +# Preference +# ═══════════════════════════════════════════════════════════════ + +class Preference(Stub): + """Preference — 偏好设置项基类""" + + def __init__(self, context: Any = None, attrs: Any = None, + def_style_attr: int = 0): + super().__init__() + self._context = context + self._title: str = "" + self._summary: str = "" + self._key: Optional[str] = None + self._enabled: bool = True + self._default_value: Any = None + self._order: int = 0 + self._persistent: bool = True + self._icon: Any = None + self._dependents: List["Preference"] = [] + self._dependency_key: Optional[str] = None + self._preference_manager: Optional[PreferenceManager] = None + self._parent: Optional["PreferenceGroup"] = None + self._on_change_listener: Optional[PreferenceChangeListener] = None + self._on_click_listener: Optional[PreferenceOnPreferenceClickListener] = None + + def setTitle(self, title: str): + self._title = title + + def getTitle(self) -> str: + return self._title + + def setSummary(self, summary: str): + self._summary = summary + + def getSummary(self) -> str: + return self._summary + + def setKey(self, key: str): + self._key = key + + def getKey(self) -> Optional[str]: + return self._key + + def setEnabled(self, enabled: bool): + self._enabled = enabled + + def isEnabled(self) -> bool: + return self._enabled + + def setDefaultValue(self, value: Any): + self._default_value = value + + def setOnPreferenceClickListener(self, listener: PreferenceOnPreferenceClickListener): + self._on_click_listener = listener + + def setOnPreferenceChangeListener(self, listener: PreferenceChangeListener): + self._on_change_listener = listener + + def getSharedPreferences(self) -> Any: + if self._preference_manager: + return self._preference_manager.getSharedPreferences() + return {} + + def getEditor(self) -> Any: + if self._preference_manager: + return self._preference_manager + return None + + def shouldCommit(self) -> bool: + return True + + def shouldPersist(self) -> bool: + return self._persistent and self._key is not None + + def persistString(self, value: str) -> bool: + if self.shouldPersist() and self._preference_manager: + self._preference_manager.putPreference(self._key, value) + return True + return False + + def persistInt(self, value: int) -> bool: + if self.shouldPersist() and self._preference_manager: + self._preference_manager.putPreference(self._key, value) + return True + return False + + def persistBoolean(self, value: bool) -> bool: + if self.shouldPersist() and self._preference_manager: + self._preference_manager.putPreference(self._key, value) + return True + return False + + def persistFloat(self, value: float) -> bool: + if self.shouldPersist() and self._preference_manager: + self._preference_manager.putPreference(self._key, value) + return True + return False + + def persistLong(self, value: int) -> bool: + return self.persistInt(value) + + def getPersistedString(self, default_return: Optional[str] = None) -> Optional[str]: + if self.shouldPersist() and self._preference_manager: + val = self._preference_manager.getPreference(self._key, default_return) + return str(val) if val is not None else default_return + return default_return + + def getPersistedInt(self, default_return: int = 0) -> int: + if self.shouldPersist() and self._preference_manager: + return int(self._preference_manager.getPreference(self._key, default_return)) + return default_return + + def getPersistedBoolean(self, default_return: bool = False) -> bool: + if self.shouldPersist() and self._preference_manager: + val = self._preference_manager.getPreference(self._key, default_return) + if isinstance(val, bool): + return val + return str(val).lower() in ("true", "1", "yes") + return default_return + + def getPersistedFloat(self, default_return: float = 0.0) -> float: + if self.shouldPersist() and self._preference_manager: + return float(self._preference_manager.getPreference(self._key, default_return)) + return default_return + + def getPersistedLong(self, default_return: int = 0) -> int: + return self.getPersistedInt(default_return) + + def notifyChanged(self): + pass + + def notifyHierarchyChanged(self): + pass + + def onBindView(self, view: Any): + pass + + def onClick(self): + if self._on_click_listener: + self._on_click_listener.onPreferenceClick(self) + + def setOrder(self, order: int): + self._order = order + + def getOrder(self) -> int: + return self._order + + def setPersistent(self, persistent: bool): + self._persistent = persistent + + def isPersistent(self) -> bool: + return self._persistent + + def setDependency(self, dependency_key: str): + self._dependency_key = dependency_key + + def getDependency(self) -> Optional[str]: + return self._dependency_key + + def toString(self) -> str: + return f"Preference(key={self._key}, title={self._title})" + + def hashCode(self) -> int: + return hash(self._key) & 0x7FFFFFFF if self._key else 0 + + +# ═══════════════════════════════════════════════════════════════ +# PreferenceGroup +# ═══════════════════════════════════════════════════════════════ + +class PreferenceGroup(Preference): + """PreferenceGroup — 偏好组""" + + def __init__(self, context: Any = None, attrs: Any = None): + super().__init__(context, attrs) + self._preferences: List[Preference] = [] + + def addPreference(self, preference: Preference) -> bool: + if preference not in self._preferences: + self._preferences.append(preference) + preference._parent = self + return True + return False + + def removePreference(self, preference: Preference) -> bool: + if preference in self._preferences: + self._preferences.remove(preference) + preference._parent = None + return True + return False + + def removeAll(self): + for p in self._preferences: + p._parent = None + self._preferences.clear() + + def getPreference(self, index: int) -> Optional[Preference]: + if 0 <= index < len(self._preferences): + return self._preferences[index] + return None + + def getPreferenceCount(self) -> int: + return len(self._preferences) + + def findPreference(self, key: str) -> Optional[Preference]: + for p in self._preferences: + if p.getKey() == key: + return p + if isinstance(p, PreferenceGroup): + result = p.findPreference(key) + if result: + return result + return None + + def toString(self) -> str: + return f"PreferenceGroup(count={len(self._preferences)})" + + +# ═══════════════════════════════════════════════════════════════ +# PreferenceScreen +# ═══════════════════════════════════════════════════════════════ + +class PreferenceScreen(PreferenceGroup): + """PreferenceScreen — 根偏好屏幕""" + + def __init__(self, context: Any = None, attrs: Any = None): + super().__init__(context, attrs) + self._root: bool = True + + +# ═══════════════════════════════════════════════════════════════ +# PreferenceCategory +# ═══════════════════════════════════════════════════════════════ + +class PreferenceCategory(PreferenceGroup): + """PreferenceCategory — 偏好分类标题""" + + def __init__(self, context: Any = None, attrs: Any = None): + super().__init__(context, attrs) + + +# ═══════════════════════════════════════════════════════════════ +# TwoStatePreference +# ═══════════════════════════════════════════════════════════════ + +class TwoStatePreference(Preference): + """TwoStatePreference — 双状态偏好基类""" + + def __init__(self, context: Any = None, attrs: Any = None): + super().__init__(context, attrs) + self._checked: bool = False + self._summary_on: str = "" + self._summary_off: str = "" + self._disable_dependents_state: bool = False + + def isChecked(self) -> bool: + return self._checked + + def setChecked(self, checked: bool): + self._checked = checked + self.persistBoolean(checked) + + def setSummaryOn(self, summary: str): + self._summary_on = summary + + def setSummaryOff(self, summary: str): + self._summary_off = summary + + def setDisableDependentsState(self, state: bool): + self._disable_dependents_state = state + + +# ═══════════════════════════════════════════════════════════════ +# CheckBoxPreference +# ═══════════════════════════════════════════════════════════════ + +class CheckBoxPreference(TwoStatePreference): + """CheckBoxPreference — 复选框偏好""" + + def __init__(self, context: Any = None, attrs: Any = None): + super().__init__(context, attrs) + + +# ═══════════════════════════════════════════════════════════════ +# SwitchPreference +# ═══════════════════════════════════════════════════════════════ + +class SwitchPreference(TwoStatePreference): + """SwitchPreference — 开关偏好""" + + def __init__(self, context: Any = None, attrs: Any = None): + super().__init__(context, attrs) + self._switch_text_on: str = "" + self._switch_text_off: str = "" + + def setSwitchTextOn(self, text: str): + self._switch_text_on = text + + def setSwitchTextOff(self, text: str): + self._switch_text_off = text + + def getSwitchTextOn(self) -> str: + return self._switch_text_on + + def getSwitchTextOff(self) -> str: + return self._switch_text_off + + +# ═══════════════════════════════════════════════════════════════ +# DialogPreference +# ═══════════════════════════════════════════════════════════════ + +class DialogPreference(Preference): + """DialogPreference — 对话框偏好基类""" + + def __init__(self, context: Any = None, attrs: Any = None): + super().__init__(context, attrs) + self._dialog_title: str = "" + self._dialog_message: str = "" + self._dialog_icon: Any = None + self._positive_button_text: str = "" + self._negative_button_text: str = "" + + +# ═══════════════════════════════════════════════════════════════ +# EditTextPreference +# ═══════════════════════════════════════════════════════════════ + +class EditTextPreference(DialogPreference): + """EditTextPreference — 文本编辑偏好""" + + def __init__(self, context: Any = None, attrs: Any = None): + super().__init__(context, attrs) + self._text: str = "" + + def getText(self) -> str: + return self._text + + def setText(self, text: str): + self._text = text + self.persistString(text) + + +# ═══════════════════════════════════════════════════════════════ +# ListPreference +# ═══════════════════════════════════════════════════════════════ + +class ListPreference(DialogPreference): + """ListPreference — 列表偏好""" + + def __init__(self, context: Any = None, attrs: Any = None): + super().__init__(context, attrs) + self._entries: List[str] = [] + self._entry_values: List[str] = [] + self._value: str = "" + + def getEntries(self) -> List[str]: + return list(self._entries) + + def setEntries(self, entries: List[str]): + self._entries = list(entries) + + def getEntryValues(self) -> List[str]: + return list(self._entry_values) + + def setEntryValues(self, values: List[str]): + self._entry_values = list(values) + + def getValue(self) -> str: + return self._value + + def setValue(self, value: str): + self._value = value + self.persistString(value) + + def getEntry(self) -> Optional[str]: + try: + idx = self._entry_values.index(self._value) + if 0 <= idx < len(self._entries): + return self._entries[idx] + except ValueError: + pass + return None + + def getSummary(self) -> str: + entry = self.getEntry() + if entry: + return entry + return self._summary + + def setDefaultValue(self, value: Any): + super().setDefaultValue(value) + + +# ═══════════════════════════════════════════════════════════════ +# MultiSelectListPreference +# ═══════════════════════════════════════════════════════════════ + +class MultiSelectListPreference(DialogPreference): + """MultiSelectListPreference — 多选列表偏好""" + + def __init__(self, context: Any = None, attrs: Any = None): + super().__init__(context, attrs) + self._entries: List[str] = [] + self._entry_values: List[str] = [] + self._values: Set[str] = set() + + def getEntries(self) -> List[str]: + return list(self._entries) + + def setEntries(self, entries: List[str]): + self._entries = list(entries) + + def getEntryValues(self) -> List[str]: + return list(self._entry_values) + + def setEntryValues(self, values: List[str]): + self._entry_values = list(values) + + def getValues(self) -> Set[str]: + return set(self._values) + + def setValues(self, values: Set[str]): + self._values = set(values) + + +# ═══════════════════════════════════════════════════════════════ +# RingtonePreference / SeekBarPreference / DropDownPreference +# ═══════════════════════════════════════════════════════════════ + +class RingtonePreference(Preference): + """RingtonePreference — 铃声偏好""" + + def __init__(self, context: Any = None, attrs: Any = None): + super().__init__(context, attrs) + self._ringtone_type: int = 1 + self._show_default: bool = True + self._show_silent: bool = True + + +class SeekBarPreference(Preference): + """SeekBarPreference — 滑块偏好""" + + def __init__(self, context: Any = None, attrs: Any = None): + super().__init__(context, attrs) + self._min: int = 0 + self._max: int = 100 + self._current: int = 50 + self._show_progress: bool = True + self._adjustable: bool = True + + def getMin(self) -> int: + return self._min + + def setMin(self, min_val: int): + self._min = min_val + + def getMax(self) -> int: + return self._max + + def setMax(self, max_val: int): + self._max = max_val + + def getValue(self) -> int: + return self._current + + def setValue(self, value: int): + self._current = value + self.persistInt(value) + + +class DropDownPreference(ListPreference): + """DropDownPreference — 下拉列表偏好""" + + def __init__(self, context: Any = None, attrs: Any = None): + super().__init__(context, attrs) + + +# ═══════════════════════════════════════════════════════════════ +# PreferenceFragment / PreferenceFragmentCompat +# ═══════════════════════════════════════════════════════════════ + +class PreferenceFragment(Stub): + """PreferenceFragment — 偏好片段""" + + def __init__(self): + super().__init__() + self._preference_manager: Optional[PreferenceManager] = None + + def onCreate(self, savedInstanceState: Any): + pass + + def onCreatePreferences(self, savedInstanceState: Any, root_key: Optional[str]): + pass + + def addPreferencesFromResource(self, res_id: int): + pass + + def setPreferenceScreen(self, screen: PreferenceScreen): + pass + + def getPreferenceScreen(self) -> Optional[PreferenceScreen]: + return None + + def findPreference(self, key: str) -> Optional[Preference]: + screen = self.getPreferenceScreen() + if screen: + return screen.findPreference(key) + return None + + +class PreferenceFragmentCompat(PreferenceFragment): + """PreferenceFragmentCompat — 兼容偏好片段""" + + def __init__(self): + super().__init__() + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "Preference", + "PreferenceScreen", + "PreferenceCategory", + "PreferenceManager", + "CheckBoxPreference", + "SwitchPreference", + "ListPreference", + "EditTextPreference", + "MultiSelectListPreference", + "PreferenceFragment", + "PreferenceFragmentCompat", + "PreferenceGroup", + "PreferenceChangeListener", + "PreferenceOnPreferenceClickListener", + "TwoStatePreference", + "DialogPreference", + "RingtonePreference", + "SeekBarPreference", + "DropDownPreference", +] \ No newline at end of file diff --git a/android_pyapi/android/provider.py b/android_pyapi/android/provider.py new file mode 100644 index 0000000..644057a --- /dev/null +++ b/android_pyapi/android/provider.py @@ -0,0 +1,550 @@ +""" +Android Provider 组件 — Settings, MediaStore, ContactsContract 等 +方法签名完全对齐 Android SDK +""" + +import os +import sys +import json +from typing import Any, Dict, List, Optional, Set, Tuple, Union + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, + _sdcard_root, _app_data_dir, _package_name, +) + + +# ═══════════════════════════════════════════════════════════════ +# OpenableColumns +# ═══════════════════════════════════════════════════════════════ + +class OpenableColumns(Stub): + DISPLAY_NAME = "_display_name" + SIZE = "_size" + + +# ═══════════════════════════════════════════════════════════════ +# Settings +# ═══════════════════════════════════════════════════════════════ + +class _SettingsBase(Stub): + """Settings 基类 — 存储到 JSON 文件""" + + _DATA_DIR = os.path.join(_app_data_dir, "shared_prefs") + _cache: Dict[str, Dict[str, Any]] = {} + + @classmethod + def _get_path(cls, name: str) -> str: + os.makedirs(cls._DATA_DIR, exist_ok=True) + return os.path.join(cls._DATA_DIR, f"{name}.json") + + @classmethod + def _load(cls, name: str) -> Dict[str, Any]: + if name in cls._cache: + return cls._cache[name] + path = cls._get_path(name) + if os.path.exists(path): + try: + with open(path, "r") as f: + data = json.load(f) + cls._cache[name] = data + return data + except (json.JSONDecodeError, OSError): + pass + cls._cache[name] = {} + return cls._cache[name] + + @classmethod + def _save(cls, name: str): + path = cls._get_path(name) + try: + with open(path, "w") as f: + json.dump(cls._cache.get(name, {}), f) + except OSError: + pass + + @staticmethod + def putString(name: str, key: str, value: str) -> bool: + data = _SettingsBase._load(name) + data[key] = value + _SettingsBase._save(name) + return True + + @staticmethod + def getString(name: str, key: str, default_value: Optional[str] = None) -> Optional[str]: + data = _SettingsBase._load(name) + return data.get(key, default_value) + + @staticmethod + def putInt(name: str, key: str, value: int) -> bool: + data = _SettingsBase._load(name) + data[key] = value + _SettingsBase._save(name) + return True + + @staticmethod + def getInt(name: str, key: str, default_value: int = 0) -> int: + data = _SettingsBase._load(name) + return data.get(key, default_value) + + @staticmethod + def putLong(name: str, key: str, value: int) -> bool: + return _SettingsBase.putInt(name, key, value) + + @staticmethod + def getLong(name: str, key: str, default_value: int = 0) -> int: + return _SettingsBase.getInt(name, key, default_value) + + @staticmethod + def putFloat(name: str, key: str, value: float) -> bool: + data = _SettingsBase._load(name) + data[key] = value + _SettingsBase._save(name) + return True + + @staticmethod + def getFloat(name: str, key: str, default_value: float = 0.0) -> float: + data = _SettingsBase._load(name) + return data.get(key, default_value) + + +class SettingsSystem(_SettingsBase): + _NAME = "settings_system" + + @staticmethod + def putInt(key: str, value: int) -> bool: + return _SettingsBase.putInt(SettingsSystem._NAME, key, value) + + @staticmethod + def getInt(key: str, default_value: int = 0) -> int: + return _SettingsBase.getInt(SettingsSystem._NAME, key, default_value) + + @staticmethod + def putString(key: str, value: str) -> bool: + return _SettingsBase.putString(SettingsSystem._NAME, key, value) + + @staticmethod + def getString(key: str, default_value: Optional[str] = None) -> Optional[str]: + return _SettingsBase.getString(SettingsSystem._NAME, key, default_value) + + @staticmethod + def putFloat(key: str, value: float) -> bool: + return _SettingsBase.putFloat(SettingsSystem._NAME, key, value) + + @staticmethod + def getFloat(key: str, default_value: float = 0.0) -> float: + return _SettingsBase.getFloat(SettingsSystem._NAME, key, default_value) + + @staticmethod + def putLong(key: str, value: int) -> bool: + return _SettingsBase.putLong(SettingsSystem._NAME, key, value) + + @staticmethod + def getLong(key: str, default_value: int = 0) -> int: + return _SettingsBase.getLong(SettingsSystem._NAME, key, default_value) + + +class SettingsSecure(_SettingsBase): + _NAME = "settings_secure" + + @staticmethod + def putInt(key: str, value: int) -> bool: + return _SettingsBase.putInt(SettingsSecure._NAME, key, value) + + @staticmethod + def getInt(key: str, default_value: int = 0) -> int: + return _SettingsBase.getInt(SettingsSecure._NAME, key, default_value) + + @staticmethod + def putString(key: str, value: str) -> bool: + return _SettingsBase.putString(SettingsSecure._NAME, key, value) + + @staticmethod + def getString(key: str, default_value: Optional[str] = None) -> Optional[str]: + return _SettingsBase.getString(SettingsSecure._NAME, key, default_value) + + @staticmethod + def putFloat(key: str, value: float) -> bool: + return _SettingsBase.putFloat(SettingsSecure._NAME, key, value) + + @staticmethod + def getFloat(key: str, default_value: float = 0.0) -> float: + return _SettingsBase.getFloat(SettingsSecure._NAME, key, default_value) + + @staticmethod + def putLong(key: str, value: int) -> bool: + return _SettingsBase.putLong(SettingsSecure._NAME, key, value) + + @staticmethod + def getLong(key: str, default_value: int = 0) -> int: + return _SettingsBase.getLong(SettingsSecure._NAME, key, default_value) + + +class SettingsGlobal(_SettingsBase): + _NAME = "settings_global" + + @staticmethod + def putInt(key: str, value: int) -> bool: + return _SettingsBase.putInt(SettingsGlobal._NAME, key, value) + + @staticmethod + def getInt(key: str, default_value: int = 0) -> int: + return _SettingsBase.getInt(SettingsGlobal._NAME, key, default_value) + + @staticmethod + def putString(key: str, value: str) -> bool: + return _SettingsBase.putString(SettingsGlobal._NAME, key, value) + + @staticmethod + def getString(key: str, default_value: Optional[str] = None) -> Optional[str]: + return _SettingsBase.getString(SettingsGlobal._NAME, key, default_value) + + @staticmethod + def putFloat(key: str, value: float) -> bool: + return _SettingsBase.putFloat(SettingsGlobal._NAME, key, value) + + @staticmethod + def getFloat(key: str, default_value: float = 0.0) -> float: + return _SettingsBase.getFloat(SettingsGlobal._NAME, key, default_value) + + @staticmethod + def putLong(key: str, value: int) -> bool: + return _SettingsBase.putLong(SettingsGlobal._NAME, key, value) + + @staticmethod + def getLong(key: str, default_value: int = 0) -> int: + return _SettingsBase.getLong(SettingsGlobal._NAME, key, default_value) + + +class Settings(Stub): + """Settings — 系统设置""" + + System = SettingsSystem + Secure = SettingsSecure + Global = SettingsGlobal + + ACTION_SETTINGS = "android.settings.SETTINGS" + ACTION_APPLICATION_DETAILS_SETTINGS = "android.settings.APPLICATION_DETAILS_SETTINGS" + EXTRA_APP_PACKAGE = "android.intent.extra.PACKAGE_NAME" + + +# ═══════════════════════════════════════════════════════════════ +# MediaStore +# ═══════════════════════════════════════════════════════════════ + +class MediaStore(Stub): + """MediaStore — 媒体存储""" + + class MediaColumns(Stub): + _ID = 0 + DATA = 1 + SIZE = 2 + DISPLAY_NAME = 3 + MIME_TYPE = 4 + TITLE = 5 + DATE_ADDED = 6 + DATE_MODIFIED = 7 + ORIENTATION = 8 + WIDTH = 9 + HEIGHT = 10 + + class Files(Stub): + @staticmethod + def getContentUri(volume_name: str) -> str: + return f"content://media/{volume_name}/file" + + class Images(Stub): + class Media(Stub): + EXTERNAL_CONTENT_URI = "content://media/external/images/media" + INTERNAL_CONTENT_URI = "content://media/internal/images/media" + + class Thumbnails(Stub): + EXTERNAL_CONTENT_URI = "content://media/external/images/thumbnails" + + class Video(Stub): + class Media(Stub): + EXTERNAL_CONTENT_URI = "content://media/external/video/media" + + class Audio(Stub): + class Media(Stub): + EXTERNAL_CONTENT_URI = "content://media/external/audio/media" + + @staticmethod + def getVersion(context: Any, uri: str) -> str: + return "0" + + @staticmethod + def setVersion(context: Any, uri: str, version: str) -> bool: + return True + + +# ═══════════════════════════════════════════════════════════════ +# DocumentsContract +# ═══════════════════════════════════════════════════════════════ + +class DocumentsContract(Stub): + """DocumentsContract — 文档合约""" + + EXTRA_INITIAL_URI = "android.provider.extra.INITIAL_URI" + EXTRA_LOADING = "android.provider.extra.LOADING" + EXTRA_INFO = "android.provider.extra.INFO" + EXTRA_PROMPT = "android.provider.extra.PROMPT" + + @staticmethod + def buildDocumentUri(authority: str, document_id: str) -> str: + return f"content://{authority}/document/{document_id}" + + @staticmethod + def buildDocumentUriUsingTree(tree_uri: str, document_id: str) -> str: + return f"{tree_uri}/document/{document_id}" + + @staticmethod + def buildChildDocumentsUri(authority: str, parent_document_id: str) -> str: + return f"content://{authority}/document/{parent_document_id}/children" + + @staticmethod + def buildChildDocumentsUriUsingTree(tree_uri: str, parent_document_id: str) -> str: + return f"{tree_uri}/document/{parent_document_id}/children" + + @staticmethod + def getDocumentId(document_uri: str) -> str: + return document_uri.rsplit("/", 1)[-1] + + @staticmethod + def getTreeDocumentId(document_uri: str) -> str: + parts = document_uri.split("/") + if "document" in parts: + idx = parts.index("document") + if idx + 1 < len(parts): + return parts[idx + 1] + return "" + + @staticmethod + def getRootId(root_uri: str) -> str: + parts = root_uri.split("/") + if "root" in parts: + idx = parts.index("root") + if idx + 1 < len(parts): + return parts[idx + 1] + return "" + + +# ═══════════════════════════════════════════════════════════════ +# ContactsContract +# ═══════════════════════════════════════════════════════════════ + +class ContactsContract(Stub): + """ContactsContract — 联系人合约""" + + class Contacts(Stub): + CONTENT_URI = "content://com.android.contacts/contacts" + CONTENT_FILTER_URI = "content://com.android.contacts/contacts/filter" + DISPLAY_NAME = "display_name" + PHOTO_URI = "photo_uri" + _ID = "_id" + + class CommonDataKinds(Stub): + class Email(Stub): + CONTENT_URI = "content://com.android.contacts/data/emails" + + class Phone(Stub): + CONTENT_URI = "content://com.android.contacts/data/phones" + + class Data(Stub): + CONTENT_URI = "content://com.android.contacts/data" + + +class ContactsContractContacts(ContactsContract.Contacts): + pass + + +class ContactsContractData(ContactsContract.Data): + pass + + +# ═══════════════════════════════════════════════════════════════ +# CallLog +# ═══════════════════════════════════════════════════════════════ + +class CallLog(Stub): + """CallLog — 通话记录""" + + class Calls(Stub): + CONTENT_URI = "content://call_log/calls" + _ID = "_id" + NUMBER = "number" + TYPE = "type" + TYPE_INCOMING = 1 + TYPE_OUTGOING = 2 + TYPE_MISSED = 3 + TYPE_VOICEMAIL = 4 + TYPE_REJECTED = 5 + TYPE_BLOCKED = 6 + TYPE_ANSWERED_EXTERNALLY = 7 + DATE = "date" + DURATION = "duration" + NEW = "new" + VOICEMAIL_URI = "voicemail_uri" + CACHED_NAME = "cached_name" + CACHED_NUMBER_LABEL = "cached_number_label" + GEOCODED_LOCATION = "geocoded_location" + COUNTRY_ISO = "country_iso" + + @staticmethod + def getLastOutgoingCall(context: Any) -> Optional[str]: + return None + + +# ═══════════════════════════════════════════════════════════════ +# CalendarContract +# ═══════════════════════════════════════════════════════════════ + +class CalendarContract(Stub): + """CalendarContract — 日历合约""" + + class Events(Stub): + CONTENT_URI = "content://com.android.calendar/events" + _ID = "_id" + TITLE = "title" + DESCRIPTION = "description" + EVENT_LOCATION = "event_location" + DTSTART = "dtstart" + DTEND = "dtend" + EVENT_TIMEZONE = "event_timezone" + DURATION = "duration" + ALL_DAY = "allDay" + CALENDAR_ID = "calendar_id" + ORGANIZER = "organizer" + STATUS = "eventStatus" + AVAILABILITY = "availability" + ACCESS_LEVEL = "accessLevel" + + class Attendees(Stub): + CONTENT_URI = "content://com.android.calendar/attendees" + + class Reminders(Stub): + CONTENT_URI = "content://com.android.calendar/reminders" + + +# ═══════════════════════════════════════════════════════════════ +# Browser / SearchRecentSuggestions / UserDictionary +# ═══════════════════════════════════════════════════════════════ + +class Browser(Stub): + """Browser — 浏览器书签""" + + class BookmarkColumns(Stub): + TITLE = "title" + URL = "url" + _ID = "_id" + BOOKMARK = "bookmark" + DATE = "date" + CREATED = "created" + VISITS = "visits" + + class SearchColumns(Stub): + URL = "url" + SEARCH = "search" + DATE = "date" + + HISTORY_PROJECTION = ["_id", "url", "title", "date", "visits", "bookmark", "created"] + SEARCHES_PROJECTION = ["_id", "search", "date"] + + +class SearchRecentSuggestions(Stub): + """SearchRecentSuggestions — 搜索建议""" + + def __init__(self, context: Any, authority: str, mode: int): + super().__init__() + self._authority = authority + self._mode = mode + + def saveRecentQuery(self, query_string: str, line2: str): + pass + + def clearHistory(self): + pass + + +class UserDictionary(Stub): + """UserDictionary — 用户词典""" + + class Words(Stub): + CONTENT_URI = "content://user_dictionary/words" + _ID = "_id" + WORD = "word" + FREQUENCY = "frequency" + LOCALE = "locale" + APP_ID = "app_id" + SHORTCUT = "shortcut" + + +# ═══════════════════════════════════════════════════════════════ +# SyncStateContract / LiveFolders +# ═══════════════════════════════════════════════════════════════ + +class SyncStateContract(Stub): + """SyncStateContract — 同步状态合约""" + + class Columns(Stub): + _ID = "_id" + ACCOUNT_NAME = "account_name" + ACCOUNT_TYPE = "account_type" + DATA = "data" + + class Helpers(Stub): + @staticmethod + def get(cr: Any, provider_uri: str, account: Any) -> Optional[bytes]: + return None + + @staticmethod + def set(cr: Any, provider_uri: str, account: Any, data: bytes): + pass + + @staticmethod + def insert(cr: Any, provider_uri: str, account: Any, data: bytes): + pass + + @staticmethod + def update(cr: Any, provider_uri: str, account: Any, data: bytes): + pass + + +class LiveFolders(Stub): + """LiveFolders — 实时文件夹""" + + NAME = "name" + DESCRIPTION = "description" + INTENT = "intent" + ICON_BITMAP = "icon_bitmap" + ICON_PACKAGE = "icon_package" + ICON_RESOURCE = "icon_resource" + DISPLAY_MODE = "display_mode" + DISPLAY_MODE_GRID = 1 + DISPLAY_MODE_LIST = 2 + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "Settings", + "SettingsSystem", + "SettingsSecure", + "SettingsGlobal", + "CallLog", + "ContactsContract", + "ContactsContractContacts", + "ContactsContractData", + "MediaStore", + "DocumentsContract", + "CalendarContract", + "Browser", + "SearchRecentSuggestions", + "UserDictionary", + "SyncStateContract", + "LiveFolders", + "OpenableColumns", +] \ No newline at end of file diff --git a/android_pyapi/android/speech_tts.py b/android_pyapi/android/speech_tts.py new file mode 100644 index 0000000..60c8dcd --- /dev/null +++ b/android_pyapi/android/speech_tts.py @@ -0,0 +1,401 @@ +""" +Android Speech/TTS 组件 — TextToSpeech, Voice, SynthesisCallback 等 +方法签名完全对齐 Android SDK +""" + +import os +import sys +import locale as _locale +from typing import Any, Dict, List, Optional, Set, Tuple, Union + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, + _sdcard_root, _app_data_dir, _package_name, +) + + +# ═══════════════════════════════════════════════════════════════ +# TextToSpeech.OnInitListener +# ═══════════════════════════════════════════════════════════════ + +class TextToSpeechOnInitListener(Stub): + """OnInitListener — 初始化监听器""" + + def onInit(self, status: int): + pass + + +# ═══════════════════════════════════════════════════════════════ +# UtteranceProgressListener +# ═══════════════════════════════════════════════════════════════ + +class UtteranceProgressListener(Stub): + """UtteranceProgressListener — 发音进度监听器""" + + def onStart(self, utterance_id: str): + pass + + def onDone(self, utterance_id: str): + pass + + def onError(self, utterance_id: str, error_code: int = -1): + pass + + def onStop(self, utterance_id: str, interrupted: bool = False): + pass + + def onBeginSynthesis(self, utterance_id: str, sample_rate_in_hz: int, + audio_format: int, channel_count: int): + pass + + def onRangeStart(self, utterance_id: str, start: int, end: int, frame: int): + pass + + +class TextToSpeechOnUtteranceCompletedListener(Stub): + """OnUtteranceCompletedListener — 旧版发音完成监听器""" + + def onUtteranceCompleted(self, utterance_id: str): + pass + + +# ═══════════════════════════════════════════════════════════════ +# SynthesisRequest +# ═══════════════════════════════════════════════════════════════ + +class SynthesisRequest(Stub): + """SynthesisRequest — 合成请求""" + + def __init__(self): + super().__init__() + self._text: str = "" + self._speech_rate: float = 1.0 + self._voice: Optional["Voice"] = None + self._calling_uid: int = 0 + self._country: str = "" + self._language: str = "" + self._variant: str = "" + self._params: Dict[str, str] = {} + + def getText(self) -> str: + return self._text + + def getSpeechRate(self) -> float: + return self._speech_rate + + def getVoice(self) -> Optional["Voice"]: + return self._voice + + def getCallingUid(self) -> int: + return self._calling_uid + + def getCountry(self) -> str: + return self._country + + def getLanguage(self) -> str: + return self._language + + def getVariant(self) -> str: + return self._variant + + def getParams(self) -> Dict[str, str]: + return dict(self._params) + + +# ═══════════════════════════════════════════════════════════════ +# SynthesisCallback +# ═══════════════════════════════════════════════════════════════ + +class SynthesisCallback(Stub): + """SynthesisCallback — 合成回调""" + + def start(self, sample_rate_in_hz: int, audio_format: int, channel_count: int) -> int: + return 0 + + def getMaxBufferSize(self) -> int: + return 8192 + + def getChannelCount(self) -> int: + return 1 + + def getAudioFormat(self) -> int: + return 1 + + def getSampleRate(self) -> int: + return 22050 + + def availableBuffer(self, buffer_size: int) -> int: + return buffer_size + + def audioAvailable(self, audio: bytes) -> int: + return len(audio) + + def done(self) -> int: + return 0 + + def error(self) -> int: + return -1 + + def hasStarted(self) -> bool: + return False + + def hasFinished(self) -> bool: + return False + + +# ═══════════════════════════════════════════════════════════════ +# Voice +# ═══════════════════════════════════════════════════════════════ + +class Voice(Stub): + """Voice — 语音""" + + QUALITY_DEFAULT = -1 + QUALITY_VERY_LOW = 100 + QUALITY_LOW = 200 + QUALITY_NORMAL = 300 + QUALITY_HIGH = 400 + QUALITY_VERY_HIGH = 500 + + LATENCY_DEFAULT = -1 + LATENCY_VERY_LOW = 100 + LATENCY_LOW = 200 + LATENCY_NORMAL = 300 + LATENCY_HIGH = 400 + LATENCY_VERY_HIGH = 500 + + def __init__(self, name: str = "", locale: Any = None, + quality: int = QUALITY_NORMAL, latency: int = LATENCY_NORMAL, + requires_network: bool = False, + features: Optional[List[str]] = None): + super().__init__() + self._name = name + self._locale = locale or _locale.getdefaultlocale()[0] + self._quality = quality + self._latency = latency + self._requires_network = requires_network + self._features = features or [] + + def getName(self) -> str: + return self._name + + def getLocale(self) -> Any: + return self._locale + + def getQuality(self) -> int: + return self._quality + + def getLatency(self) -> int: + return self._latency + + def isNetworkConnectionRequired(self) -> bool: + return self._requires_network + + def getFeatures(self) -> List[str]: + return list(self._features) + + def toString(self) -> str: + return f"Voice(name={self._name}, locale={self._locale})" + + +# ═══════════════════════════════════════════════════════════════ +# TextToSpeech.Engine +# ═══════════════════════════════════════════════════════════════ + +class TextToSpeechEngine(Stub): + """TextToSpeech.Engine — TTS 引擎元数据""" + + ACTION_CHECK_TTS_DATA = "android.speech.tts.engine.CHECK_TTS_DATA" + ACTION_INSTALL_TTS_DATA = "android.speech.tts.engine.INSTALL_TTS_DATA" + ACTION_GET_SAMPLE_TEXT = "android.speech.tts.engine.GET_SAMPLE_TEXT" + + KEY_PARAM_STREAM = "streamType" + KEY_PARAM_VOLUME = "volume" + KEY_PARAM_PAN = "pan" + KEY_PARAM_UTTERANCE_ID = "utteranceId" + KEY_PARAM_SESSION_ID = "sessionId" + + KEY_FEATURE_NETWORK_SYNTHESIS = "networkSynthesis" + KEY_FEATURE_EMBEDDED_SYNTHESIS = "embeddedSynthesis" + KEY_FEATURE_NOT_INSTALLED = "notInstalled" + + DEFAULT_STREAM = 3 + DEFAULT_LANG = "eng" + DEFAULT_COUNTRY = "USA" + DEFAULT_VARIANT = "" + + @staticmethod + def getLocaleLang(lang: str) -> str: + return lang[:3] if len(lang) >= 3 else lang + + @staticmethod + def getLocaleCountry(lang: str) -> str: + return lang[3:6] if len(lang) >= 6 else "" + + @staticmethod + def getLocaleVariant(lang: str) -> str: + return lang[6:] if len(lang) > 6 else "" + + +Engine = TextToSpeechEngine + + +# ═══════════════════════════════════════════════════════════════ +# TextToSpeech +# ═══════════════════════════════════════════════════════════════ + +class TextToSpeech(Stub): + """TextToSpeech — 文字转语音""" + + SUCCESS = 0 + ERROR = -1 + STOPPED = -2 + + QUEUE_FLUSH = 0 + QUEUE_ADD = 1 + + LANG_COUNTRY_AVAILABLE = 1 + LANG_AVAILABLE = 0 + LANG_COUNTRY_VAR_AVAILABLE = 2 + LANG_MISSING_DATA = -1 + LANG_NOT_SUPPORTED = -2 + + Engine = TextToSpeechEngine + + def __init__(self, context: Any = None, listener: Optional[TextToSpeechOnInitListener] = None): + super().__init__() + self._context = context + self._listener = listener + self._utterance_progress_listener: Optional[UtteranceProgressListener] = None + self._language: str = "" + self._country: str = "" + self._pitch: float = 1.0 + self._speech_rate: float = 1.0 + self._voice: Optional[Voice] = None + self._voices: List[Voice] = [ + Voice("en-us-1", "en_US", Voice.QUALITY_HIGH, Voice.LATENCY_NORMAL), + Voice("en-gb-1", "en_GB", Voice.QUALITY_NORMAL, Voice.LATENCY_NORMAL), + Voice("zh-cn-1", "zh_CN", Voice.QUALITY_HIGH, Voice.LATENCY_NORMAL), + ] + self._engine_package: str = "" + self._initialized = False + if listener: + try: + listener.onInit(self.SUCCESS) + except Exception: + pass + self._initialized = True + + def speak(self, text: str, queue_mode: int = QUEUE_FLUSH, + params: Any = None, utterance_id: str = "") -> int: + return self.SUCCESS + + def stop(self) -> int: + return self.SUCCESS + + def shutdown(self): + self._initialized = False + + def setLanguage(self, language: str, country: str = "", variant: str = "") -> int: + self._language = language + self._country = country + return self.LANG_AVAILABLE + + def getLanguage(self) -> Tuple[str, str, str]: + return (self._language, self._country, "") + + def isLanguageAvailable(self, language: str, country: str = "", + variant: str = "") -> int: + return self.LANG_AVAILABLE + + def setOnUtteranceProgressListener(self, listener: UtteranceProgressListener): + self._utterance_progress_listener = listener + + def setOnUtteranceCompletedListener(self, listener: TextToSpeechOnUtteranceCompletedListener): + pass + + def setPitch(self, pitch: float) -> int: + self._pitch = pitch + return self.SUCCESS + + def setSpeechRate(self, rate: float) -> int: + self._speech_rate = rate + return self.SUCCESS + + def getVoice(self) -> Optional[Voice]: + return self._voice + + def setVoice(self, voice: Voice) -> int: + self._voice = voice + return self.SUCCESS + + def getVoices(self) -> Set[Voice]: + return set(self._voices) + + def addSpeech(self, text: str, filename: str) -> int: + return self.SUCCESS + + def addEyes(self, text: str, filename: str) -> int: + return self.SUCCESS + + def synthesizeToFile(self, text: str, params: Any, filename: str) -> int: + return self.SUCCESS + + def setEngineByPackageName(self, package_name: str): + self._engine_package = package_name + + def getDefaultEngine(self) -> Optional[str]: + return "com.android.tts" + + def getEngines(self) -> List["EngineInfo"]: + return [] + + def getFeatures(self, locale: Any) -> Set[str]: + return set() + + def areDefaultsEnforced(self) -> bool: + return False + + def setQueueMode(self, queue_mode: int): + pass + + def isSpeaking(self) -> bool: + return False + + def toString(self) -> str: + return f"TextToSpeech(lang={self._language})" + + +# ═══════════════════════════════════════════════════════════════ +# EngineInfo +# ═══════════════════════════════════════════════════════════════ + +class EngineInfo(Stub): + """EngineInfo — 引擎信息""" + + def __init__(self): + super().__init__() + self.name: str = "" + self.label: str = "" + self.icon: int = 0 + self.priority: int = 0 + self.system: bool = False + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "TextToSpeech", + "TextToSpeechEngine", + "TextToSpeechOnInitListener", + "TextToSpeechOnUtteranceCompletedListener", + "SynthesisCallback", + "SynthesisRequest", + "Voice", + "UtteranceProgressListener", + "Engine", + "EngineInfo", +] \ No newline at end of file diff --git a/android_pyapi/android/telephony.py b/android_pyapi/android/telephony.py new file mode 100644 index 0000000..1ab18ce --- /dev/null +++ b/android_pyapi/android/telephony.py @@ -0,0 +1,676 @@ +""" +Android Telephony 组件 — TelephonyManager, CellInfo, PhoneStateListener 等 +方法签名完全对齐 Android SDK +""" + +import os +import sys +import random +from typing import Any, Dict, List, Optional, Set, Tuple, Union + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, + _sdcard_root, _app_data_dir, _package_name, +) + + +# ═══════════════════════════════════════════════════════════════ +# CellIdentity 基类集合 +# ═══════════════════════════════════════════════════════════════ + +class CellIdentity(Stub): + def __init__(self): + super().__init__() + + +class CellIdentityGsm(CellIdentity): + def __init__(self, mcc: int = 0, mnc: int = 0, lac: int = 0, cid: int = 0, arfcn: int = 0): + super().__init__() + self._mcc = mcc + self._mnc = mnc + self._lac = lac + self._cid = cid + self._arfcn = arfcn + + def getMcc(self) -> int: return self._mcc + def getMnc(self) -> int: return self._mnc + def getLac(self) -> int: return self._lac + def getCid(self) -> int: return self._cid + def getArfcn(self) -> int: return self._arfcn + + +class CellIdentityCdma(CellIdentity): + def __init__(self, network_id: int = 0, system_id: int = 0, basestation_id: int = 0, + latitude: int = 0, longitude: int = 0): + super().__init__() + self._network_id = network_id + self._system_id = system_id + self._basestation_id = basestation_id + self._latitude = latitude + self._longitude = longitude + + def getNetworkId(self) -> int: return self._network_id + def getSystemId(self) -> int: return self._system_id + def getBasestationId(self) -> int: return self._basestation_id + def getLatitude(self) -> int: return self._latitude + def getLongitude(self) -> int: return self._longitude + + +class CellIdentityLte(CellIdentity): + def __init__(self, mcc: int = 0, mnc: int = 0, ci: int = 0, pci: int = 0, tac: int = 0): + super().__init__() + self._mcc = mcc; self._mnc = mnc + self._ci = ci; self._pci = pci; self._tac = tac + + def getMcc(self) -> int: return self._mcc + def getMnc(self) -> int: return self._mnc + def getCi(self) -> int: return self._ci + def getPci(self) -> int: return self._pci + def getTac(self) -> int: return self._tac + + +class CellIdentityWcdma(CellIdentity): + def __init__(self, mcc: int = 0, mnc: int = 0, lac: int = 0, cid: int = 0, psc: int = 0): + super().__init__() + self._mcc = mcc; self._mnc = mnc + self._lac = lac; self._cid = cid; self._psc = psc + + def getMcc(self) -> int: return self._mcc + def getMnc(self) -> int: return self._mnc + def getLac(self) -> int: return self._lac + def getCid(self) -> int: return self._cid + def getPsc(self) -> int: return self._psc + + +class CellIdentityNr(CellIdentity): + def __init__(self, mcc: int = 0, mnc: int = 0, nci: int = 0, pci: int = 0, tac: int = 0): + super().__init__() + self._mcc = mcc; self._mnc = mnc + self._nci = nci; self._pci = pci; self._tac = tac + + def getMcc(self) -> int: return self._mcc + def getMnc(self) -> int: return self._mnc + def getNci(self) -> int: return self._nci + def getPci(self) -> int: return self._pci + def getTac(self) -> int: return self._tac + + +# ═══════════════════════════════════════════════════════════════ +# CellSignalStrength 基类集合 +# ═══════════════════════════════════════════════════════════════ + +class CellSignalStrength(Stub): + SIGNAL_STRENGTH_NONE_OR_UNKNOWN = 0 + SIGNAL_STRENGTH_POOR = 1 + SIGNAL_STRENGTH_MODERATE = 2 + SIGNAL_STRENGTH_GOOD = 3 + SIGNAL_STRENGTH_GREAT = 4 + + def getLevel(self) -> int: + return self.SIGNAL_STRENGTH_NONE_OR_UNKNOWN + + def getAsuLevel(self) -> int: + return 0 + + def getDbm(self) -> int: + return 0 + + +class CellSignalStrengthGsm(CellSignalStrength): + def __init__(self, rssi: int = 0, ber: int = 0, ta: int = 0): + super().__init__() + self._rssi = rssi; self._ber = ber; self._ta = ta + + def getRssi(self) -> int: return self._rssi + def getDbm(self) -> int: return self._rssi - 113 if self._rssi > 0 else 0 + + +class CellSignalStrengthCdma(CellSignalStrength): + def __init__(self, dbm: int = 0, ecio: int = 0, evdo_dbm: int = 0, evdo_ecio: int = 0, + evdo_snr: int = 0): + super().__init__() + self._dbm = dbm; self._ecio = ecio + self._evdo_dbm = evdo_dbm; self._evdo_ecio = evdo_ecio; self._evdo_snr = evdo_snr + + def getDbm(self) -> int: return self._dbm + + +class CellSignalStrengthLte(CellSignalStrength): + def __init__(self, rssi: int = 0, rsrp: int = 0, rsrq: int = 0, rssnr: int = 0, + cqi: int = 0, ta: int = 0): + super().__init__() + self._rssi = rssi; self._rsrp = rsrp; self._rsrq = rsrq + self._rssnr = rssnr; self._cqi = cqi; self._ta = ta + + def getRsrp(self) -> int: return self._rsrp + def getRsrq(self) -> int: return self._rsrq + def getRssnr(self) -> int: return self._rssnr + def getDbm(self) -> int: return self._rsrp + + +class CellSignalStrengthWcdma(CellSignalStrength): + def __init__(self, rscp: int = 0, ecno: int = 0): + super().__init__() + self._rscp = rscp; self._ecno = ecno + + def getRscp(self) -> int: return self._rscp + def getEcno(self) -> int: return self._ecno + def getDbm(self) -> int: return self._rscp - 113 if self._rscp > 0 else 0 + + +class CellSignalStrengthNr(CellSignalStrength): + def __init__(self, ssRsrp: int = 0, ssRsrq: int = 0, ssSinr: int = 0, csiRsrp: int = 0): + super().__init__() + self._ssRsrp = ssRsrp; self._ssRsrq = ssRsrq + self._ssSinr = ssSinr; self._csiRsrp = csiRsrp + + def getSsRsrp(self) -> int: return self._ssRsrp + def getDbm(self) -> int: return self._ssRsrp + + +# ═══════════════════════════════════════════════════════════════ +# CellInfo 基类集合 +# ═══════════════════════════════════════════════════════════════ + +class CellInfo(Stub): + UNAVAILABLE = 0x7FFFFFFF + TIMESTAMP_TYPE_UNKNOWN = 0 + TIMESTAMP_TYPE_GSM = 1 + TIMESTAMP_TYPE_UMTS = 2 + TIMESTAMP_TYPE_CDMA = 3 + TIMESTAMP_TYPE_LTE = 4 + TIMESTAMP_TYPE_WCDMA = 5 + TIMESTAMP_TYPE_NR = 6 + + def __init__(self): + super().__init__() + self._registered = False + self._timestamp = 0 + self._connection_status = 0 + + def isRegistered(self) -> bool: return self._registered + def getTimeStamp(self) -> int: return self._timestamp + def getCellConnectionStatus(self) -> int: return self._connection_status + + +class CellInfoGsm(CellInfo): + def __init__(self): + super().__init__() + self._identity = CellIdentityGsm() + self._signal_strength = CellSignalStrengthGsm() + + def getCellIdentity(self) -> CellIdentityGsm: return self._identity + def getCellSignalStrength(self) -> CellSignalStrengthGsm: return self._signal_strength + + +class CellInfoCdma(CellInfo): + def __init__(self): + super().__init__() + self._identity = CellIdentityCdma() + self._signal_strength = CellSignalStrengthCdma() + + def getCellIdentity(self) -> CellIdentityCdma: return self._identity + def getCellSignalStrength(self) -> CellSignalStrengthCdma: return self._signal_strength + + +class CellInfoLte(CellInfo): + def __init__(self): + super().__init__() + self._identity = CellIdentityLte() + self._signal_strength = CellSignalStrengthLte() + + def getCellIdentity(self) -> CellIdentityLte: return self._identity + def getCellSignalStrength(self) -> CellSignalStrengthLte: return self._signal_strength + + +class CellInfoWcdma(CellInfo): + def __init__(self): + super().__init__() + self._identity = CellIdentityWcdma() + self._signal_strength = CellSignalStrengthWcdma() + + def getCellIdentity(self) -> CellIdentityWcdma: return self._identity + def getCellSignalStrength(self) -> CellSignalStrengthWcdma: return self._signal_strength + + +class CellInfoNr(CellInfo): + def __init__(self): + super().__init__() + self._identity = CellIdentityNr() + self._signal_strength = CellSignalStrengthNr() + + def getCellIdentity(self) -> CellIdentityNr: return self._identity + def getCellSignalStrength(self) -> CellSignalStrengthNr: return self._signal_strength + + +# ═══════════════════════════════════════════════════════════════ +# PhoneStateListener +# ═══════════════════════════════════════════════════════════════ + +class PhoneStateListener(Stub): + LISTEN_NONE = 0 + LISTEN_SERVICE_STATE = 1 + LISTEN_SIGNAL_STRENGTHS = 2 + LISTEN_MESSAGE_WAITING_INDICATOR = 4 + LISTEN_CALL_FORWARDING_INDICATOR = 8 + LISTEN_CELL_LOCATION = 16 + LISTEN_CALL_STATE = 32 + LISTEN_DATA_CONNECTION_STATE = 64 + LISTEN_DATA_ACTIVITY = 128 + LISTEN_SIGNAL_STRENGTH = 256 + LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH = 512 + LISTEN_CELL_INFO = 1024 + LISTEN_PRECISE_CALL_STATE = 2048 + LISTEN_PRECISE_DATA_CONNECTION_STATE = 4096 + LISTEN_DATA_CONNECTION_REAL_TIME_INFO = 8192 + LISTEN_OEM_HOOK_RAW_EVENT = 32768 + LISTEN_SRVCC_STATE_CHANGED = 65536 + LISTEN_CARRIER_NETWORK_CHANGE = 131072 + LISTEN_VOICE_ACTIVATION_STATE = 262144 + LISTEN_DATA_ACTIVATION_STATE = 524288 + LISTEN_USER_MOBILE_DATA_STATE = 1048576 + LISTEN_DISPLAY_INFO_CHANGED = 2097152 + LISTEN_PHONE_CAPABILITY_CHANGE = 4194304 + LISTEN_ACTIVE_PHONE_TYPE_CHANGE = 8388608 + LISTEN_EMERGENCY_NUMBER_LIST = 16777216 + LISTEN_EMERGENCY_NUMBER_SOURCE = 33554432 + LISTEN_CALL_ATTRIBUTES_CHANGED = 67108864 + LISTEN_BARRING_INFO_CHANGED = 134217728 + LISTEN_ALL = 2147483647 + + def __init__(self, looper: Any = None): + super().__init__() + self._looper = looper + + def onServiceStateChanged(self, service_state: "ServiceState"): + pass + + def onSignalStrengthsChanged(self, signal_strength: "SignalStrength"): + pass + + def onMessageWaitingIndicatorChanged(self, mwi: bool): + pass + + def onCallForwardingIndicatorChanged(self, cfi: bool): + pass + + def onCellLocationChanged(self, location: Any): + pass + + def onCallStateChanged(self, state: int, phone_number: str): + pass + + def onDataConnectionStateChanged(self, state: int, network_type: int = 0): + pass + + def onDataActivity(self, direction: int): + pass + + def onSignalStrengthChanged(self, asu: int): + pass + + def onCellInfoChanged(self, cell_info: List[CellInfo]): + pass + + +# ═══════════════════════════════════════════════════════════════ +# ServiceState / SignalStrength +# ═══════════════════════════════════════════════════════════════ + +class ServiceState(Stub): + STATE_IN_SERVICE = 0 + STATE_OUT_OF_SERVICE = 1 + STATE_EMERGENCY_ONLY = 2 + STATE_POWER_OFF = 3 + + def __init__(self): + super().__init__() + self._state = self.STATE_OUT_OF_SERVICE + self._roaming = False + self._operator_alpha_long: str = "" + self._operator_alpha_short: str = "" + self._operator_numeric: str = "" + self._is_manual_selection = False + self._cdma_default_roaming_indicator = -1 + self._cdma_eri_icon_index = -1 + self._cdma_eri_icon_mode = -1 + self._cdma_roaming_indicator = -1 + self._channel_number = 0 + + def getState(self) -> int: return self._state + def setState(self, state: int): self._state = state + def getRoaming(self) -> bool: return self._roaming + def setRoaming(self, roaming: bool): self._roaming = roaming + def getOperatorAlphaLong(self) -> str: return self._operator_alpha_long + def getOperatorAlphaShort(self) -> str: return self._operator_alpha_short + def getOperatorNumeric(self) -> str: return self._operator_numeric + def getIsManualSelection(self) -> bool: return self._is_manual_selection + def getCdmaDefaultRoamingIndicator(self) -> int: return self._cdma_default_roaming_indicator + def getCdmaEriIconIndex(self) -> int: return self._cdma_eri_icon_index + def getCdmaEriIconMode(self) -> int: return self._cdma_eri_icon_mode + def getCdmaRoamingIndicator(self) -> int: return self._cdma_roaming_indicator + def getChannelNumber(self) -> int: return self._channel_number + def getNetworkRegistrationInfo(self, domain: int, transport_type: int) -> Any: + return None + def toString(self) -> str: + return f"ServiceState(state={self._state}, roaming={self._roaming})" + + +class SignalStrength(Stub): + NUM_SIGNAL_STRENGTH_BINS = 5 + SIGNAL_STRENGTH_NONE_OR_UNKNOWN = 0 + SIGNAL_STRENGTH_POOR = 1 + SIGNAL_STRENGTH_MODERATE = 2 + SIGNAL_STRENGTH_GOOD = 3 + SIGNAL_STRENGTH_GREAT = 4 + + def __init__(self): + super().__init__() + self._gsm_signal_strength = 0 + self._cdma_dbm = 0 + self._cdma_ecio = 0 + self._evdo_dbm = 0 + self._evdo_ecio = 0 + self._evdo_snr = 0 + self._lte_signal_strength = 0 + self._td_scdma_rscp = 0 + + def getGsmSignalStrength(self) -> int: return self._gsm_signal_strength + def getCdmaDbm(self) -> int: return self._cdma_dbm + def getCdmaEcio(self) -> int: return self._cdma_ecio + def getEvdoDbm(self) -> int: return self._evdo_dbm + def getEvdoEcio(self) -> int: return self._evdo_ecio + def getEvdoSnr(self) -> int: return self._evdo_snr + def getLteSignalStrength(self) -> int: return self._lte_signal_strength + def getLevel(self) -> int: return self.SIGNAL_STRENGTH_NONE_OR_UNKNOWN + def getAsuLevel(self) -> int: return 0 + def getDbm(self) -> int: return 0 + + +# ═══════════════════════════════════════════════════════════════ +# SmsManager +# ═══════════════════════════════════════════════════════════════ + +class SmsManager(Stub): + RESULT_ERROR_GENERIC_FAILURE = 1 + RESULT_ERROR_RADIO_OFF = 2 + RESULT_ERROR_NULL_PDU = 3 + RESULT_ERROR_NO_SERVICE = 4 + RESULT_ERROR_LIMIT_EXCEEDED = 5 + RESULT_ERROR_FDN_CHECK_FAILURE = 6 + RESULT_ERROR_SHORT_CODE_NOT_ALLOWED = 7 + RESULT_ERROR_SHORT_CODE_NEVER_ALLOWED = 8 + RESULT_RIL_GENERIC_FAILURE = 9 + RESULT_RIL_RADIO_NOT_AVAILABLE = 10 + STATUS_ON_ICC_FREE = 0 + STATUS_ON_ICC_READ = 1 + STATUS_ON_ICC_UNREAD = 3 + STATUS_ON_ICC_SENT = 5 + STATUS_ON_ICC_UNSENT = 7 + + _instance: Optional["SmsManager"] = None + + def __init__(self): + super().__init__() + + @staticmethod + def getDefault() -> "SmsManager": + if SmsManager._instance is None: + SmsManager._instance = SmsManager() + return SmsManager._instance + + def sendTextMessage(self, dest_address: str, sc_address: Optional[str], + text: str, sent_intent: Any, delivery_intent: Any): + pass + + def sendMultipartTextMessage(self, dest_address: str, sc_address: Optional[str], + parts: List[str], sent_intents: Optional[List[Any]], + delivery_intents: Optional[List[Any]]): + pass + + def sendDataMessage(self, dest_address: str, sc_address: Optional[str], + dest_port: int, data: bytes, sent_intent: Any, + delivery_intent: Any): + pass + + def sendMultimediaMessage(self, context: Any, content_uri: str, + location_url: Optional[str], + config_overrides: Optional[Any], + sent_intent: Any): + pass + + +# ═══════════════════════════════════════════════════════════════ +# PhoneNumberUtils +# ═══════════════════════════════════════════════════════════════ + +class PhoneNumberUtils(Stub): + + FORMAT_JAPAN = 2 + FORMAT_NANP = 1 + FORMAT_UNKNOWN = 0 + + @staticmethod + def formatNumber(source: str) -> str: + return source + + @staticmethod + def isGlobalPhoneNumber(phone_number: str) -> bool: + return bool(phone_number and len(phone_number) >= 7) + + @staticmethod + def compare(a: str, b: str) -> bool: + return a.replace("-", "").replace(" ", "") == b.replace("-", "").replace(" ", "") + + @staticmethod + def formatNumberToE164(phone_number: str, default_country_iso: str) -> Optional[str]: + return phone_number + + @staticmethod + def formatNumberToRFC3966(phone_number: str, default_country_iso: str) -> Optional[str]: + return phone_number + + @staticmethod + def isEmergencyNumber(phone_number: str) -> bool: + return phone_number in ("911", "112", "999", "000", "110", "119", "120", "122") + + @staticmethod + def isVoiceMailNumber(phone_number: str) -> bool: + return False + + @staticmethod + def convertKeypadLettersToDigits(input_: str) -> str: + mapping = {"A": "2", "B": "2", "C": "2", "D": "3", "E": "3", + "F": "3", "G": "4", "H": "4", "I": "4", "J": "5", + "K": "5", "L": "5", "M": "6", "N": "6", "O": "6", + "P": "7", "Q": "7", "R": "7", "S": "7", "T": "8", + "U": "8", "V": "8", "W": "9", "X": "9", "Y": "9", "Z": "9"} + result = "" + for c in input_.upper(): + result += mapping.get(c, c) + return result + + @staticmethod + def toCallerIDMinMatch(phone_number: str) -> str: + return phone_number[-7:] if len(phone_number) >= 7 else phone_number + + +# ═══════════════════════════════════════════════════════════════ +# TelephonyManager +# ═══════════════════════════════════════════════════════════════ + +class TelephonyManager(Stub): + """TelephonyManager — 电话管理器""" + + PHONE_TYPE_NONE = 0 + PHONE_TYPE_GSM = 1 + PHONE_TYPE_CDMA = 2 + PHONE_TYPE_SIP = 3 + + NETWORK_TYPE_UNKNOWN = 0 + NETWORK_TYPE_GPRS = 1 + NETWORK_TYPE_EDGE = 2 + NETWORK_TYPE_UMTS = 3 + NETWORK_TYPE_CDMA = 4 + NETWORK_TYPE_EVDO_0 = 5 + NETWORK_TYPE_EVDO_A = 6 + NETWORK_TYPE_1xRTT = 7 + NETWORK_TYPE_HSDPA = 8 + NETWORK_TYPE_HSUPA = 9 + NETWORK_TYPE_HSPA = 10 + NETWORK_TYPE_IDEN = 11 + NETWORK_TYPE_EVDO_B = 12 + NETWORK_TYPE_LTE = 13 + NETWORK_TYPE_EHRPD = 14 + NETWORK_TYPE_HSPAP = 15 + NETWORK_TYPE_GSM = 16 + NETWORK_TYPE_TD_SCDMA = 17 + NETWORK_TYPE_IWLAN = 18 + NETWORK_TYPE_LTE_CA = 19 + NETWORK_TYPE_NR = 20 + + SIM_STATE_UNKNOWN = 0 + SIM_STATE_ABSENT = 1 + SIM_STATE_PIN_REQUIRED = 2 + SIM_STATE_PUK_REQUIRED = 3 + SIM_STATE_NETWORK_LOCKED = 4 + SIM_STATE_READY = 5 + SIM_STATE_NOT_READY = 6 + SIM_STATE_PERM_DISABLED = 7 + + DATA_DISCONNECTED = 0 + DATA_CONNECTING = 1 + DATA_CONNECTED = 2 + DATA_SUSPENDED = 3 + + CALL_STATE_IDLE = 0 + CALL_STATE_RINGING = 1 + CALL_STATE_OFFHOOK = 2 + + def __init__(self, context: Any = None): + super().__init__() + self._context = context + + def getNetworkOperatorName(self) -> str: + return "MockOperator" + + def getNetworkOperator(self) -> str: + return "310260" + + def getNetworkCountryIso(self) -> str: + return "us" + + def getNetworkType(self) -> int: + return self.NETWORK_TYPE_LTE + + def getPhoneType(self) -> int: + return self.PHONE_TYPE_GSM + + def getDataNetworkType(self) -> int: + return self.NETWORK_TYPE_LTE + + def getVoiceNetworkType(self) -> int: + return self.NETWORK_TYPE_LTE + + def getSimOperator(self) -> str: + return "310260" + + def getSimOperatorName(self) -> str: + return "MockSIM" + + def getSimCountryIso(self) -> str: + return "us" + + def getSimSerialNumber(self) -> Optional[str]: + return "89014103211118510720" + + def getSubscriberId(self) -> Optional[str]: + return "310260123456789" + + def getDeviceId(self) -> Optional[str]: + return "000000000000000" + + def getDeviceSoftwareVersion(self) -> Optional[str]: + return "00.00.00.00" + + def getLine1Number(self) -> Optional[str]: + return "15551234567" + + def getGroupIdLevel1(self) -> Optional[str]: + return "" + + def getIccAuthentication(self, app_type: int, aid: str, data: bytes) -> Optional[bytes]: + return None + + def getVoiceMailNumber(self) -> Optional[str]: + return "15551234567" + + def getVoiceMailAlphaTag(self) -> str: + return "Voicemail" + + def isNetworkRoaming(self) -> bool: + return False + + def hasIccCard(self) -> bool: + return True + + def getSimState(self) -> int: + return self.SIM_STATE_READY + + def getCellLocation(self) -> Any: + return None + + def getAllCellInfo(self) -> Optional[List[CellInfo]]: + return [] + + def getMmsUserAgent(self) -> str: + return "Android-Mms/1.0" + + def getMmsUAProfUrl(self) -> str: + return "http://www.example.com/uaprof.xml" + + def listen(self, listener: PhoneStateListener, events: int): + pass + + def getDataState(self) -> int: + return self.DATA_CONNECTED + + def getDataActivity(self) -> int: + return 0 # DATA_ACTIVITY_NONE + + def getCallState(self) -> int: + return self.CALL_STATE_IDLE + + def toString(self) -> str: + return "TelephonyManager()" + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "TelephonyManager", + "CellInfo", + "CellInfoGsm", + "CellInfoCdma", + "CellInfoLte", + "CellInfoWcdma", + "CellInfoNr", + "CellIdentityGsm", + "CellIdentityCdma", + "CellIdentityLte", + "CellIdentityWcdma", + "CellIdentityNr", + "CellSignalStrengthGsm", + "CellSignalStrengthCdma", + "CellSignalStrengthLte", + "CellSignalStrengthWcdma", + "CellSignalStrengthNr", + "PhoneStateListener", + "PhoneNumberUtils", + "ServiceState", + "SignalStrength", + "SmsManager", +] \ No newline at end of file diff --git a/android_pyapi/android/text.py b/android_pyapi/android/text.py new file mode 100644 index 0000000..0b1405f --- /dev/null +++ b/android_pyapi/android/text.py @@ -0,0 +1,1106 @@ +""" +Android Text 组件 — TextUtils, SpannableString, Html, Layout 等 +方法签名完全对齐 Android SDK +""" + +import html as _html +import re as _re +import sys +from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Type, Union + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, +) + + +# ═══════════════════════════════════════════════════════════════ +# Typeface +# ═══════════════════════════════════════════════════════════════ + +class Typeface(Stub): + """Typeface — 字体""" + + NORMAL = 0 + BOLD = 1 + ITALIC = 2 + BOLD_ITALIC = 3 + + DEFAULT: "Typeface" = None + DEFAULT_BOLD: "Typeface" = None + MONOSPACE: "Typeface" = None + SANS_SERIF: "Typeface" = None + SERIF: "Typeface" = None + + def __init__(self, family_name: str = "", style: int = NORMAL): + super().__init__() + self._family_name = family_name + self._style = style + self._weight = 400 if style in (self.NORMAL,) else 700 + + @staticmethod + def defaultFromStyle(style: int) -> "Typeface": + tf = Typeface("sans-serif", style) + return tf + + @staticmethod + def create(family_name: str, style: int) -> "Typeface": + return Typeface(family_name, style) + + @staticmethod + def createFromFile(path: str) -> "Typeface": + return Typeface("custom") + + def getStyle(self) -> int: + return self._style + + def getWeight(self) -> int: + return self._weight + + def isBold(self) -> bool: + return self._style in (self.BOLD, self.BOLD_ITALIC) + + def isItalic(self) -> bool: + return self._style in (self.ITALIC, self.BOLD_ITALIC) + + def toString(self) -> str: + return f"Typeface({self._family_name}, style={self._style})" + + +# Initialize Typeface constants +Typeface.DEFAULT = Typeface("sans-serif", Typeface.NORMAL) +Typeface.DEFAULT_BOLD = Typeface("sans-serif", Typeface.BOLD) +Typeface.MONOSPACE = Typeface("monospace", Typeface.NORMAL) +Typeface.SANS_SERIF = Typeface("sans-serif", Typeface.NORMAL) +Typeface.SERIF = Typeface("serif", Typeface.NORMAL) + + +# ═══════════════════════════════════════════════════════════════ +# TextPaint +# ═══════════════════════════════════════════════════════════════ + +class TextPaint(Stub): + """TextPaint — 文本绘制画笔""" + + def __init__(self, flags: int = 0): + super().__init__() + self.bgColor = 0 + self.bgColorSet = False + self.linkColor = 0xFF0000FF # blue + self.underlineWidth = 0.0 + self.baselineShift = 0 + self.bulletRadius = 0.0 + self.bulletGap = 0 + self.bulletColor = 0 + self.color = 0xFF000000 + self.textSize = 14.0 + self.typeface: Optional[Typeface] = Typeface.DEFAULT + self.flags = flags + self.antiAlias = True + self.style = Typeface.NORMAL + self.strokeWidth = 0.0 + self.strokeCap = "butt" + self.strokeJoin = "miter" + self.shadowDx = 0.0 + self.shadowDy = 0.0 + self.shadowRadius = 0.0 + self.shadowColor = 0 + self.elevation = 0.0 + self.letterSpacing = 0.0 + self.fontFeatureSettings = "" + self.fontVariationSettings = "" + + def setUnderlineText(self, underline: bool): + if underline: + self.underlineWidth = 1.0 + else: + self.underlineWidth = 0.0 + + def getColor(self) -> int: + return self.color + + def setColor(self, color: int): + self.color = color + + def setARGB(self, a: int, r: int, g: int, b: int): + self.color = ((a & 0xFF) << 24) | ((r & 0xFF) << 16) | ((g & 0xFF) << 8) | (b & 0xFF) + + def getTextSize(self) -> float: + return self.textSize + + def setTextSize(self, size: float): + self.textSize = size + + def getTypeface(self) -> Optional[Typeface]: + return self.typeface + + def setTypeface(self, tf: Typeface): + self.typeface = tf + + def setAntiAlias(self, aa: bool): + self.antiAlias = aa + + def measureText(self, text: str) -> float: + return len(text) * self.textSize * 0.5 + + def toString(self) -> str: + return f"TextPaint(size={self.textSize}, color={self.color})" + + +# ═══════════════════════════════════════════════════════════════ +# TextUtils +# ═══════════════════════════════════════════════════════════════ + +class TextUtils(Stub): + """TextUtils — 文本工具""" + + CAP_MODE_SENTENCES = 0 + CAP_MODE_WORDS = 1 + CAP_MODE_CHARACTERS = 2 + + @staticmethod + def isEmpty(str_: Optional[str]) -> bool: + return str_ is None or len(str_) == 0 + + @staticmethod + def isBlank(str_: Optional[str]) -> bool: + return str_ is None or str_.strip() == "" + + @staticmethod + def equals(a: Optional[str], b: Optional[str]) -> bool: + return a == b + + @staticmethod + def join(delimiter: str, tokens: Sequence[str]) -> str: + return delimiter.join(tokens) + + @staticmethod + def split(text: str, delimiter: str) -> List[str]: + return text.split(delimiter) + + @staticmethod + def htmlEncode(s: str) -> str: + return _html.escape(s, quote=True) + + @staticmethod + def htmlDecode(s: str) -> str: + return _html.unescape(s) + + @staticmethod + def getReverse(s: str, start: int, end: int) -> str: + return s[start:end][::-1] + + @staticmethod + def substring(text: str, start: int, end: int) -> str: + return text[start:end] + + @staticmethod + def delimitedListToStringArray(text: str, delimiter: str, delimiter2: str = "") -> List[str]: + if not text: + return [] + return [t.strip() for t in text.split(delimiter)] + + @staticmethod + def commaEllipsize(text: str, max_width: int, paint: Any, + one_origin: bool = False, ellipsize: bool = False) -> str: + if len(text) <= max_width: + return text + return text[:max_width] + "..." + + @staticmethod + def ellipsize(text: str, paint: Any, avail: float, + where: Any, ellipsis: str = "...") -> str: + if paint and hasattr(paint, 'measureText'): + text_width = paint.measureText(text) + if text_width <= avail: + return text + max_chars = int(avail / 7) if avail else len(text) // 2 + if max_chars >= len(text): + return text + if str(where) == "END": + return text[:max_chars] + ellipsis + elif str(where) == "START": + return ellipsis + text[-max_chars:] + elif str(where) == "MIDDLE": + half = max_chars // 2 + return text[:half] + ellipsis + text[-(max_chars - half):] + return text[:max_chars] + ellipsis + + @staticmethod + def isDigitsOnly(s: str) -> bool: + return s.isdigit() if s else False + + @staticmethod + def isGraphical(s: str) -> bool: + return bool(s and s.isprintable()) + + @staticmethod + def capitalize(s: str) -> str: + return s.capitalize() + + @staticmethod + def trim(s: str) -> str: + return s.strip() + + @staticmethod + def getTrimmedLength(s: str) -> int: + return len(s.strip()) + + @staticmethod + def stringOrEmpty(s: Optional[str]) -> str: + return s or "" + + @staticmethod + def copySpansFrom(source: Any, start: int, end: int, kind: type, + dest: Any, dest_offset: int = 0): + pass + + @staticmethod + def removeEmptySpans(spans: List, source: Any, kind: type) -> List: + return [s for s in spans if s is not None] + + @staticmethod + def expandTemplate(template: str, values: List[str]) -> str: + result = template + for i, v in enumerate(values): + result = result.replace("$" + str(i + 1), v) + return result + + +# ═══════════════════════════════════════════════════════════════ +# Span 相关接口和基类 +# ═══════════════════════════════════════════════════════════════ + +class Spanned(Stub): + """Spanned 接口 — 带标记的字符串""" + + SPAN_POINT_MARK = 0 + SPAN_MARK_MARK = 1 + SPAN_POINT_POINT = 2 + SPAN_MARK_POINT = 3 + SPAN_PARAGRAPH = 3 + SPAN_INCLUSIVE_EXCLUSIVE = SPAN_MARK_POINT + SPAN_INCLUSIVE_INCLUSIVE = SPAN_MARK_MARK + SPAN_EXCLUSIVE_EXCLUSIVE = SPAN_POINT_POINT + SPAN_EXCLUSIVE_INCLUSIVE = SPAN_POINT_MARK + SPAN_COMPOSING = 256 + SPAN_USER = 0x01000000 + SPAN_USER_SHIFT = 24 + SPAN_PRIORITY = 0x0000FF00 + SPAN_PRIORITY_SHIFT = 8 + SPAN_INTERMEDIATE = 0x00100000 + + def __init__(self, source: str = ""): + super().__init__() + self._source = source + self._spans: Dict[Tuple[type, int], Tuple[int, int, Any]] = {} # (type, id) -> (start, end, span_obj) + + def setSpan(self, span_obj: Any, start: int, end: int, flags: int): + span_id = id(span_obj) + span_type = type(span_obj) + self._spans[(span_type, span_id)] = (start, end, span_obj) + + def removeSpan(self, span_obj: Any): + span_id = id(span_obj) + span_type = type(span_obj) + self._spans.pop((span_type, span_id), None) + + def getSpans(self, start: int, end: int, span_type: Optional[type] = None) -> List[Any]: + result = [] + for (st, sid), (s, e, obj) in self._spans.items(): + if span_type is None or st == span_type: + if s < end and e > start: + result.append(obj) + return result + + def getSpanStart(self, span_obj: Any) -> int: + span_id = id(span_obj) + span_type = type(span_obj) + data = self._spans.get((span_type, span_id)) + return data[0] if data else -1 + + def getSpanEnd(self, span_obj: Any) -> int: + span_id = id(span_obj) + span_type = type(span_obj) + data = self._spans.get((span_type, span_id)) + return data[1] if data else -1 + + def getSpanFlags(self, span_obj: Any) -> int: + span_id = id(span_obj) + span_type = type(span_obj) + data = self._spans.get((span_type, span_id)) + return 0 if data is None else 0 + + def nextSpanTransition(self, start: int, end: int, span_type: Optional[type] = None) -> int: + return end + + def toString(self) -> str: + return self._source + + def __len__(self) -> int: + return len(self._source) + + def __getitem__(self, index): + return self._source[index] + + def __str__(self): + return self._source + + def length(self) -> int: + return len(self._source) + + +class Editable(Spanned): + """Editable — 可编辑文本接口""" + + def __init__(self, source: str = ""): + super().__init__(source) + + def append(self, text: Any) -> "Editable": + self._source += str(text) + return self + + def insert(self, where: int, text: Any): + self._source = self._source[:where] + str(text) + self._source[where:] + + def replace(self, start: int, end: int, text: Any): + self._source = self._source[:start] + str(text) + self._source[end:] + + def delete(self, start: int, end: int): + self._source = self._source[:start] + self._source[end:] + + def clear(self): + self._source = "" + + def clearSpans(self): + self._spans.clear() + + def getChars(self, start: int, end: int, dest: List[str], destoff: int): + for i, c in enumerate(self._source[start:end]): + if destoff + i < len(dest): + dest[destoff + i] = c + + +# ═══════════════════════════════════════════════════════════════ +# SpannableString +# ═══════════════════════════════════════════════════════════════ + +class SpannableString(Spanned): + """SpannableString — 不可变但可标记的字符串""" + + def __init__(self, source: str): + super().__init__(source) + self._source = source + + def setSpan(self, span_obj: Any, start: int, end: int, flags: int): + super().setSpan(span_obj, start, end, flags) + + def removeSpan(self, span_obj: Any): + super().removeSpan(span_obj) + + def toString(self) -> str: + return self._source + + def __str__(self): + return self._source + + @staticmethod + def valueOf(source: str) -> "SpannableString": + return SpannableString(source) + + def length(self) -> int: + return len(self._source) + + def charAt(self, index: int) -> str: + return self._source[index] + + def subSequence(self, start: int, end: int) -> str: + return self._source[start:end] + + +# ═══════════════════════════════════════════════════════════════ +# SpannableStringBuilder +# ═══════════════════════════════════════════════════════════════ + +class SpannableStringBuilder(Editable): + """SpannableStringBuilder — 可变可标记字符串构建器""" + + def __init__(self, source: Any = None): + if source is None: + super().__init__("") + elif isinstance(source, str): + super().__init__(source) + elif isinstance(source, Spanned): + super().__init__(source.toString()) + else: + super().__init__(str(source)) + + def append(self, text: Any) -> "SpannableStringBuilder": + super().append(text) + return self + + def append(self, text: Any, start: int, end: int) -> "SpannableStringBuilder": + if isinstance(text, str): + self._source += text[start:end] + else: + self._source += str(text)[start:end] + return self + + def insert(self, where: int, text: Any) -> "SpannableStringBuilder": + super().insert(where, text) + return self + + def replace(self, start: int, end: int, text: Any) -> "SpannableStringBuilder": + super().replace(start, end, text) + return self + + def delete(self, start: int, end: int) -> "SpannableStringBuilder": + super().delete(start, end) + return self + + def setSpan(self, span_obj: Any, start: int, end: int, flags: int): + super().setSpan(span_obj, start, end, flags) + + def clear(self): + super().clear() + + def clearSpans(self): + super().clearSpans() + + def length(self) -> int: + return len(self._source) + + def charAt(self, index: int) -> str: + return self._source[index] if 0 <= index < len(self._source) else "" + + def subSequence(self, start: int, end: int) -> str: + return self._source[start:end] + + def toString(self) -> str: + return self._source + + def __str__(self): + return self._source + + def __iadd__(self, other: Any) -> "SpannableStringBuilder": + self.append(str(other)) + return self + + +# ═══════════════════════════════════════════════════════════════ +# TextWatcher +# ═══════════════════════════════════════════════════════════════ + +class TextWatcher(Stub): + """TextWatcher — 文本变化监听器""" + + def beforeTextChanged(self, s: str, start: int, count: int, after: int): + pass + + def onTextChanged(self, s: str, start: int, before: int, count: int): + pass + + def afterTextChanged(self, s: Any): + pass + + +# ═══════════════════════════════════════════════════════════════ +# InputFilter / LengthFilter +# ═══════════════════════════════════════════════════════════════ + +class InputFilter(Stub): + """InputFilter — 输入过滤器接口""" + + class LengthFilter(Stub): + """LengthFilter — 长度限制过滤器""" + + def __init__(self, max_length: int): + super().__init__() + self._max_length = max_length + + def filter(self, source: str, start: int, end: int, dest: Spanned, + dstart: int, dend: int) -> Optional[str]: + keep = self._max_length - (len(dest.toString()) - (dend - dstart)) + if keep <= 0: + return "" + if keep >= (end - start): + return None # keep original + return source[start:start + keep] + + def getMax(self) -> int: + return self._max_length + + @staticmethod + def allCaps() -> "InputFilter": + f = InputFilter() + f._transform = lambda s: s.upper() + return f + + def filter(self, source: str, start: int, end: int, dest: Spanned, + dstart: int, dend: int) -> Optional[str]: + return None + + +# ═══════════════════════════════════════════════════════════════ +# Html +# ═══════════════════════════════════════════════════════════════ + +class Html(Stub): + """Html — HTML 文本处理""" + + FROM_HTML_MODE_COMPACT = 0 + FROM_HTML_MODE_LEGACY = 1 + FROM_HTML_OPTION_USE_CSS_COLORS = 256 + FROM_HTML_SEPARATOR_LINE_BREAK_BLOCKQUOTE = 0x00000001 + FROM_HTML_SEPARATOR_LINE_BREAK_DIV = 0x00000002 + FROM_HTML_SEPARATOR_LINE_BREAK_HEADING = 0x00000004 + FROM_HTML_SEPARATOR_LINE_BREAK_LIST_ITEM = 0x00000008 + FROM_HTML_SEPARATOR_LINE_BREAK_LIST = 0x00000020 + FROM_HTML_SEPARATOR_LINE_BREAK_TABLE = 0x00000040 + TO_HTML_PARAGRAPH_LINES_INDIVIDUAL = 0x00000001 + TO_HTML_PARAGRAPH_LINE_CONSECUTIVE = 0x00000002 + + _TAG_RE = _re.compile(r"<[^>]*>") + _BR_RE = _re.compile(r"", _re.IGNORECASE) + _P_RE = _re.compile(r"

|]*>", _re.IGNORECASE) + + @staticmethod + def fromHtml(html_text: str, flags: int = 0) -> str: + """将 HTML 转为纯文本""" + text = html_text + text = Html._BR_RE.sub("\n", text) + text = Html._P_RE.sub("\n\n", text) + text = Html._TAG_RE.sub("", text) + text = _html.unescape(text) + return text.strip() + + @staticmethod + def toHtml(text: str, option: int = 0) -> str: + """将纯文本转为 HTML""" + paragraphs = text.split("\n") + html_parts = [] + for p in paragraphs: + escaped = _html.escape(p) + html_parts.append(f"

{escaped}

") + return "".join(html_parts) + + @staticmethod + def fromHtml(html_text: str, image_getter: Any, tag_handler: Any) -> str: + return Html.fromHtml(html_text) + + @staticmethod + def toHtmlWithOptions(text: str, options: int) -> str: + return Html.toHtml(text) + + class ImageGetter: + def getDrawable(self, source: str): + return None + + class TagHandler: + def handleTag(self, opening: bool, tag: str, output: Editable, xml_reader: Any): + pass + + +# ═══════════════════════════════════════════════════════════════ +# CharacterStyle / 各 Span 实现 +# ═══════════════════════════════════════════════════════════════ + +class CharacterStyle(Stub): + """CharacterStyle — 字符样式基类""" + + def underLine(self): + pass + + def updateDrawState(self, tp: TextPaint): + pass + + def getUnderline(self) -> bool: + return False + + @staticmethod + def wrap(cs: "CharacterStyle") -> "CharacterStyle": + return cs + + +class StyleSpan(CharacterStyle): + """StyleSpan — 字体样式""" + + def __init__(self, style: int): + super().__init__() + self._style = style + + def getStyle(self) -> int: + return self._style + + def updateDrawState(self, tp: TextPaint): + tp.style = self._style + + +class TypefaceSpan(CharacterStyle): + """TypefaceSpan — 字体族""" + + def __init__(self, family: str): + super().__init__() + self._family = family + + def getFamily(self) -> str: + return self._family + + def updateDrawState(self, tp: TextPaint): + if self._family == "monospace": + tp.typeface = Typeface.MONOSPACE + elif self._family == "serif": + tp.typeface = Typeface.SERIF + else: + tp.typeface = Typeface.DEFAULT + + +class RelativeSizeSpan(CharacterStyle): + """RelativeSizeSpan — 相对大小""" + + def __init__(self, size: float): + super().__init__() + self._size = size + + def getSizeChange(self) -> float: + return self._size + + def updateDrawState(self, tp: TextPaint): + tp.textSize *= self._size + + +class ForegroundColorSpan(CharacterStyle): + """ForegroundColorSpan — 前景色""" + + def __init__(self, color: int): + super().__init__() + self._color = color + + def getForegroundColor(self) -> int: + return self._color + + def updateDrawState(self, tp: TextPaint): + tp.color = self._color + + +class BackgroundColorSpan(CharacterStyle): + """BackgroundColorSpan — 背景色""" + + def __init__(self, color: int): + super().__init__() + self._color = color + + def getBackgroundColor(self) -> int: + return self._color + + def updateDrawState(self, tp: TextPaint): + tp.bgColor = self._color + tp.bgColorSet = True + + +class UnderlineSpan(CharacterStyle): + """UnderlineSpan — 下划线""" + + def updateDrawState(self, tp: TextPaint): + tp.setUnderlineText(True) + + +class StrikethroughSpan(CharacterStyle): + """StrikethroughSpan — 删除线""" + + def updateDrawState(self, tp: TextPaint): + pass # desktop 无直接等价 + + +class SubscriptSpan(CharacterStyle): + """SubscriptSpan — 下标""" + + def updateDrawState(self, tp: TextPaint): + tp.baselineShift = -tp.textSize / 4 + + +class SuperscriptSpan(CharacterStyle): + """SuperscriptSpan — 上标""" + + def updateDrawState(self, tp: TextPaint): + tp.baselineShift = tp.textSize / 2 + + +class ImageSpan(CharacterStyle): + """ImageSpan — 图片""" + + ALIGN_BOTTOM = 0 + ALIGN_BASELINE = 1 + ALIGN_CENTER = 2 + ALIGN_TOP = 3 + + def __init__(self, drawable: Any, source: str = "", align: int = ALIGN_BOTTOM): + super().__init__() + self._drawable = drawable + self._source = source + self._align = align + + def getDrawable(self): + return self._drawable + + def getSource(self) -> str: + return self._source + + def getAlignment(self) -> int: + return self._align + + +class ClickableSpan(CharacterStyle): + """ClickableSpan — 可点击文本""" + + def __init__(self): + super().__init__() + + def onClick(self, view: Any): + pass + + def updateDrawState(self, tp: TextPaint): + tp.color = tp.linkColor + tp.setUnderlineText(True) + + +class URLSpan(ClickableSpan): + """URLSpan — URL 链接""" + + def __init__(self, url: str): + super().__init__() + self._url = url + + def getURL(self) -> str: + return self._url + + def onClick(self, view: Any): + sys.stderr.write(f"[URLSpan] onClick: {self._url}\n") + + def updateDrawState(self, tp: TextPaint): + super().updateDrawState(tp) + + +# ═══════════════════════════════════════════════════════════════ +# NoCopySpan / ParagraphStyle 接口 +# ═══════════════════════════════════════════════════════════════ + +class NoCopySpan(Stub): + """NoCopySpan — 标记不在拷贝时复制的 span""" + pass + +class NoCopySpanConcise(NoCopySpan): + """NoCopySpan.Concrete — 具体实现""" + pass + + +class ParagraphStyle(Stub): + """ParagraphStyle — 段落样式接口""" + pass + + +# ═══════════════════════════════════════════════════════════════ +# Ellipsize / TruncateAt 枚举 +# ═══════════════════════════════════════════════════════════════ + +class Ellipsize(Stub): + """Ellipsize 常量""" + END = "END" + MIDDLE = "MIDDLE" + MARQUEE = "MARQUEE" + START = "START" + NONE = "NONE" + + +class TruncateAt(Stub): + """TruncateAt 常量""" + END = "END" + MIDDLE = "MIDDLE" + MARQUEE = "MARQUEE" + START = "START" + + +# ═══════════════════════════════════════════════════════════════ +# Align +# ═══════════════════════════════════════════════════════════════ + +class Align(Stub): + """Layout.Alignment 枚举""" + ALIGN_NORMAL = 0 + ALIGN_OPPOSITE = 1 + ALIGN_CENTER = 2 + + +# ═══════════════════════════════════════════════════════════════ +# TextDirectionHeuristic / TextDirectionHeuristics +# ═══════════════════════════════════════════════════════════════ + +class TextDirectionHeuristic(Stub): + """TextDirectionHeuristic — 文本方向启发式""" + pass + + +class TextDirectionHeuristics(Stub): + """TextDirectionHeuristics — 文本方向启发式常量""" + + FIRSTSTRONG_LTR = TextDirectionHeuristic() + FIRSTSTRONG_RTL = TextDirectionHeuristic() + ANYRTL_LTR = TextDirectionHeuristic() + LTR = TextDirectionHeuristic() + RTL = TextDirectionHeuristic() + LOCALE = TextDirectionHeuristic() + + +# ═══════════════════════════════════════════════════════════════ +# LoginFilter +# ═══════════════════════════════════════════════════════════════ + +class LoginFilter(InputFilter): + """LoginFilter — 登录名输入过滤器""" + + def __init__(self, append_ok: bool = True): + super().__init__() + self._append_ok = append_ok + + def isAllowed(self, c: str) -> bool: + return c.isalnum() or c in "@._-" + + def filter(self, source: str, start: int, end: int, dest: Spanned, + dstart: int, dend: int) -> Optional[str]: + filtered = [] + for c in source[start:end]: + if self.isAllowed(c): + filtered.append(c) + elif self._append_ok: + pass + result = "".join(filtered) + return result if result != source else None + + class UsernameFilterGMail(InputFilter): + def filter(self, source, start, end, dest, dstart, dend): + result = [] + for c in source[start:end]: + if c.isalnum() or c in "@._-": + result.append(c) + return "".join(result) or None + + class PasswordFilterGMail(InputFilter): + def filter(self, source, start, end, dest, dstart, dend): + return None + + +# ═══════════════════════════════════════════════════════════════ +# Method / MovementMethod +# ═══════════════════════════════════════════════════════════════ + +class Method(Stub): + """Method — 输入法接口""" + pass + + +class MovementMethod(Stub): + """MovementMethod — 移动方式接口""" + pass + + +# ═══════════════════════════════════════════════════════════════ +# Layout / StaticLayout / DynamicLayout / BoringLayout +# ═══════════════════════════════════════════════════════════════ + +class Layout(Stub): + """Layout — 布局基类""" + + Alignment = Align + + BREAK_STRATEGY_SIMPLE = 0 + BREAK_STRATEGY_HIGH_QUALITY = 1 + BREAK_STRATEGY_BALANCED = 2 + + HYPHENATION_FREQUENCY_NONE = 0 + HYPHENATION_FREQUENCY_NORMAL = 1 + HYPHENATION_FREQUENCY_FULL = 2 + + JUSTIFICATION_MODE_NONE = 0 + JUSTIFICATION_MODE_INTER_WORD = 1 + + def __init__(self, text: str, paint: TextPaint, width: int, alignment: int, + spacing_mult: float, spacing_add: float): + super().__init__() + self._text = text + self._paint = paint + self._width = width + self._alignment = alignment + self._spacing_mult = spacing_mult + self._spacing_add = spacing_add + self._line_count = max(1, len(text) // max(1, width // 10) + 1) + + def getLineCount(self) -> int: + return self._line_count + + def getLineBounds(self, line: int, bounds: Optional[Any]) -> int: + line_height = int(self._paint.textSize * self._spacing_mult + self._spacing_add) + return line * line_height + + def getPrimaryHorizontal(self, offset: int) -> float: + line = 0 + return (offset % max(1, self._width)) * self._paint.measureText("x") + + def getSecondaryHorizontal(self, offset: int) -> float: + return 0.0 + + def getLineTop(self, line: int) -> int: + line_height = int(self._paint.textSize * self._spacing_mult + self._spacing_add) + return line * line_height + + def getLineBottom(self, line: int) -> int: + line_height = int(self._paint.textSize * self._spacing_mult + self._spacing_add) + return (line + 1) * line_height + + def getLineStart(self, line: int) -> int: + chars_per_line = max(1, self._width // max(1, int(self._paint.measureText("x")))) + return line * chars_per_line + + def getLineEnd(self, line: int) -> int: + chars_per_line = max(1, self._width // max(1, int(self._paint.measureText("x")))) + return min((line + 1) * chars_per_line, len(self._text)) + + def getText(self) -> str: + return self._text + + def getPaint(self) -> TextPaint: + return self._paint + + def getWidth(self) -> int: + return self._width + + def getAlignment(self) -> int: + return self._alignment + + def getSpacingMultiplier(self) -> float: + return self._spacing_mult + + def getSpacingAdd(self) -> float: + return self._spacing_add + + def isRtlCharAt(self, offset: int) -> bool: + return False + + def getParagraphDirection(self, line: int) -> int: + return 1 + + def draw(self, canvas: Any): + pass + + +class StaticLayout(Layout): + """StaticLayout — 静态布局""" + + def __init__(self, source: str, paint: TextPaint, width: int, alignment: int, + spacing_mult: float, spacing_add: float, include_pad: bool): + super().__init__(source, paint, width, alignment, spacing_mult, spacing_add) + self._include_pad = include_pad + + +class DynamicLayout(Layout): + """DynamicLayout — 动态布局""" + + def __init__(self, base: Any, paint: TextPaint, width: int, alignment: int, + spacing_mult: float, spacing_add: float, include_pad: bool, + ellipsize: Any = None, ellipsize_width: int = 0): + super().__init__(str(base), paint, width, alignment, spacing_mult, spacing_add) + self._include_pad = include_pad + + +class BoringLayout(Layout): + """BoringLayout — 单行布局""" + + def __init__(self, source: str, paint: TextPaint, width: int, alignment: int, + spacing_mult: float, spacing_add: float, include_pad: bool, + ellipsize: Any = None, ellipsize_width: int = 0): + super().__init__(source, paint, width, alignment, spacing_mult, spacing_add) + self._include_pad = include_pad + self._line_count = 1 if source else 0 + + class Metrics(Stub): + """Metrics for BoringLayout""" + width = 0 + height = 0 + + @staticmethod + def isBoring(text: str, paint: TextPaint) -> Optional["BoringLayout.Metrics"]: + m = BoringLayout.Metrics() + m.width = int(paint.measureText(text)) + m.height = int(paint.textSize) + return m if text else None + + @staticmethod + def make(source: str, paint: TextPaint, width: int, alignment: int, + spacing_mult: float, spacing_add: float, metrics: "BoringLayout.Metrics", + include_pad: bool) -> "BoringLayout": + return BoringLayout(source, paint, width, alignment, spacing_mult, spacing_add, include_pad) + + +class ClipRectangle(Stub): + """ClipRectangle — 裁剪矩形""" + def __init__(self, left: int = 0, top: int = 0, right: int = 0, bottom: int = 0): + super().__init__() + self.left = left + self.top = top + self.right = right + self.bottom = bottom + + +# ═══════════════════════════════════════════════════════════════ +# Spannable (接口别名) +# ═══════════════════════════════════════════════════════════════ + +class Spannable(Spanned): + """Spannable — 可标记接口""" + pass + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "TextUtils", + "SpannableString", + "SpannableStringBuilder", + "Spannable", + "Editable", + "Spanned", + "TextWatcher", + "InputFilter", + "Html", + "Layout", + "StaticLayout", + "DynamicLayout", + "BoringLayout", + "ClipRectangle", + "TextPaint", + "TextDirectionHeuristic", + "TextDirectionHeuristics", + "Align", + "Ellipsize", + "TruncateAt", + "LoginFilter", + "Method", + "MovementMethod", + "NoCopySpan", + "ParagraphStyle", + "CharacterStyle", + "StyleSpan", + "TypefaceSpan", + "RelativeSizeSpan", + "ForegroundColorSpan", + "BackgroundColorSpan", + "UnderlineSpan", + "StrikethroughSpan", + "SubscriptSpan", + "SuperscriptSpan", + "ImageSpan", + "ClickableSpan", + "URLSpan", + "Typeface", +] \ No newline at end of file diff --git a/android_pyapi/android/util.py b/android_pyapi/android/util.py new file mode 100644 index 0000000..37b5e32 --- /dev/null +++ b/android_pyapi/android/util.py @@ -0,0 +1,1055 @@ +""" +Android Util 组件 — Log, SparseArray, LruCache, DisplayMetrics 等 +方法签名完全对齐 Android SDK +""" + +import math +import re as _re +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) -> int: + if Log._min_log_level <= Log.WARN: + sys.stderr.write(f"W/{tag}: {msg}\n") + return 0 + + @staticmethod + def e(tag: str, msg: str) -> int: + if Log._min_log_level <= Log.ERROR: + sys.stderr.write(f"E/{tag}: {msg}\n") + return 0 + + @staticmethod + def wtf(tag: str, msg: str) -> int: + 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 + return "".join(traceback.format_exception(type(tr), tr, tr.__traceback__)) + + @staticmethod + def setMinLogLevel(level: int): + Log._min_log_level = level + + @staticmethod + def wtf(tag: str, tr: Exception) -> int: + sys.stderr.write(f"WTF/{tag}: {Log.getStackTraceString(tr)}\n") + return 0 + + +# ═══════════════════════════════════════════════════════════════ +# 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 + + 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 + + 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: + unit = data & 0xF + value = (data >> 4) & 0xFFFFFF + # Sign-extend + if value & 0x800000: + value = value - 0x1000000 + return TypedValue.applyDimension(unit, float(value), metrics) + + @staticmethod + def complexToFloat(data: int) -> float: + value = (data & 0xFFFFFF00) >> 8 + exp = (data & 0xFF) - 150 + return float(value) * (10.0 ** exp) + + @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: + return float(self.data) + + 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", +] \ No newline at end of file diff --git a/android_pyapi/android/view.py b/android_pyapi/android/view.py new file mode 100644 index 0000000..42df7fd --- /dev/null +++ b/android_pyapi/android/view.py @@ -0,0 +1,3801 @@ +""" +Android View 组件 — View, ViewGroup, MotionEvent, KeyEvent, GestureDetector 等 +方法签名完全对齐 Android SDK +""" + +import math +import time +import weakref +from typing import Any, Callable, Dict, List, Optional, Tuple, Union + +from .._core import Stub, AndroidOnlyError, android_context, HAS_PYAUTOGUI + + +# ═══════════════════════════════════════════════════════════════ +# Gravity +# ═══════════════════════════════════════════════════════════════ + +class Gravity: + """Gravity — 布局重力常量""" + NO_GRAVITY = 0x0000 + TOP = 0x0030 + BOTTOM = 0x0050 + LEFT = 0x0003 + RIGHT = 0x0005 + CENTER = 0x0011 + CENTER_HORIZONTAL = 0x0001 + CENTER_VERTICAL = 0x0010 + FILL = 0x0077 + FILL_HORIZONTAL = 0x0007 + FILL_VERTICAL = 0x0070 + CLIP_HORIZONTAL = 0x0008 + CLIP_VERTICAL = 0x0080 + START = 0x00800001 + END = 0x00800005 + RELATIVE_LAYOUT_DIRECTION = 0x00800000 + + @staticmethod + def getAbsoluteGravity(gravity: int, layout_direction: int) -> int: + from ..os import View + if layout_direction == View.LAYOUT_DIRECTION_RTL: + if gravity & Gravity.START: + gravity = (gravity & ~Gravity.START) | Gravity.RIGHT + if gravity & Gravity.END: + gravity = (gravity & ~Gravity.END) | Gravity.LEFT + else: + if gravity & Gravity.START: + gravity = (gravity & ~Gravity.START) | Gravity.LEFT + if gravity & Gravity.END: + gravity = (gravity & ~Gravity.END) | Gravity.RIGHT + return gravity + + @staticmethod + def apply(gravity: int, w: int, h: int, container: "Rect") -> int: + return 0 + + +Rect = None + + +def _set_rect_class(): + global Rect + if Rect is None: + class _Rect: + def __init__(self, l=0, t=0, r=0, b=0): + self.left = l + self.top = t + self.right = r + self.bottom = b + def width(self): return self.right - self.left + def height(self): return self.bottom - self.top + def set(self, l, t, r, b): + self.left, self.top, self.right, self.bottom = l, t, r, b + def isEmpty(self): return self.width() <= 0 or self.height() <= 0 + def toString(self): return f"Rect({self.left}, {self.top} - {self.right}, {self.bottom})" + Rect = _Rect + + +_set_rect_class() + + +# ═══════════════════════════════════════════════════════════════ +# View +# ═══════════════════════════════════════════════════════════════ + +class View(Stub): + """View — 所有 UI 组件的基类""" + + # 可见性常量 + VISIBLE = 0 + INVISIBLE = 4 + GONE = 8 + + # 测量常量 + MEASURED_SIZE_STATE_MASK = 0xFF000000 + MEASURED_STATE_MASK = 0xFF000000 + MEASURED_HEIGHT_STATE_SHIFT = 16 + MEASURED_WIDTH_STATE_SHIFT = 0 + + # 测量模式 + EXACTLY = 0x40000000 + AT_MOST = 0x80000000 # -2147483648 + UNSPECIFIED = 0 + + # 滚动轴 + SCROLL_AXIS_NONE = 0 + SCROLL_AXIS_HORIZONTAL = 1 + SCROLL_AXIS_VERTICAL = 2 + + # 布局方向 + LAYOUT_DIRECTION_LTR = 0 + LAYOUT_DIRECTION_RTL = 1 + + # 绘制缓存 + DRAWING_CACHE_QUALITY_LOW = 0x00040000 + DRAWING_CACHE_QUALITY_HIGH = 0x00080000 + DRAWING_CACHE_QUALITY_AUTO = 0 + + # 焦点方向 + FOCUS_BACKWARD = 0x00000001 + FOCUS_FORWARD = 0x00000002 + FOCUS_LEFT = 0x00000011 + FOCUS_UP = 0x00000021 + FOCUS_RIGHT = 0x00000042 + FOCUS_DOWN = 0x00000082 + + # Keep screen on + KEEP_SCREEN_ON = 0x02000000 + + # 状态 + STATUS_BAR_HIDDEN = 0x00000001 + STATUS_BAR_VISIBLE = 0x00000000 + NAVIGATION_BAR_HIDDEN = 0x00000002 + NAVIGATION_BAR_VISIBLE = 0x00000000 + + # 系统UI可见性 + SYSTEM_UI_FLAG_VISIBLE = 0 + SYSTEM_UI_FLAG_LOW_PROFILE = 0x00000001 + SYSTEM_UI_FLAG_HIDE_NAVIGATION = 0x00000002 + SYSTEM_UI_FLAG_FULLSCREEN = 0x00000004 + SYSTEM_UI_FLAG_LAYOUT_STABLE = 0x00000100 + SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION = 0x00000200 + SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN = 0x00000400 + SYSTEM_UI_FLAG_IMMERSIVE = 0x00000800 + SYSTEM_UI_FLAG_IMMERSIVE_STICKY = 0x00001000 + + _next_id = 0x10000000 + _id_lock = None + + def __init__(self, context=None): + super().__init__() + if context is None: + context = android_context + self._context = context + self._id = View.NO_ID + self._tag: Any = None + self._layout_params: Optional["ViewGroup.LayoutParams"] = None + self._visibility = View.VISIBLE + self._enabled = True + self._clickable = False + self._focusable = False + self._selected = False + self._activated = False + self._x: float = 0.0 + self._y: float = 0.0 + self._translation_x: float = 0.0 + self._translation_y: float = 0.0 + self._rotation: float = 0.0 + self._scale_x: float = 1.0 + self._scale_y: float = 1.0 + self._alpha: float = 1.0 + self._pivot_x: float = 0.0 + self._pivot_y: float = 0.0 + self._measured_width: int = 0 + self._measured_height: int = 0 + self._left: int = 0 + self._top: int = 0 + self._right: int = 0 + self._bottom: int = 0 + self._padding_left: int = 0 + self._padding_top: int = 0 + self._padding_right: int = 0 + self._padding_bottom: int = 0 + self._parent: Optional["ViewGroup"] = None + self._background_color: Optional[int] = None + self._background_drawable: Any = None + self._background_resource: int = 0 + self._on_click_listener: Optional[Callable] = None + self._on_long_click_listener: Optional[Callable] = None + self._on_touch_listener: Optional[Callable] = None + self._on_key_listener: Optional[Callable] = None + self._callbacks: Dict[Any, Tuple[Callable, float]] = {} + self._scroll_x: int = 0 + self._scroll_y: int = 0 + self._will_not_draw = False + self._layer_type = View.LAYER_TYPE_NONE + self._layout_direction = View.LAYOUT_DIRECTION_LTR + self._min_width: int = 0 + self._min_height: int = 0 + self._elevation: float = 0.0 + self._clickable = False + self._long_clickable = False + self._context_clickable = False + self._children: List["View"] = [] + + # ─── 常量 ────────────────────────────────────────────────── + + NO_ID = -1 + DRAWING_CACHE_QUALITY_LOW = 0x00040000 + DRAWING_CACHE_QUALITY_HIGH = 0x00080000 + DRAWING_CACHE_QUALITY_AUTO = 0 + LAYER_TYPE_NONE = 0 + LAYER_TYPE_SOFTWARE = 1 + LAYER_TYPE_HARDWARE = 2 + FADING_EDGE_NONE = 0 + FADING_EDGE_HORIZONTAL = 0x00001000 + FADING_EDGE_VERTICAL = 0x00002000 + OVER_SCROLL_ALWAYS = 0 + OVER_SCROLL_IF_CONTENT_SCROLLS = 1 + OVER_SCROLL_NEVER = 2 + + # ─── id / tag ────────────────────────────────────────────── + + def setId(self, id_: int): + self._id = id_ + + def getId(self) -> int: + return self._id + + def setTag(self, tag: Any): + self._tag = tag + + def getTag(self) -> Any: + return self._tag + + # ─── layout params ───────────────────────────────────────── + + def setLayoutParams(self, params: "ViewGroup.LayoutParams"): + self._layout_params = params + + def getLayoutParams(self) -> Optional["ViewGroup.LayoutParams"]: + return self._layout_params + + # ─── visibility ──────────────────────────────────────────── + + def setVisibility(self, visibility: int): + self._visibility = visibility + + def getVisibility(self) -> int: + return self._visibility + + def isShown(self) -> bool: + return self._visibility == View.VISIBLE + + # ─── position / size ─────────────────────────────────────── + + def getX(self) -> float: + return self._x + + def setX(self, x: float): + self._x = x + + def getY(self) -> float: + return self._y + + def setY(self, y: float): + self._y = y + + def getWidth(self) -> int: + return self._right - self._left + + def getHeight(self) -> int: + return self._bottom - self._top + + def getLeft(self) -> int: + return self._left + + def getTop(self) -> int: + return self._top + + def getRight(self) -> int: + return self._right + + def getBottom(self) -> int: + return self._bottom + + def getMeasuredWidth(self) -> int: + return self._measured_width + + def getMeasuredHeight(self) -> int: + return self._measured_height + + def setFrame(self, left: int, top: int, right: int, bottom: int) -> bool: + changed = (left != self._left or top != self._top or + right != self._right or bottom != self._bottom) + self._left, self._top, self._right, self._bottom = left, top, right, bottom + return changed + + def layout(self, l: int, t: int, r: int, b: int): + old_l, old_t, old_r, old_b = self._left, self._top, self._right, self._bottom + changed = self.setFrame(l, t, r, b) + if changed: + self.onLayout(changed, l - old_l, t - old_t, r - old_r, b - old_b) + + def onLayout(self, changed: bool, left: int, top: int, right: int, bottom: int): + pass + + def measure(self, width_measure_spec: int, height_measure_spec: int): + self.onMeasure(width_measure_spec, height_measure_spec) + + def onMeasure(self, width_measure_spec: int, height_measure_spec: int): + w = View.getDefaultSize(self.getSuggestedMinimumWidth(), width_measure_spec) + h = View.getDefaultSize(self.getSuggestedMinimumHeight(), height_measure_spec) + self.setMeasuredDimension(w, h) + + def setMeasuredDimension(self, measured_width: int, measured_height: int): + self._measured_width = measured_width + self._measured_height = measured_height + + def getSuggestedMinimumWidth(self) -> int: + return self._min_width + + def getSuggestedMinimumHeight(self) -> int: + return self._min_height + + def getMinimumWidth(self) -> int: + return self._min_width + + def getMinimumHeight(self) -> int: + return self._min_height + + def setMinimumWidth(self, min_w: int): + self._min_width = min_w + + def setMinimumHeight(self, min_h: int): + self._min_height = min_h + + def draw(self, canvas: Any): + self.onDraw(canvas) + + def onDraw(self, canvas: Any): + pass + + # ─── listeners ───────────────────────────────────────────── + + def setOnClickListener(self, listener: Optional[Callable]): + self._on_click_listener = listener + + def setOnLongClickListener(self, listener: Optional[Callable]) -> None: + self._on_long_click_listener = listener + + def setOnTouchListener(self, listener: Optional[Callable]) -> None: + self._on_touch_listener = listener + + def setOnKeyListener(self, listener: Optional[Callable]) -> None: + self._on_key_listener = listener + + def callOnClick(self) -> bool: + if self._on_click_listener: + self._on_click_listener(self) + return True + return False + + def performClick(self) -> bool: + return self.callOnClick() + + def performLongClick(self) -> bool: + if self._on_long_click_listener: + self._on_long_click_listener(self) + return True + return False + + # ─── post / delayed ──────────────────────────────────────── + + def post(self, action: Callable) -> bool: + action() + return True + + def postDelayed(self, action: Callable, delay_millis: int) -> bool: + import threading + timer = threading.Timer(delay_millis / 1000.0, action) + timer.daemon = True + timer.start() + self._callbacks[action] = (action, time.time() + delay_millis / 1000.0) + return True + + def removeCallbacks(self, action: Optional[Callable] = None): + if action is None: + self._callbacks.clear() + else: + self._callbacks.pop(action, None) + + # ─── invalidate / requestLayout ──────────────────────────── + + def invalidate(self): + pass + + def requestLayout(self): + pass + + def requestFocus(self, direction: int = FOCUS_FORWARD) -> bool: + if self._visibility != View.VISIBLE or not self._enabled: + return False + return True + + # ─── padding ─────────────────────────────────────────────── + + def setPadding(self, left: int, top: int, right: int, bottom: int): + self._padding_left = left + self._padding_top = top + self._padding_right = right + self._padding_bottom = bottom + + def getPaddingLeft(self) -> int: + return self._padding_left + + def getPaddingTop(self) -> int: + return self._padding_top + + def getPaddingRight(self) -> int: + return self._padding_right + + def getPaddingBottom(self) -> int: + return self._padding_bottom + + def getPaddingStart(self) -> int: + return self._padding_left + + def getPaddingEnd(self) -> int: + return self._padding_right + + # ─── background ──────────────────────────────────────────── + + def setBackgroundColor(self, color: int): + self._background_color = color + self._background_drawable = None + + def setBackground(self, background: Any): + self._background_drawable = background + + def setBackgroundDrawable(self, background: Any): + self._background_drawable = background + + def setBackgroundResource(self, resid: int): + self._background_resource = resid + + def getBackground(self) -> Any: + return self._background_drawable + + # ─── transform properties ────────────────────────────────── + + def setAlpha(self, alpha: float): + self._alpha = alpha + + def getAlpha(self) -> float: + return self._alpha + + def setRotation(self, rotation: float): + self._rotation = rotation + + def getRotation(self) -> float: + return self._rotation + + def setScaleX(self, scale_x: float): + self._scale_x = scale_x + + def getScaleX(self) -> float: + return self._scale_x + + def setScaleY(self, scale_y: float): + self._scale_y = scale_y + + def getScaleY(self) -> float: + return self._scale_y + + def setTranslationX(self, translation_x: float): + self._translation_x = translation_x + + def getTranslationX(self) -> float: + return self._translation_x + + def setTranslationY(self, translation_y: float): + self._translation_y = translation_y + + def getTranslationY(self) -> float: + return self._translation_y + + def getPivotX(self) -> float: + return self._pivot_x + + def setPivotX(self, pivot_x: float): + self._pivot_x = pivot_x + + def getPivotY(self) -> float: + return self._pivot_y + + def setPivotY(self, pivot_y: float): + self._pivot_y = pivot_y + + def setElevation(self, elevation: float): + self._elevation = elevation + + def getElevation(self) -> float: + return self._elevation + + def animate(self) -> "ViewPropertyAnimator": + return ViewPropertyAnimator(self) + + # ─── parent / root ───────────────────────────────────────── + + def getParent(self) -> Optional["ViewParent"]: + return self._parent + + def getRootView(self) -> "View": + v = self + while v._parent is not None: + v = v._parent + return v + + # ─── hierarchy ───────────────────────────────────────────── + + def findViewById(self, id_: int) -> Optional["View"]: + if self._id == id_: + return self + if hasattr(self, "_children"): + for child in self._children: + result = child.findViewById(id_) + if result is not None: + return result + return None + + def bringToFront(self): + if self._parent is not None: + self._parent.bringChildToFront(self) + + # ─── enable / focusable / clickable ──────────────────────── + + def setEnabled(self, enabled: bool): + self._enabled = enabled + + def isEnabled(self) -> bool: + return self._enabled + + def setFocusable(self, focusable: bool): + self._focusable = focusable + + def isFocusable(self) -> bool: + return self._focusable + + def setClickable(self, clickable: bool): + self._clickable = clickable + + def isClickable(self) -> bool: + return self._clickable + + def setLongClickable(self, long_clickable: bool): + self._long_clickable = long_clickable + + def isLongClickable(self) -> bool: + return self._long_clickable + + def setContextClickable(self, context_clickable: bool): + self._context_clickable = context_clickable + + def isContextClickable(self) -> bool: + return self._context_clickable + + def setSelected(self, selected: bool): + self._selected = selected + + def isSelected(self) -> bool: + return self._selected + + def setActivated(self, activated: bool): + self._activated = activated + + def isActivated(self) -> bool: + return self._activated + + # ─── context / resources ─────────────────────────────────── + + def getContext(self): + return self._context + + def getResources(self): + if hasattr(self._context, "getResources"): + return self._context.getResources() + return None + + # ─── scroll ──────────────────────────────────────────────── + + def setScrollX(self, value: int): + self._scroll_x = value + + def setScrollY(self, value: int): + self._scroll_y = value + + def getScrollX(self) -> int: + return self._scroll_x + + def getScrollY(self) -> int: + return self._scroll_y + + def scrollTo(self, x: int, y: int): + self._scroll_x = x + self._scroll_y = y + + def scrollBy(self, x: int, y: int): + self._scroll_x += x + self._scroll_y += y + + def computeScroll(self): + pass + + # ─── drawing / layer ─────────────────────────────────────── + + def setWillNotDraw(self, will_not_draw: bool): + self._will_not_draw = will_not_draw + + def willNotDraw(self) -> bool: + return self._will_not_draw + + def setLayerType(self, layer_type: int, paint: Any = None): + self._layer_type = layer_type + + def getLayerType(self) -> int: + return self._layer_type + + def buildLayer(self): + pass + + def setDrawingCacheQuality(self, quality: int): + pass + + def getDrawingCacheQuality(self) -> int: + return View.DRAWING_CACHE_QUALITY_AUTO + + def getDrawingCache(self, auto_scale: bool = True) -> Any: + return None + + def buildDrawingCache(self, auto_scale: bool = True): + pass + + def destroyDrawingCache(self): + pass + + # ─── layout direction ────────────────────────────────────── + + def setLayoutDirection(self, layout_direction: int): + self._layout_direction = layout_direction + + def getLayoutDirection(self) -> int: + return self._layout_direction + + def setTextDirection(self, text_direction: int): + pass + + def getTextDirection(self) -> int: + return 0 + + def setTextAlignment(self, text_alignment: int): + pass + + def getTextAlignment(self) -> int: + return 0 + + # ─── hit / focus ─────────────────────────────────────────── + + def onTouchEvent(self, event: "MotionEvent") -> bool: + return self._clickable or self._long_clickable + + def onTrackballEvent(self, event: "MotionEvent") -> bool: + return False + + def onKeyDown(self, key_code: int, event: "KeyEvent") -> bool: + return False + + def onKeyUp(self, key_code: int, event: "KeyEvent") -> bool: + return False + + def onKeyLongPress(self, key_code: int, event: "KeyEvent") -> bool: + return False + + def onKeyMultiple(self, key_code: int, repeat_count: int, event: "KeyEvent") -> bool: + return False + + def dispatchTouchEvent(self, event: "MotionEvent") -> bool: + if self._on_touch_listener is not None: + handled = self._on_touch_listener(self, event) + if handled: + return True + return self.onTouchEvent(event) + + def dispatchKeyEvent(self, event: "KeyEvent") -> bool: + if self._on_key_listener is not None: + handled = self._on_key_listener(self, event.getKeyCode(), event) + if handled: + return True + if event.getAction() == KeyEvent.ACTION_DOWN: + return self.onKeyDown(event.getKeyCode(), event) + elif event.getAction() == KeyEvent.ACTION_UP: + return self.onKeyUp(event.getKeyCode(), event) + return False + + def dispatchGenericMotionEvent(self, event: "MotionEvent") -> bool: + return False + + def hasFocus(self) -> bool: + return False + + def isFocused(self) -> bool: + return self.hasFocus() + + def clearFocus(self): + pass + + def onWindowFocusChanged(self, has_window_focus: bool): + pass + + def hasWindowFocus(self) -> bool: + return True + + def getWindowToken(self) -> Any: + return None + + def getWindowVisibility(self) -> int: + return View.VISIBLE + + def getWindowAttachCount(self) -> int: + return 1 + + def onAttachedToWindow(self): + pass + + def onDetachedFromWindow(self): + pass + + def isAttachedToWindow(self) -> bool: + return self._parent is not None + + # ─── Haptic ──────────────────────────────────────────────── + + def performHapticFeedback(self, feedback_constant: int) -> bool: + return False + + HapticFeedbackConstants = None + + # ─── static helpers ──────────────────────────────────────── + + @staticmethod + def generateViewId() -> int: + View._next_id += 1 + return View._next_id + + @staticmethod + def getDefaultSize(size: int, measure_spec: int) -> int: + spec_mode = View.MeasureSpec.getMode(measure_spec) + spec_size = View.MeasureSpec.getSize(measure_spec) + if spec_mode == View.UNSPECIFIED: + return size + else: + return spec_size + + @staticmethod + def combineMeasuredStates(cur_state: int, new_state: int) -> int: + return cur_state | new_state + + @staticmethod + def resolveSize(size: int, measure_spec: int) -> int: + return View.getDefaultSize(size, measure_spec) + + @staticmethod + def resolveSizeAndState(size: int, measure_spec: int, child_measured_state: int) -> int: + result = View.resolveSize(size, measure_spec) + return result | (child_measured_state & View.MEASURED_STATE_MASK) + + @staticmethod + def inflate(context, resource, root): + return View(context) + + +class MeasureSpec: + """MeasureSpec — 测量规格包装""" + EXACTLY = View.EXACTLY + AT_MOST = 0x80000000 # -2147483648 + UNSPECIFIED = 0 + MODE_SHIFT = 30 + MODE_MASK = 0xC0000000 + + @staticmethod + def makeMeasureSpec(size: int, mode: int) -> int: + return (size & ~MeasureSpec.MODE_MASK) | (mode & MeasureSpec.MODE_MASK) + + @staticmethod + def getMode(measure_spec: int) -> int: + return measure_spec & MeasureSpec.MODE_MASK + + @staticmethod + def getSize(measure_spec: int) -> int: + return measure_spec & ~MeasureSpec.MODE_MASK + + @staticmethod + def toString(measure_spec: int) -> str: + mode = MeasureSpec.getMode(measure_spec) + size = MeasureSpec.getSize(measure_spec) + mode_str = "UNSPECIFIED" + if mode == MeasureSpec.EXACTLY: + mode_str = "EXACTLY" + elif mode == MeasureSpec.AT_MOST: + mode_str = "AT_MOST" + return f"MeasureSpec: {mode_str} {size}" + + +View.MeasureSpec = MeasureSpec + + +class ViewPropertyAnimator: + """ViewPropertyAnimator — View 属性动画""" + + def __init__(self, view: View): + self._view = view + self._duration: int = 300 + self._interpolator: Any = None + + def setDuration(self, duration: int) -> "ViewPropertyAnimator": + self._duration = duration + return self + + def alpha(self, value: float) -> "ViewPropertyAnimator": + self._view.setAlpha(value) + return self + + def translationX(self, value: float) -> "ViewPropertyAnimator": + self._view.setTranslationX(value) + return self + + def translationY(self, value: float) -> "ViewPropertyAnimator": + self._view.setTranslationY(value) + return self + + def rotation(self, value: float) -> "ViewPropertyAnimator": + self._view.setRotation(value) + return self + + def scaleX(self, value: float) -> "ViewPropertyAnimator": + self._view.setScaleX(value) + return self + + def scaleY(self, value: float) -> "ViewPropertyAnimator": + self._view.setScaleY(value) + return self + + def x(self, value: float) -> "ViewPropertyAnimator": + self._view.setX(value) + return self + + def y(self, value: float) -> "ViewPropertyAnimator": + self._view.setY(value) + return self + + def start(self): + pass + + def cancel(self): + pass + + def setInterpolator(self, interpolator: Any) -> "ViewPropertyAnimator": + self._interpolator = interpolator + return self + + def withStartAction(self, runnable: Callable) -> "ViewPropertyAnimator": + return self + + def withEndAction(self, runnable: Callable) -> "ViewPropertyAnimator": + return self + + +# ═══════════════════════════════════════════════════════════════ +# ViewParent / ViewManager +# ═══════════════════════════════════════════════════════════════ + +class ViewParent(Stub): + """ViewParent — 视图父接口""" + + def requestLayout(self): + pass + + def invalidateChild(self, child: View, r: Any): + pass + + def requestChildFocus(self, child: View, focused: View): + pass + + def clearChildFocus(self, child: View): + pass + + def getParent(self) -> Optional["ViewParent"]: + return None + + def bringChildToFront(self, child: View): + pass + + def focusSearch(self, child: View, direction: int) -> Optional[View]: + return None + + def requestChildRectangleOnScreen(self, child: View, rectangle: Any, immediate: bool) -> bool: + return False + + def getChildVisibleRect(self, child: View, r: Any, offset: Any) -> bool: + return False + + def requestTransparentRegion(self, child: View): + pass + + def onStartNestedScroll(self, child: View, target: View, nested_scroll_axes: int) -> bool: + return False + + def onStopNestedScroll(self, target: View): + pass + + def onNestedScroll(self, target: View, dx_consumed: int, dy_consumed: int, + dx_unconsumed: int, dy_unconsumed: int): + pass + + def onNestedPreScroll(self, target: View, dx: int, dy: int, consumed: List[int]): + pass + + def onNestedFling(self, target: View, velocity_x: float, velocity_y: float, consumed: bool) -> bool: + return False + + def onNestedPreFling(self, target: View, velocity_x: float, velocity_y: float) -> bool: + return False + + def isNestedScrollingEnabled(self) -> bool: + return False + + def setNestedScrollingEnabled(self, enabled: bool): + pass + + def notifySubtreeAccessibilityStateChanged(self, child: View, source: View, change_type: int): + pass + + +class ViewManager(Stub): + """ViewManager — 视图管理接口""" + + def addView(self, view: View, params: "ViewGroup.LayoutParams"): + pass + + def updateViewLayout(self, view: View, params: "ViewGroup.LayoutParams"): + pass + + def removeView(self, view: View): + pass + + +# ═══════════════════════════════════════════════════════════════ +# ViewGroup +# ═══════════════════════════════════════════════════════════════ + +class ViewGroup(View, ViewParent, ViewManager): + """ViewGroup — 可包含子视图的容器""" + + CLIP_TO_PADDING_MASK = 0x00000001 + CLIP_CHILDREN_MASK = 0x00000002 + FLAG_CLIP_CHILDREN = 0x00000001 + FLAG_CLIP_TO_PADDING = 0x00000002 + FLAG_USE_CHILD_DRAWING_ORDER = 0x00000400 + + def __init__(self, context=None): + super().__init__(context) + self._children: List[View] = [] + self._clip_children = True + self._clip_to_padding = True + self._layout_mode = 0 + self._child_drawing_order_reversed = False + self._persistent_drawing_cache = False + self._always_drawn_with_cache = True + self._animate_on_set_layout = True + self._add_stateset = True + self._layout_animations = False + + # ─── child management ────────────────────────────────────── + + def addView(self, child: View, index: int = -1, + params: Optional["ViewGroup.LayoutParams"] = None): + if params is None: + params = ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, + ViewGroup.LayoutParams.WRAP_CONTENT) + if index < 0 or index >= len(self._children): + self._children.append(child) + else: + self._children.insert(index, child) + child._parent = self + child.setLayoutParams(params) + child.onAttachedToWindow() + + def addView(self, child: View, params: Optional["ViewGroup.LayoutParams"] = None): + self.addView(child, -1, params) + + def removeView(self, view: View): + if view in self._children: + self._children.remove(view) + view._parent = None + view.onDetachedFromWindow() + + def removeViewAt(self, index: int): + if 0 <= index < len(self._children): + self.removeView(self._children[index]) + + def removeAllViews(self): + for child in list(self._children): + child._parent = None + child.onDetachedFromWindow() + self._children.clear() + + def getChildCount(self) -> int: + return len(self._children) + + def getChildAt(self, index: int) -> Optional[View]: + if 0 <= index < len(self._children): + return self._children[index] + return None + + def indexOfChild(self, child: View) -> int: + try: + return self._children.index(child) + except ValueError: + return -1 + + def bringChildToFront(self, child: View): + if child in self._children: + self._children.remove(child) + self._children.append(child) + + def requestChildFocus(self, child: View, focused: View): + pass + + def onInterceptTouchEvent(self, event: "MotionEvent") -> bool: + return False + + def onInterceptHoverEvent(self, event: "MotionEvent") -> bool: + return False + + def addChildrenForAccessibility(self, children: List[View]): + for child in self._children: + children.append(child) + + def setClipChildren(self, clip_children: bool): + self._clip_children = clip_children + + def getClipChildren(self) -> bool: + return self._clip_children + + def setClipToPadding(self, clip_to_padding: bool): + self._clip_to_padding = clip_to_padding + + def getClipToPadding(self) -> bool: + return self._clip_to_padding + + def setLayoutAnimation(self, layout_animation: Any): + pass + + def getLayoutAnimation(self) -> Any: + return None + + def setLayoutMode(self, layout_mode: int): + self._layout_mode = layout_mode + + def getLayoutMode(self) -> int: + return self._layout_mode + + def setPersistentDrawingCache(self, drawing_cache_to_keep: int): + self._persistent_drawing_cache = bool(drawing_cache_to_keep) + + def setAddStatesFromChildren(self, add_states: bool): + self._add_stateset = add_states + + def addStatesFromChildren(self) -> bool: + return self._add_stateset + + def setChildDrawingOrderCallback(self, callback: Any): + pass + + def setChildrenDrawingOrderEnabled(self, enabled: bool): + self._child_drawing_order_reversed = enabled + + def isChildrenDrawingOrderEnabled(self) -> bool: + return self._child_drawing_order_reversed + + def setChildrenDrawnWithCacheEnabled(self, enabled: bool): + self._always_drawn_with_cache = enabled + + def isChildrenDrawnWithCacheEnabled(self) -> bool: + return self._always_drawn_with_cache + + def setMotionEventSplittingEnabled(self, split: bool): + pass + + def isMotionEventSplittingEnabled(self) -> bool: + return True + + def setTransitionGroup(self, is_transition_group: bool): + pass + + def isTransitionGroup(self) -> bool: + return False + + def startLayoutAnimation(self): + pass + + def scheduleLayoutAnimation(self): + pass + + def gatherTransparentRegion(self, region: Any) -> bool: + return False + + def requestTransparentRegion(self, child: View): + pass + + def onChildVisibilityChanged(self, child: View, old_visibility: int, new_visibility: int): + pass + + def focusSearch(self, focused: View, direction: int) -> Optional[View]: + return None + + def focusableViewAvailable(self, v: View): + pass + + def showContextMenuForChild(self, original_view: View) -> bool: + return False + + def createContextMenu(self, menu: Any): + pass + + def showContextMenu(self) -> bool: + return False + + def startActionModeForChild(self, original_view: View, action_mode: Any) -> Optional[Any]: + return None + + # ─── LayoutParams ────────────────────────────────────────── + + class LayoutParams: + """ViewGroup.LayoutParams — 布局参数""" + + MATCH_PARENT = -1 + WRAP_CONTENT = -2 + + def __init__(self, width: int = WRAP_CONTENT, height: int = WRAP_CONTENT): + self.width = width + self.height = height + + @staticmethod + def getSize(size: int) -> int: + return size + + # ─── MarginLayoutParams ──────────────────────────────────── + + class MarginLayoutParams(LayoutParams): + """ViewGroup.MarginLayoutParams — 带边距的布局参数""" + + def __init__(self, width: int = -2, height: int = -2): + super().__init__(width, height) + self.leftMargin = 0 + self.topMargin = 0 + self.rightMargin = 0 + self.bottomMargin = 0 + self.startMargin = 0 + self.endMargin = 0 + + def setMargins(self, left: int, top: int, right: int, bottom: int): + self.leftMargin = left + self.topMargin = top + self.rightMargin = right + self.bottomMargin = bottom + + def getMarginLeft(self) -> int: + return self.leftMargin + + def getMarginTop(self) -> int: + return self.topMargin + + def getMarginRight(self) -> int: + return self.rightMargin + + def getMarginBottom(self) -> int: + return self.bottomMargin + + def getMarginStart(self) -> int: + return self.startMargin if self.startMargin != 0 else self.leftMargin + + def getMarginEnd(self) -> int: + return self.endMargin if self.endMargin != 0 else self.rightMargin + + def setMarginStart(self, start: int): + self.startMargin = start + + def setMarginEnd(self, end: int): + self.endMargin = end + + +# ═══════════════════════════════════════════════════════════════ +# WindowManager +# ═══════════════════════════════════════════════════════════════ + +class WindowManager(ViewManager): + """WindowManager — 窗口管理器""" + + class LayoutParams(ViewGroup.LayoutParams): + """WindowManager.LayoutParams — 窗口布局参数""" + + # 窗口类型 + TYPE_FIRST_APPLICATION = 1 + TYPE_APPLICATION = 2 + TYPE_APPLICATION_STARTING = 3 + TYPE_APPLICATION_PANEL = 1000 + TYPE_APPLICATION_MEDIA = 1001 + TYPE_APPLICATION_SUB_PANEL = 1002 + TYPE_APPLICATION_ATTACHED_DIALOG = 1003 + TYPE_APPLICATION_OVERLAY = 1004 + + # 标志位 + FLAG_ALLOW_LOCK_WHILE_SCREEN_ON = 0x00000001 + FLAG_DIM_BEHIND = 0x00000002 + FLAG_BLUR_BEHIND = 0x00000004 + FLAG_NOT_FOCUSABLE = 0x00000008 + FLAG_NOT_TOUCHABLE = 0x00000010 + FLAG_NOT_TOUCH_MODAL = 0x00000020 + FLAG_TOUCHABLE_WHEN_WAKING = 0x00000040 + FLAG_KEEP_SCREEN_ON = 0x00000080 + FLAG_LAYOUT_IN_SCREEN = 0x00000100 + FLAG_LAYOUT_NO_LIMITS = 0x00000200 + FLAG_FULLSCREEN = 0x00000400 + FLAG_FORCE_NOT_FULLSCREEN = 0x00000800 + FLAG_DITHER = 0x00001000 + FLAG_SECURE = 0x00002000 + FLAG_SCALED = 0x00004000 + FLAG_IGNORE_CHEEK_PRESSES = 0x00008000 + FLAG_LAYOUT_INSET_DECOR = 0x00010000 + FLAG_ALT_FOCUSABLE_IM = 0x00020000 + FLAG_WATCH_OUTSIDE_TOUCH = 0x00040000 + FLAG_SHOW_WHEN_LOCKED = 0x00080000 + FLAG_SHOW_WALLPAPER = 0x00100000 + FLAG_TURN_SCREEN_ON = 0x00200000 + FLAG_DISMISS_KEYGUARD = 0x00400000 + FLAG_SPLIT_TOUCH = 0x00800000 + FLAG_HARDWARE_ACCELERATED = 0x01000000 + FLAG_LOCAL_FOCUS_MODE = 0x02000000 + FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS = 0x04000000 + FLAG_TRANSLUCENT_STATUS = 0x04000000 + FLAG_TRANSLUCENT_NAVIGATION = 0x08000000 + + # 软输入模式 + SOFT_INPUT_STATE_UNSPECIFIED = 0 + SOFT_INPUT_STATE_UNCHANGED = 1 + SOFT_INPUT_STATE_HIDDEN = 2 + SOFT_INPUT_STATE_ALWAYS_HIDDEN = 3 + SOFT_INPUT_STATE_VISIBLE = 4 + SOFT_INPUT_STATE_ALWAYS_VISIBLE = 5 + SOFT_INPUT_ADJUST_UNSPECIFIED = 0x00 + SOFT_INPUT_ADJUST_RESIZE = 0x10 + SOFT_INPUT_ADJUST_PAN = 0x20 + SOFT_INPUT_ADJUST_NOTHING = 0x30 + SOFT_INPUT_IS_FORWARD_NAVIGATION = 0x100 + + # 屏幕方向 + SCREEN_ORIENTATION_UNSPECIFIED = -1 + SCREEN_ORIENTATION_LANDSCAPE = 0 + SCREEN_ORIENTATION_PORTRAIT = 1 + SCREEN_ORIENTATION_USER = 2 + SCREEN_ORIENTATION_BEHIND = 3 + SCREEN_ORIENTATION_SENSOR = 4 + SCREEN_ORIENTATION_NOSENSOR = 5 + SCREEN_ORIENTATION_SENSOR_LANDSCAPE = 6 + SCREEN_ORIENTATION_SENSOR_PORTRAIT = 7 + SCREEN_ORIENTATION_REVERSE_LANDSCAPE = 8 + SCREEN_ORIENTATION_REVERSE_PORTRAIT = 9 + SCREEN_ORIENTATION_FULL_SENSOR = 10 + SCREEN_ORIENTATION_USER_LANDSCAPE = 11 + SCREEN_ORIENTATION_USER_PORTRAIT = 12 + SCREEN_ORIENTATION_FULL_USER = 13 + SCREEN_ORIENTATION_LOCKED = 14 + + # 重力 + gravity = Gravity.NO_GRAVITY + x = 0 + y = 0 + horizontalMargin = 0.0 + verticalMargin = 0.0 + + def __init__(self, w: int = ViewGroup.LayoutParams.WRAP_CONTENT, + h: int = ViewGroup.LayoutParams.WRAP_CONTENT): + super().__init__(w, h) + self.type = WindowManager.LayoutParams.TYPE_APPLICATION + self.flags = 0 + self.softInputMode = WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED + self.screenOrientation = WindowManager.LayoutParams.SCREEN_ORIENTATION_UNSPECIFIED + self.gravity = Gravity.NO_GRAVITY + self.x = 0 + self.y = 0 + self.token: Any = None + self.windowAnimations: int = 0 + self.packageName: str = "" + self.screenBrightness = -1.0 + self.buttonBrightness = -1.0 + self.rotationAnimation = 0 + self.preferredDisplayModeId = 0 + self.colorMode = 0 + self.format = -1 + + def __init__(self): + super().__init__() + self._views: Dict[View, WindowManager.LayoutParams] = {} + + def addView(self, view: View, params: LayoutParams): + self._views[view] = params + + def updateViewLayout(self, view: View, params: LayoutParams): + if view in self._views: + self._views[view] = params + + def removeView(self, view: View): + self._views.pop(view, None) + + def removeViewImmediate(self, view: View): + self._views.pop(view, None) + + def getDefaultDisplay(self) -> "Display": + return Display() + + +# ═══════════════════════════════════════════════════════════════ +# MotionEvent +# ═══════════════════════════════════════════════════════════════ + +class MotionEvent(Stub): + """MotionEvent — 触摸事件""" + + # 动作常量 + ACTION_DOWN = 0 + ACTION_UP = 1 + ACTION_MOVE = 2 + ACTION_CANCEL = 3 + ACTION_OUTSIDE = 4 + ACTION_POINTER_DOWN = 5 + ACTION_POINTER_UP = 6 + ACTION_HOVER_MOVE = 7 + ACTION_HOVER_ENTER = 8 + ACTION_HOVER_EXIT = 9 + ACTION_SCROLL = 11 + ACTION_BUTTON_PRESS = 12 + ACTION_BUTTON_RELEASE = 13 + + # 动作掩码 + ACTION_MASK = 0xFF + ACTION_POINTER_INDEX_MASK = 0xFF00 + ACTION_POINTER_INDEX_SHIFT = 8 + + # 按钮 + BUTTON_PRIMARY = 1 + BUTTON_SECONDARY = 2 + BUTTON_TERTIARY = 4 + BUTTON_BACK = 8 + BUTTON_FORWARD = 16 + BUTTON_STYLUS_PRIMARY = 32 + BUTTON_STYLUS_SECONDARY = 64 + + # 边缘 + EDGE_LEFT = 1 + EDGE_TOP = 2 + EDGE_RIGHT = 4 + EDGE_BOTTOM = 8 + + # 坐标分类 + AXIS_X = 0 + AXIS_Y = 1 + AXIS_PRESSURE = 2 + AXIS_SIZE = 3 + AXIS_TOUCH_MAJOR = 4 + AXIS_TOUCH_MINOR = 5 + AXIS_TOOL_MAJOR = 6 + AXIS_TOOL_MINOR = 7 + AXIS_ORIENTATION = 8 + AXIS_VSCROLL = 9 + AXIS_HSCROLL = 10 + AXIS_Z = 11 + AXIS_RX = 12 + AXIS_RY = 13 + AXIS_RZ = 14 + AXIS_HAT_X = 15 + AXIS_HAT_Y = 16 + AXIS_LTRIGGER = 17 + AXIS_RTRIGGER = 18 + AXIS_THROTTLE = 19 + AXIS_RUDDER = 20 + AXIS_WHEEL = 21 + AXIS_GAS = 22 + AXIS_BRAKE = 23 + AXIS_DISTANCE = 24 + AXIS_TILT = 25 + AXIS_SCROLL = 26 + AXIS_RELATIVE_X = 27 + AXIS_RELATIVE_Y = 28 + AXIS_GENERIC_1 = 32 + AXIS_GENERIC_2 = 33 + AXIS_GENERIC_3 = 34 + AXIS_GENERIC_4 = 35 + AXIS_GENERIC_5 = 36 + AXIS_GENERIC_6 = 37 + AXIS_GENERIC_7 = 38 + AXIS_GENERIC_8 = 39 + AXIS_GENERIC_9 = 40 + AXIS_GENERIC_10 = 41 + AXIS_GENERIC_11 = 42 + AXIS_GENERIC_12 = 43 + AXIS_GENERIC_13 = 44 + AXIS_GENERIC_14 = 45 + AXIS_GENERIC_15 = 46 + AXIS_GENERIC_16 = 47 + + # 输入类型 + TOOL_TYPE_UNKNOWN = 0 + TOOL_TYPE_FINGER = 1 + TOOL_TYPE_STYLUS = 2 + TOOL_TYPE_MOUSE = 3 + TOOL_TYPE_ERASER = 4 + + INVALID_POINTER_ID = -1 + + def __init__(self, action: int = 0, x: float = 0.0, y: float = 0.0, + event_time: int = 0, pointer_count: int = 1, + meta_state: int = 0, button_state: int = 0): + super().__init__() + self._action = action + self._x = x + self._y = y + self._raw_x = x + self._raw_y = y + self._event_time = event_time if event_time else int(time.time() * 1000) + self._down_time = self._event_time + self._pointer_count = pointer_count + self._meta_state = meta_state + self._button_state = button_state + self._pointers: List[Dict] = [] + for i in range(pointer_count): + self._pointers.append({ + "id": i, + "x": x, + "y": y, + "pressure": 1.0, + "size": 0.5, + "tool_type": MotionEvent.TOOL_TYPE_FINGER, + }) + + @classmethod + def obtain(cls, down_time: int, event_time: int, action: int, + x: float, y: float, meta_state: int = 0) -> "MotionEvent": + return cls(action=action, x=x, y=y, event_time=event_time) + + @classmethod + def obtainNoHistory(cls, me: "MotionEvent") -> "MotionEvent": + return cls(action=me._action, x=me._x, y=me._y, + event_time=me._event_time, pointer_count=me._pointer_count) + + def recycle(self): + pass + + def getAction(self) -> int: + return self._action + + def getActionMasked(self) -> int: + return self._action & MotionEvent.ACTION_MASK + + def getActionIndex(self) -> int: + return (self._action & MotionEvent.ACTION_POINTER_INDEX_MASK) >> MotionEvent.ACTION_POINTER_INDEX_SHIFT + + def getX(self, pointer_index: int = 0) -> float: + if 0 <= pointer_index < len(self._pointers): + return self._pointers[pointer_index]["x"] + return self._x + + def getY(self, pointer_index: int = 0) -> float: + if 0 <= pointer_index < len(self._pointers): + return self._pointers[pointer_index]["y"] + return self._y + + def getRawX(self) -> float: + return self._raw_x + + def getRawY(self) -> float: + return self._raw_y + + def getPointerCount(self) -> int: + return self._pointer_count + + def getPointerId(self, pointer_index: int) -> int: + if 0 <= pointer_index < len(self._pointers): + return self._pointers[pointer_index]["id"] + return pointer_index + + def findPointerIndex(self, pointer_id: int) -> int: + for i, p in enumerate(self._pointers): + if p["id"] == pointer_id: + return i + return -1 + + def getPressure(self, pointer_index: int = 0) -> float: + if 0 <= pointer_index < len(self._pointers): + return self._pointers[pointer_index]["pressure"] + return 1.0 + + def getSize(self, pointer_index: int = 0) -> float: + if 0 <= pointer_index < len(self._pointers): + return self._pointers[pointer_index]["size"] + return 0.5 + + def getEventTime(self) -> int: + return self._event_time + + def getDownTime(self) -> int: + return self._down_time + + def getMetaState(self) -> int: + return self._meta_state + + def getButtonState(self) -> int: + return self._button_state + + def getToolType(self, pointer_index: int = 0) -> int: + if 0 <= pointer_index < len(self._pointers): + return self._pointers[pointer_index]["tool_type"] + return MotionEvent.TOOL_TYPE_FINGER + + def setLocation(self, x: float, y: float): + self._x = x + self._y = y + + def offsetLocation(self, dx: float, dy: float): + self._x += dx + self._y += dy + + def transform(self, matrix: Any): + pass + + def isLongPress(self) -> bool: + return (self._event_time - self._down_time) > 500 + + def getHistoricalSize(self, pos: int, pointer: int = 0) -> float: + return 0.5 + + +# ═══════════════════════════════════════════════════════════════ +# KeyEvent +# ═══════════════════════════════════════════════════════════════ + +class KeyEvent(Stub): + """KeyEvent — 按键事件""" + + # 动作 + ACTION_DOWN = 0 + ACTION_UP = 1 + ACTION_MULTIPLE = 2 + + # 键码 + KEYCODE_UNKNOWN = 0 + KEYCODE_SOFT_LEFT = 1 + KEYCODE_SOFT_RIGHT = 2 + KEYCODE_HOME = 3 + KEYCODE_BACK = 4 + KEYCODE_CALL = 5 + KEYCODE_ENDCALL = 6 + KEYCODE_0 = 7 + KEYCODE_1 = 8 + KEYCODE_2 = 9 + KEYCODE_3 = 10 + KEYCODE_4 = 11 + KEYCODE_5 = 12 + KEYCODE_6 = 13 + KEYCODE_7 = 14 + KEYCODE_8 = 15 + KEYCODE_9 = 16 + KEYCODE_STAR = 17 + KEYCODE_POUND = 18 + KEYCODE_DPAD_UP = 19 + KEYCODE_DPAD_DOWN = 20 + KEYCODE_DPAD_LEFT = 21 + KEYCODE_DPAD_RIGHT = 22 + KEYCODE_DPAD_CENTER = 23 + KEYCODE_VOLUME_UP = 24 + KEYCODE_VOLUME_DOWN = 25 + KEYCODE_POWER = 26 + KEYCODE_CAMERA = 27 + KEYCODE_CLEAR = 28 + KEYCODE_A = 29 + KEYCODE_B = 30 + KEYCODE_C = 31 + KEYCODE_D = 32 + KEYCODE_E = 33 + KEYCODE_F = 34 + KEYCODE_G = 35 + KEYCODE_H = 36 + KEYCODE_I = 37 + KEYCODE_J = 38 + KEYCODE_K = 39 + KEYCODE_L = 40 + KEYCODE_M = 41 + KEYCODE_N = 42 + KEYCODE_O = 43 + KEYCODE_P = 44 + KEYCODE_Q = 45 + KEYCODE_R = 46 + KEYCODE_S = 47 + KEYCODE_T = 48 + KEYCODE_U = 49 + KEYCODE_V = 50 + KEYCODE_W = 51 + KEYCODE_X = 52 + KEYCODE_Y = 53 + KEYCODE_Z = 54 + KEYCODE_COMMA = 55 + KEYCODE_PERIOD = 56 + KEYCODE_ALT_LEFT = 57 + KEYCODE_ALT_RIGHT = 58 + KEYCODE_SHIFT_LEFT = 59 + KEYCODE_SHIFT_RIGHT = 60 + KEYCODE_TAB = 61 + KEYCODE_SPACE = 62 + KEYCODE_SYM = 63 + KEYCODE_EXPLORER = 64 + KEYCODE_ENVELOPE = 65 + KEYCODE_ENTER = 66 + KEYCODE_DEL = 67 + KEYCODE_GRAVE = 68 + KEYCODE_MINUS = 69 + KEYCODE_EQUALS = 70 + KEYCODE_LEFT_BRACKET = 71 + KEYCODE_RIGHT_BRACKET = 72 + KEYCODE_BACKSLASH = 73 + KEYCODE_SEMICOLON = 74 + KEYCODE_APOSTROPHE = 75 + KEYCODE_SLASH = 76 + KEYCODE_AT = 77 + KEYCODE_NUM = 78 + KEYCODE_HEADSETHOOK = 79 + KEYCODE_FOCUS = 80 + KEYCODE_PLUS = 81 + KEYCODE_MENU = 82 + KEYCODE_NOTIFICATION = 83 + KEYCODE_SEARCH = 84 + KEYCODE_MEDIA_PLAY_PAUSE = 85 + KEYCODE_MEDIA_STOP = 86 + KEYCODE_MEDIA_NEXT = 87 + KEYCODE_MEDIA_PREVIOUS = 88 + KEYCODE_MEDIA_REWIND = 89 + KEYCODE_MEDIA_FAST_FORWARD = 90 + KEYCODE_MUTE = 91 + KEYCODE_PAGE_UP = 92 + KEYCODE_PAGE_DOWN = 93 + KEYCODE_PICTSYMBOLS = 94 + KEYCODE_SWITCH_CHARSET = 95 + KEYCODE_BUTTON_A = 96 + KEYCODE_BUTTON_B = 97 + KEYCODE_BUTTON_C = 98 + KEYCODE_BUTTON_X = 99 + KEYCODE_BUTTON_Y = 100 + KEYCODE_BUTTON_Z = 101 + KEYCODE_BUTTON_L1 = 102 + KEYCODE_BUTTON_R1 = 103 + KEYCODE_BUTTON_L2 = 104 + KEYCODE_BUTTON_R2 = 105 + KEYCODE_BUTTON_THUMBL = 106 + KEYCODE_BUTTON_THUMBR = 107 + KEYCODE_BUTTON_START = 108 + KEYCODE_BUTTON_SELECT = 109 + KEYCODE_BUTTON_MODE = 110 + KEYCODE_ESCAPE = 111 + KEYCODE_FORWARD_DEL = 112 + KEYCODE_CTRL_LEFT = 113 + KEYCODE_CTRL_RIGHT = 114 + KEYCODE_CAPS_LOCK = 115 + KEYCODE_SCROLL_LOCK = 116 + KEYCODE_META_LEFT = 117 + KEYCODE_META_RIGHT = 118 + KEYCODE_FUNCTION = 119 + KEYCODE_SYSRQ = 120 + KEYCODE_BREAK = 121 + KEYCODE_MOVE_HOME = 122 + KEYCODE_MOVE_END = 123 + KEYCODE_INSERT = 124 + KEYCODE_FORWARD = 125 + KEYCODE_MEDIA_PLAY = 126 + KEYCODE_MEDIA_PAUSE = 127 + KEYCODE_MEDIA_CLOSE = 128 + KEYCODE_MEDIA_EJECT = 129 + KEYCODE_MEDIA_RECORD = 130 + KEYCODE_F1 = 131 + KEYCODE_F2 = 132 + KEYCODE_F3 = 133 + KEYCODE_F4 = 134 + KEYCODE_F5 = 135 + KEYCODE_F6 = 136 + KEYCODE_F7 = 137 + KEYCODE_F8 = 138 + KEYCODE_F9 = 139 + KEYCODE_F10 = 140 + KEYCODE_F11 = 141 + KEYCODE_F12 = 142 + KEYCODE_NUM_LOCK = 143 + KEYCODE_NUMPAD_0 = 144 + KEYCODE_NUMPAD_1 = 145 + KEYCODE_NUMPAD_2 = 146 + KEYCODE_NUMPAD_3 = 147 + KEYCODE_NUMPAD_4 = 148 + KEYCODE_NUMPAD_5 = 149 + KEYCODE_NUMPAD_6 = 150 + KEYCODE_NUMPAD_7 = 151 + KEYCODE_NUMPAD_8 = 152 + KEYCODE_NUMPAD_9 = 153 + KEYCODE_NUMPAD_DIVIDE = 154 + KEYCODE_NUMPAD_MULTIPLY = 155 + KEYCODE_NUMPAD_SUBTRACT = 156 + KEYCODE_NUMPAD_ADD = 157 + KEYCODE_NUMPAD_DOT = 158 + KEYCODE_NUMPAD_COMMA = 159 + KEYCODE_NUMPAD_ENTER = 160 + KEYCODE_NUMPAD_EQUALS = 161 + KEYCODE_NUMPAD_LEFT_PAREN = 162 + KEYCODE_NUMPAD_RIGHT_PAREN = 163 + KEYCODE_META_CTRL_LEFT = 164 + KEYCODE_META_CTRL_RIGHT = 165 + KEYCODE_META_ALT_LEFT = 166 + KEYCODE_META_ALT_RIGHT = 167 + KEYCODE_META_SHIFT_LEFT = 168 + KEYCODE_META_SHIFT_RIGHT = 169 + KEYCODE_META_SYM = 170 + + # 元键掩码 + META_ALT_ON = 0x02 + META_ALT_LEFT_ON = 0x10 + META_ALT_RIGHT_ON = 0x20 + META_SHIFT_ON = 0x01 + META_SHIFT_LEFT_ON = 0x40 + META_SHIFT_RIGHT_ON = 0x80 + META_SYM_ON = 0x04 + META_FUNCTION_ON = 0x08 + META_CTRL_ON = 0x1000 + META_CTRL_LEFT_ON = 0x2000 + META_CTRL_RIGHT_ON = 0x4000 + META_META_ON = 0x10000 + META_META_LEFT_ON = 0x20000 + META_META_RIGHT_ON = 0x40000 + META_CAPS_LOCK_ON = 0x100000 + META_NUM_LOCK_ON = 0x200000 + META_SCROLL_LOCK_ON = 0x400000 + + def __init__(self, action: int = ACTION_DOWN, key_code: int = KEYCODE_UNKNOWN, + repeat_count: int = 0, event_time: int = 0, + meta_state: int = 0): + super().__init__() + self._action = action + self._key_code = key_code + self._repeat_count = repeat_count + self._event_time = event_time if event_time else int(time.time() * 1000) + self._down_time = self._event_time + self._meta_state = meta_state + self._device_id = 0 + self._source = 0x101 # InputDevice.SOURCE_KEYBOARD + self._flags = 0 + self._display_id = 0 + + getAction = lambda self: self._action + getKeyCode = lambda self: self._key_code + getRepeatCount = lambda self: self._repeat_count + getEventTime = lambda self: self._event_time + getDownTime = lambda self: self._down_time + getMetaState = lambda self: self._meta_state + getDeviceId = lambda self: self._device_id + getSource = lambda self: self._source + getFlags = lambda self: self._flags + getDisplayId = lambda self: self._display_id + + def isLongPress(self) -> bool: + return self._repeat_count > 0 + + def dispatch(self, receiver: View, on_receive: Callable) -> bool: + return on_receive(receiver, self) + + def isAltPressed(self) -> bool: + return bool(self._meta_state & KeyEvent.META_ALT_ON) + + def isShiftPressed(self) -> bool: + return bool(self._meta_state & KeyEvent.META_SHIFT_ON) + + def isCtrlPressed(self) -> bool: + return bool(self._meta_state & KeyEvent.META_CTRL_ON) + + def isMetaPressed(self) -> bool: + return bool(self._meta_state & KeyEvent.META_META_ON) + + def isSymPressed(self) -> bool: + return bool(self._meta_state & KeyEvent.META_SYM_ON) + + def isFunctionPressed(self) -> bool: + return bool(self._meta_state & KeyEvent.META_FUNCTION_ON) + + def isCapsLockOn(self) -> bool: + return bool(self._meta_state & KeyEvent.META_CAPS_LOCK_ON) + + def isNumLockOn(self) -> bool: + return bool(self._meta_state & KeyEvent.META_NUM_LOCK_ON) + + def isScrollLockOn(self) -> bool: + return bool(self._meta_state & KeyEvent.META_SCROLL_LOCK_ON) + + @staticmethod + def changeTimeRepeat(event: "KeyEvent", event_time: int, repeat_count: int) -> "KeyEvent": + return KeyEvent( + action=event._action, + key_code=event._key_code, + repeat_count=repeat_count, + event_time=event_time, + meta_state=event._meta_state, + ) + + @staticmethod + def changeAction(event: "KeyEvent", action: int) -> "KeyEvent": + return KeyEvent( + action=action, + key_code=event._key_code, + repeat_count=event._repeat_count, + event_time=event._event_time, + meta_state=event._meta_state, + ) + + +# ═══════════════════════════════════════════════════════════════ +# GestureDetector +# ═══════════════════════════════════════════════════════════════ + +class GestureDetector(Stub): + """GestureDetector — 手势检测器""" + + class SimpleOnGestureListener: + """SimpleOnGestureListener — 简单手势监听器""" + + def onDown(self, e: MotionEvent) -> bool: + return False + + def onShowPress(self, e: MotionEvent): + pass + + def onSingleTapUp(self, e: MotionEvent) -> bool: + return False + + def onScroll(self, e1: MotionEvent, e2: MotionEvent, + distance_x: float, distance_y: float) -> bool: + return False + + def onLongPress(self, e: MotionEvent): + pass + + def onFling(self, e1: MotionEvent, e2: MotionEvent, + velocity_x: float, velocity_y: float) -> bool: + return False + + def onSingleTapConfirmed(self, e: MotionEvent) -> bool: + return False + + def onDoubleTap(self, e: MotionEvent) -> bool: + return False + + def onDoubleTapEvent(self, e: MotionEvent) -> bool: + return False + + def onContextClick(self, e: MotionEvent) -> bool: + return False + + class OnGestureListener: + def onDown(self, e: MotionEvent) -> bool: + return False + def onShowPress(self, e: MotionEvent): + pass + def onSingleTapUp(self, e: MotionEvent) -> bool: + return False + def onScroll(self, e1: MotionEvent, e2: MotionEvent, + distance_x: float, distance_y: float) -> bool: + return False + def onLongPress(self, e: MotionEvent): + pass + def onFling(self, e1: MotionEvent, e2: MotionEvent, + velocity_x: float, velocity_y: float) -> bool: + return False + + class OnDoubleTapListener: + def onSingleTapConfirmed(self, e: MotionEvent) -> bool: + return False + def onDoubleTap(self, e: MotionEvent) -> bool: + return False + def onDoubleTapEvent(self, e: MotionEvent) -> bool: + return False + + def __init__(self, context=None, listener: Optional["GestureDetector.OnGestureListener"] = None, + handler: Any = None): + super().__init__() + self._listener = listener + self._double_tap_listener: Optional["GestureDetector.OnDoubleTapListener"] = None + self._is_longpress_enabled = True + self._context = context + self._current_down_event: Optional[MotionEvent] = None + self._previous_down_event: Optional[MotionEvent] = None + self._in_long_press = False + self._long_press_timeout = 500 + self._touch_slop = 8 + + def setOnDoubleTapListener(self, listener: Optional["GestureDetector.OnDoubleTapListener"]): + self._double_tap_listener = listener + + def setIsLongpressEnabled(self, enabled: bool): + self._is_longpress_enabled = enabled + + def isLongpressEnabled(self) -> bool: + return self._is_longpress_enabled + + def onTouchEvent(self, ev: MotionEvent) -> bool: + action = ev.getAction() + if action == MotionEvent.ACTION_DOWN: + self._in_long_press = False + self._current_down_event = ev + if self._listener: + return self._listener.onDown(ev) + elif action == MotionEvent.ACTION_MOVE: + pass + elif action == MotionEvent.ACTION_UP: + if self._listener: + return self._listener.onSingleTapUp(ev) + elif action == MotionEvent.ACTION_CANCEL: + pass + return False + + def setContextClickListener(self, listener: Callable): + pass + + def setContextClickable(self, context_clickable: bool): + pass + + def isContextClickable(self) -> bool: + return False + + +# ═══════════════════════════════════════════════════════════════ +# ScaleGestureDetector +# ═══════════════════════════════════════════════════════════════ + +class ScaleGestureDetector(Stub): + """ScaleGestureDetector — 缩放手势检测器""" + + class SimpleOnScaleGestureListener: + """SimpleOnScaleGestureListener — 简单缩放手势监听器""" + + def onScaleBegin(self, detector: "ScaleGestureDetector") -> bool: + return True + + def onScale(self, detector: "ScaleGestureDetector") -> bool: + return False + + def onScaleEnd(self, detector: "ScaleGestureDetector"): + pass + + class OnScaleGestureListener: + def onScaleBegin(self, detector: "ScaleGestureDetector") -> bool: + return True + def onScale(self, detector: "ScaleGestureDetector") -> bool: + return False + def onScaleEnd(self, detector: "ScaleGestureDetector"): + pass + + def __init__(self, context=None, listener: Optional[OnScaleGestureListener] = None): + super().__init__() + self._listener = listener + self._scale_factor = 1.0 + self._current_span = 0.0 + self._current_span_x = 0.0 + self._current_span_y = 0.0 + self._focus_x = 0.0 + self._focus_y = 0.0 + self._previous_span = 0.0 + self._time_delta = 0 + self._in_progress = False + + def getScaleFactor(self) -> float: + return self._scale_factor + + def getCurrentSpan(self) -> float: + return self._current_span + + def getCurrentSpanX(self) -> float: + return self._current_span_x + + def getCurrentSpanY(self) -> float: + return self._current_span_y + + def getPreviousSpan(self) -> float: + return self._previous_span + + def getPreviousSpanX(self) -> float: + return self._current_span_x + + def getPreviousSpanY(self) -> float: + return self._current_span_y + + def getFocusX(self) -> float: + return self._focus_x + + def getFocusY(self) -> float: + return self._focus_y + + def getTimeDelta(self) -> int: + return self._time_delta + + def getEventTime(self) -> int: + return int(time.time() * 1000) + + def isInProgress(self) -> bool: + return self._in_progress + + def onTouchEvent(self, event: MotionEvent) -> bool: + action = event.getActionMasked() + if action == MotionEvent.ACTION_DOWN: + self._in_progress = False + elif action == MotionEvent.ACTION_POINTER_DOWN: + if event.getPointerCount() >= 2: + self._in_progress = True + x1, y1 = event.getX(0), event.getY(0) + x2, y2 = event.getX(1), event.getY(1) + self._current_span = math.hypot(x2 - x1, y2 - y1) + self._focus_x = (x1 + x2) / 2.0 + self._focus_y = (y1 + y2) / 2.0 + if self._listener: + self._listener.onScaleBegin(self) + return True + elif action == MotionEvent.ACTION_MOVE: + if self._in_progress and event.getPointerCount() >= 2: + x1, y1 = event.getX(0), event.getY(0) + x2, y2 = event.getX(1), event.getY(1) + new_span = math.hypot(x2 - x1, y2 - y1) + self._previous_span = self._current_span + self._current_span = new_span + if self._previous_span > 0: + self._scale_factor = self._current_span / self._previous_span + self._focus_x = (x1 + x2) / 2.0 + self._focus_y = (y1 + y2) / 2.0 + if self._listener: + self._listener.onScale(self) + return True + elif action in (MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL): + if self._in_progress and self._listener: + self._listener.onScaleEnd(self) + self._in_progress = False + return False + + +# ═══════════════════════════════════════════════════════════════ +# VelocityTracker +# ═══════════════════════════════════════════════════════════════ + +class VelocityTracker(Stub): + """VelocityTracker — 速度追踪器""" + + def __init__(self): + super().__init__() + self._movements: List[Tuple[float, float, float]] = [] # (x, y, time) + self._x_velocity: float = 0.0 + self._y_velocity: float = 0.0 + + @staticmethod + def obtain() -> "VelocityTracker": + return VelocityTracker() + + @staticmethod + def obtainUnit(max_units: int, generator_id: int) -> "VelocityTracker": + return VelocityTracker() + + def addMovement(self, event: MotionEvent): + self._movements.append((event.getRawX(), event.getRawY(), + event.getEventTime() / 1000.0)) + if len(self._movements) > 100: + self._movements = self._movements[-50:] + + def computeCurrentVelocity(self, units: int, max_velocity: float = float("inf")): + if len(self._movements) < 2: + self._x_velocity = 0.0 + self._y_velocity = 0.0 + return + recent = self._movements[-4:] if len(self._movements) >= 4 else self._movements + first_x, first_y, first_t = recent[0] + last_x, last_y, last_t = recent[-1] + dt = last_t - first_t + if dt > 0: + unit_scale = units / 1000.0 + self._x_velocity = (last_x - first_x) / dt * unit_scale + self._y_velocity = (last_y - first_y) / dt * unit_scale + self._x_velocity = max(-max_velocity, min(max_velocity, self._x_velocity)) + self._y_velocity = max(-max_velocity, min(max_velocity, self._y_velocity)) + else: + self._x_velocity = 0.0 + self._y_velocity = 0.0 + + def getXVelocity(self, id_: int = -1) -> float: + return self._x_velocity + + def getYVelocity(self, id_: int = -1) -> float: + return self._y_velocity + + def recycle(self): + self._movements.clear() + self._x_velocity = 0.0 + self._y_velocity = 0.0 + + def clear(self): + self._movements.clear() + + def getEstimator(self) -> Any: + return None + + +# ═══════════════════════════════════════════════════════════════ +# DragEvent +# ═══════════════════════════════════════════════════════════════ + +class DragEvent(Stub): + """DragEvent — 拖放事件""" + + ACTION_DRAG_STARTED = 1 + ACTION_DRAG_LOCATION = 2 + ACTION_DROP = 3 + ACTION_DRAG_ENTERED = 4 + ACTION_DRAG_EXITED = 5 + ACTION_DRAG_ENDED = 6 + + def __init__(self, action: int = 0, x: float = 0.0, y: float = 0.0, + clip_data: Any = None, result: bool = False): + super().__init__() + self._action = action + self._x = x + self._y = y + self._clip_data = clip_data + self._result = result + self._local_state: Any = None + + def getAction(self) -> int: + return self._action + + def getX(self) -> float: + return self._x + + def getY(self) -> float: + return self._y + + def getClipData(self) -> Any: + return self._clip_data + + def getResult(self) -> bool: + return self._result + + def getLocalState(self) -> Any: + return self._local_state + + def setLocalState(self, state: Any): + self._local_state = state + + def toString(self) -> str: + action_names = { + 1: "ACTION_DRAG_STARTED", + 2: "ACTION_DRAG_LOCATION", + 3: "ACTION_DROP", + 4: "ACTION_DRAG_ENTERED", + 5: "ACTION_DRAG_EXITED", + 6: "ACTION_DRAG_ENDED", + } + name = action_names.get(self._action, f"UNKNOWN({self._action})") + return f"DragEvent(action={name}, x={self._x}, y={self._y})" + + +# ═══════════════════════════════════════════════════════════════ +# AccessibilityDelegate +# ═══════════════════════════════════════════════════════════════ + +class AccessibilityDelegate(Stub): + """AccessibilityDelegate — 辅助功能委托""" + + def sendAccessibilityEvent(self, host: View, event_type: int): + pass + + def sendAccessibilityEventUnchecked(self, host: View, event: Any): + pass + + def dispatchPopulateAccessibilityEvent(self, host: View, event: Any) -> bool: + return False + + def onPopulateAccessibilityEvent(self, host: View, event: Any): + pass + + def onInitializeAccessibilityEvent(self, host: View, event: Any): + pass + + def onInitializeAccessibilityNodeInfo(self, host: View, info: Any): + pass + + def onRequestSendAccessibilityEvent(self, host: ViewGroup, child: View, event: Any) -> bool: + return True + + def getAccessibilityNodeProvider(self, host: View) -> Optional[Any]: + return None + + def performAccessibilityAction(self, host: View, action: int, arguments: Any) -> bool: + return False + + +# ═══════════════════════════════════════════════════════════════ +# ViewTreeObserver +# ═══════════════════════════════════════════════════════════════ + +class ViewTreeObserver(Stub): + """ViewTreeObserver — 视图树观察者""" + + class OnGlobalLayoutListener: + def onGlobalLayout(self): + pass + + class OnGlobalFocusChangeListener: + def onGlobalFocusChanged(self, old_focus: View, new_focus: View): + pass + + class OnScrollChangedListener: + def onScrollChanged(self): + pass + + class OnTouchModeChangeListener: + def onTouchModeChanged(self, is_in_touch_mode: bool): + pass + + class OnWindowAttachListener: + def onWindowAttached(self): + pass + def onWindowDetached(self): + pass + + class OnWindowFocusChangeListener: + def onWindowFocusChanged(self, has_focus: bool): + pass + + class OnDrawListener: + def onDraw(self): + pass + + class OnPreDrawListener: + def onPreDraw(self) -> bool: + return True + + class OnWindowShownListener: + def onWindowShown(self): + pass + + def __init__(self): + super().__init__() + self._global_layout_listeners: List[ViewTreeObserver.OnGlobalLayoutListener] = [] + self._scroll_changed_listeners: List[ViewTreeObserver.OnScrollChangedListener] = [] + self._pre_draw_listeners: List[ViewTreeObserver.OnPreDrawListener] = [] + self._draw_listeners: List[ViewTreeObserver.OnDrawListener] = [] + self._touch_mode_listeners: List[ViewTreeObserver.OnTouchModeChangeListener] = [] + self._window_focus_listeners: List[ViewTreeObserver.OnWindowFocusChangeListener] = [] + self._window_attach_listeners: List[ViewTreeObserver.OnWindowAttachListener] = [] + self._alive = True + + def addOnGlobalLayoutListener(self, listener: OnGlobalLayoutListener): + self._global_layout_listeners.append(listener) + + def removeOnGlobalLayoutListener(self, listener: OnGlobalLayoutListener): + if listener in self._global_layout_listeners: + self._global_layout_listeners.remove(listener) + + def addOnScrollChangedListener(self, listener: OnScrollChangedListener): + self._scroll_changed_listeners.append(listener) + + def removeOnScrollChangedListener(self, listener: OnScrollChangedListener): + if listener in self._scroll_changed_listeners: + self._scroll_changed_listeners.remove(listener) + + def addOnPreDrawListener(self, listener: OnPreDrawListener): + self._pre_draw_listeners.append(listener) + + def removeOnPreDrawListener(self, listener: OnPreDrawListener): + if listener in self._pre_draw_listeners: + self._pre_draw_listeners.remove(listener) + + def addOnDrawListener(self, listener: OnDrawListener): + self._draw_listeners.append(listener) + + def removeOnDrawListener(self, listener: OnDrawListener): + if listener in self._draw_listeners: + self._draw_listeners.remove(listener) + + def addOnGlobalFocusChangeListener(self, listener: OnGlobalFocusChangeListener): + pass + + def removeOnGlobalFocusChangeListener(self, listener: OnGlobalFocusChangeListener): + pass + + def addOnTouchModeChangeListener(self, listener: OnTouchModeChangeListener): + self._touch_mode_listeners.append(listener) + + def removeOnTouchModeChangeListener(self, listener: OnTouchModeChangeListener): + if listener in self._touch_mode_listeners: + self._touch_mode_listeners.remove(listener) + + def addOnWindowAttachListener(self, listener: OnWindowAttachListener): + self._window_attach_listeners.append(listener) + + def removeOnWindowAttachListener(self, listener: OnWindowAttachListener): + if listener in self._window_attach_listeners: + self._window_attach_listeners.remove(listener) + + def addOnWindowFocusChangeListener(self, listener: OnWindowFocusChangeListener): + self._window_focus_listeners.append(listener) + + def removeOnWindowFocusChangeListener(self, listener: OnWindowFocusChangeListener): + if listener in self._window_focus_listeners: + self._window_focus_listeners.remove(listener) + + def addOnWindowShownListener(self, listener: OnWindowShownListener): + pass + + def removeOnWindowShownListener(self, listener: OnWindowShownListener): + pass + + def dispatchOnGlobalLayout(self): + for listener in list(self._global_layout_listeners): + listener.onGlobalLayout() + + def dispatchOnScrollChanged(self): + for listener in list(self._scroll_changed_listeners): + listener.onScrollChanged() + + def isAlive(self) -> bool: + return self._alive + + def kill(self): + self._alive = False + self._global_layout_listeners.clear() + self._scroll_changed_listeners.clear() + self._pre_draw_listeners.clear() + self._draw_listeners.clear() + + +# ═══════════════════════════════════════════════════════════════ +# ViewConfiguration +# ═══════════════════════════════════════════════════════════════ + +class ViewConfiguration(Stub): + """ViewConfiguration — 视图配置常量""" + + def __init__(self, context=None): + super().__init__() + if context is None: + context = android_context + self._context = context + + @staticmethod + def get(context=None) -> "ViewConfiguration": + return ViewConfiguration(context) + + @staticmethod + def getLongPressTimeout() -> int: + return 500 + + @staticmethod + def getTapTimeout() -> int: + return 100 + + @staticmethod + def getJumpTapTimeout() -> int: + return 500 + + @staticmethod + def getDoubleTapTimeout() -> int: + return 300 + + @staticmethod + def getEdgeSlop() -> int: + return 12 + + @staticmethod + def getTouchSlop() -> int: + return 8 + + @staticmethod + def getScaledTouchSlop(self) -> int: + return 8 + + @staticmethod + def getScaledEdgeSlop(self) -> int: + return 12 + + @staticmethod + def getScaledFadingEdgeLength(self) -> int: + return 12 + + @staticmethod + def getScaledMinimumFlingVelocity(self) -> int: + return 50 + + @staticmethod + def getScaledMaximumFlingVelocity(self) -> int: + return 8000 + + @staticmethod + def getScaledPagingTouchSlop(self) -> int: + return 16 + + @staticmethod + def getScaledOverflingDistance(self) -> int: + return 32 + + @staticmethod + def getScaledOverscrollDistance(self) -> int: + return 32 + + @staticmethod + def getScaledScrollFactor(self) -> int: + return 64 + + @staticmethod + def getScrollFriction() -> float: + return 0.015 + + @staticmethod + def getMaximumDrawingCacheSize() -> int: + return 480 * 800 * 4 + + @staticmethod + def getWindowTouchSlop() -> int: + return 16 + + @staticmethod + def getGlobalActionKeySlop() -> int: + return 12 + + def getScaledWindowTouchSlop(self) -> int: + return 16 + + +# ═══════════════════════════════════════════════════════════════ +# SurfaceView +# ═══════════════════════════════════════════════════════════════ + +class SurfaceView(View): + """SurfaceView — 表面视图，用于直接绘制""" + + def __init__(self, context=None): + super().__init__(context) + self._surface = Surface() + self._surface_holder = SurfaceHolder() + + def getHolder(self) -> "SurfaceHolder": + return self._surface_holder + + def getSurfaceControl(self) -> Any: + return None + + def setVisibility(self, visibility: int): + super().setVisibility(visibility) + + def setSecure(self, is_secure: bool): + pass + + def setZOrderMediaOverlay(self, is_media_overlay: bool): + pass + + def setZOrderOnTop(self, on_top: bool): + pass + + def gatherTransparentRegion(self, region: Any) -> bool: + return False + + def draw(self, canvas: Any): + pass + + +class SurfaceHolder(Stub): + """SurfaceHolder — Surface 持有者""" + + class Callback: + def surfaceCreated(self, holder: "SurfaceHolder"): + pass + def surfaceChanged(self, holder: "SurfaceHolder", format: int, width: int, height: int): + pass + def surfaceDestroyed(self, holder: "SurfaceHolder"): + pass + + class Callback2(Callback): + def surfaceRedrawNeeded(self, holder: "SurfaceHolder"): + pass + + SURFACE_TYPE_NORMAL = 0 + SURFACE_TYPE_HARDWARE = 1 + SURFACE_TYPE_GPU = 2 + SURFACE_TYPE_PUSH_BUFFERS = 3 + + def __init__(self): + super().__init__() + self._surface = Surface() + self._callbacks: List[SurfaceHolder.Callback] = [] + self._type = SurfaceHolder.SURFACE_TYPE_NORMAL + self._fixed_size: Optional[Tuple[int, int]] = None + self._format = -1 + + def getSurface(self) -> "Surface": + return self._surface + + def addCallback(self, callback: Callback): + self._callbacks.append(callback) + + def removeCallback(self, callback: Callback): + if callback in self._callbacks: + self._callbacks.remove(callback) + + def isCreating(self) -> bool: + return False + + def setType(self, type_: int): + self._type = type_ + + def setFixedSize(self, width: int, height: int): + self._fixed_size = (width, height) + + def setSizeFromLayout(self): + self._fixed_size = None + + def setFormat(self, format: int): + self._format = format + + def lockCanvas(self) -> Any: + return None + + def lockCanvas(self, dirty: Any) -> Any: + return None + + def unlockCanvasAndPost(self, canvas: Any): + pass + + +# ═══════════════════════════════════════════════════════════════ +# TextureView +# ═══════════════════════════════════════════════════════════════ + +class TextureView(View): + """TextureView — 纹理视图""" + + def __init__(self, context=None): + super().__init__(context) + self._surface_texture = SurfaceTexture() + self._layer = None + self._update_listener: Optional[Callable] = None + self._surface_texture_listener: Optional[Callable] = None + + class SurfaceTextureListener: + def onSurfaceTextureAvailable(self, surface: "SurfaceTexture", width: int, height: int): + pass + def onSurfaceTextureSizeChanged(self, surface: "SurfaceTexture", width: int, height: int): + pass + def onSurfaceTextureDestroyed(self, surface: "SurfaceTexture") -> bool: + return True + def onSurfaceTextureUpdated(self, surface: "SurfaceTexture"): + pass + + def isOpaque(self) -> bool: + return False + + def setOpaque(self, opaque: bool): + pass + + def getSurfaceTexture(self) -> "SurfaceTexture": + return self._surface_texture + + def setSurfaceTexture(self, surface_texture: "SurfaceTexture"): + self._surface_texture = surface_texture + + def setSurfaceTextureListener(self, listener: SurfaceTextureListener): + self._surface_texture_listener = listener + + def getSurfaceTextureListener(self) -> Optional[SurfaceTextureListener]: + return self._surface_texture_listener + + def buildLayer(self): + pass + + def setLayerPaint(self, paint: Any): + pass + + def getLayerPaint(self) -> Any: + return None + + def setTransform(self, transform: Any): + pass + + def getTransform(self, transform: Any) -> Any: + return transform + + def draw(self, canvas: Any): + pass + + def lockCanvas(self) -> Any: + return None + + def unlockCanvasAndPost(self, canvas: Any): + pass + + +class SurfaceTexture(Stub): + """SurfaceTexture — 表面纹理""" + + def __init__(self, tex_name: int = 0, allow_legacy: bool = True): + super().__init__() + self._tex_name = tex_name + self._timestamp = 0 + self._frame_available_listener: Optional[Callable] = None + self._default_buffer_size: Optional[Tuple[int, int]] = None + + def setOnFrameAvailableListener(self, listener: Callable, handler: Any = None): + self._frame_available_listener = listener + + def getTimestamp(self) -> int: + return self._timestamp + + def updateTexImage(self): + pass + + def release(self): + pass + + def setDefaultBufferSize(self, width: int, height: int): + self._default_buffer_size = (width, height) + + def getTransformMatrix(self, mtx: List[float]): + for i in range(16): + mtx[i] = 1.0 if i % 5 == 0 else 0.0 + + +# ═══════════════════════════════════════════════════════════════ +# Window +# ═══════════════════════════════════════════════════════════════ + +class Window(Stub): + """Window — 抽象窗口基类""" + + # 特性ID + FEATURES_DEFAULT = -1 + FEATURE_OPTIONS_PANEL = 0 + FEATURE_NO_TITLE = 1 + FEATURE_PROGRESS = 2 + FEATURE_LEFT_ICON = 3 + FEATURE_RIGHT_ICON = 4 + FEATURE_INDETERMINATE_PROGRESS = 5 + FEATURE_CONTEXT_MENU = 6 + FEATURE_CUSTOM_TITLE = 7 + FEATURE_ACTION_BAR = 8 + FEATURE_ACTION_BAR_OVERLAY = 9 + FEATURE_ACTION_MODE_OVERLAY = 10 + FEATURE_SWIPE_TO_DISMISS = 11 + FEATURE_CONTENT_TRANSITIONS = 12 + FEATURE_WATCH = 13 + + # 本地特性 + ID_ANDROID_CONTENT = 0x01020002 + + DECOR_CAPTION_SHORTCUT_DURATION_MS = 1000 + + # 标志 + NAVIGATION_BAR_BACKGROUND_TRANSITION_NAME = "navigationBarBackground" + STATUS_BAR_BACKGROUND_TRANSITION_NAME = "statusBarBackground" + + def __init__(self, context=None): + super().__init__() + if context is None: + context = android_context + self._context = context + self._features: Dict[int, bool] = {} + self._title: str = "" + self._decor_view: Optional[View] = None + self._callback: Optional["Window.Callback"] = None + self._window_manager: Optional[WindowManager] = None + self._soft_input_mode = WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED + self._flags: Dict[int, bool] = {} + self._container: Optional[Window] = None + self._local_features: List[int] = [] + + class Callback: + def dispatchKeyEvent(self, event: KeyEvent) -> bool: + return False + def dispatchTouchEvent(self, event: MotionEvent) -> bool: + return False + def dispatchTrackballEvent(self, event: MotionEvent) -> bool: + return False + def dispatchGenericMotionEvent(self, event: MotionEvent) -> bool: + return False + def dispatchPopulateAccessibilityEvent(self, event: Any) -> bool: + return False + def onCreatePanelView(self, feature_id: int) -> Optional[View]: + return None + def onCreatePanelMenu(self, feature_id: int, menu: Any) -> bool: + return False + def onPreparePanel(self, feature_id: int, view: View, menu: Any) -> bool: + return False + def onMenuOpened(self, feature_id: int, menu: Any): + pass + def onMenuItemSelected(self, feature_id: int, item: Any) -> bool: + return False + def onWindowAttributesChanged(self, attrs: Any): + pass + def onContentChanged(self): + pass + def onWindowFocusChanged(self, has_focus: bool): + pass + def onAttachedToWindow(self): + pass + def onDetachedFromWindow(self): + pass + def onPanelClosed(self, feature_id: int, menu: Any): + pass + def onSearchRequested(self) -> bool: + return False + def onSearchRequested(self, search_event: Any) -> bool: + return False + def onActionModeStarted(self, mode: Any): + pass + def onActionModeFinished(self, mode: Any): + pass + def onWindowStartingActionMode(self, callback: Any) -> Optional[Any]: + return None + def onWindowStartingActionMode(self, callback: Any, type_: int) -> Optional[Any]: + return None + + def setContentView(self, layout_res_id: int): + pass + + def setContentView(self, view: View): + pass + + def setContentView(self, view: View, params: ViewGroup.LayoutParams): + pass + + def addContentView(self, view: View, params: ViewGroup.LayoutParams): + pass + + def setTitle(self, title: str): + self._title = title + + def getTitle(self) -> str: + return self._title + + def setFeatureInt(self, feature_id: int, value: int): + self._features[feature_id] = True + + def requestFeature(self, feature_id: int) -> bool: + self._features[feature_id] = True + return True + + def hasFeature(self, feature_id: int) -> bool: + return self._features.get(feature_id, False) + + def setFlags(self, flags: int, mask: int): + for flag_bit in range(32): + if mask & (1 << flag_bit): + self._flags[1 << flag_bit] = bool(flags & (1 << flag_bit)) + + def addFlags(self, flags: int): + for flag_bit in range(32): + if flags & (1 << flag_bit): + self._flags[1 << flag_bit] = True + + def clearFlags(self, flags: int): + for flag_bit in range(32): + if flags & (1 << flag_bit): + self._flags[1 << flag_bit] = False + + def setSoftInputMode(self, soft_input_mode: int): + self._soft_input_mode = soft_input_mode + + def getSoftInputMode(self) -> int: + return self._soft_input_mode + + def setLayout(self, width: int, height: int): + pass + + def findViewById(self, id_: int) -> Optional[View]: + if self._decor_view: + return self._decor_view.findViewById(id_) + return None + + def getDecorView(self) -> Optional[View]: + return self._decor_view + + def setDecorView(self, view: View): + self._decor_view = view + + def getWindowManager(self) -> Optional[WindowManager]: + return self._window_manager + + def setWindowManager(self, wm: WindowManager, app_token: Any = None, app_name: str = ""): + self._window_manager = wm + + def setCallback(self, callback: Callback): + self._callback = callback + + def getCallback(self) -> Optional[Callback]: + return self._callback + + def superDispatchTouchEvent(self, event: MotionEvent) -> bool: + if self._decor_view: + return self._decor_view.dispatchTouchEvent(event) + return False + + def superDispatchKeyEvent(self, event: KeyEvent) -> bool: + if self._decor_view: + return self._decor_view.dispatchKeyEvent(event) + return False + + def superDispatchTrackballEvent(self, event: MotionEvent) -> bool: + return False + + def superDispatchGenericMotionEvent(self, event: MotionEvent) -> bool: + return False + + def takeSurface(self, callback: Any): + pass + + def takeInputQueue(self, callback: Any): + pass + + def isActive(self) -> bool: + return True + + def isFloating(self) -> bool: + return False + + def setBackgroundDrawable(self, drawable: Any): + pass + + def setBackgroundDrawableResource(self, res_id: int): + pass + + def setDimAmount(self, amount: float): + pass + + def getLayoutInflater(self): + return None + + def setWindowAnimations(self, res_id: int): + pass + + def getWindowStyle(self) -> Any: + return None + + def setContainer(self, container: "Window"): + self._container = container + + def getContainer(self) -> Optional["Window"]: + return self._container + + def setLocalFeatures(self, local_features: int): + pass + + def makeActive(self): + pass + + def getContext(self): + return self._context + + def getAttributes(self) -> WindowManager.LayoutParams: + params = WindowManager.LayoutParams() + params.softInputMode = self._soft_input_mode + return params + + def setAttributes(self, attrs: WindowManager.LayoutParams): + pass + + def reconfigure(self, attrs: WindowManager.LayoutParams): + pass + + def onConfigurationChanged(self, new_config: Any): + pass + + def getCurrentFocus(self) -> Optional[View]: + return None + + def getVolumeControlStream(self) -> int: + return -1 + + def setVolumeControlStream(self, stream_type: int): + pass + + def getMediaController(self) -> Any: + return None + + def setMediaController(self, controller: Any): + pass + + def openGlEsVersion(self) -> int: + return 2 + + def isShortcutKey(self, key_code: int, event: KeyEvent) -> bool: + return False + + def setStatusBarColor(self, color: int): + pass + + def setNavigationBarColor(self, color: int): + pass + + def setStatusBarVisibility(self, visible: bool): + pass + + def setNavigationBarVisibility(self, visible: bool): + pass + + def getStatusBarColor(self) -> int: + return 0 + + def getNavigationBarColor(self) -> int: + return 0 + + +# ═══════════════════════════════════════════════════════════════ +# WindowInsets +# ═══════════════════════════════════════════════════════════════ + +class WindowInsets(Stub): + """WindowInsets — 窗口插入区域""" + + def __init__(self, left: int = 0, top: int = 0, right: int = 0, bottom: int = 0): + super().__init__() + self._system_window_insets = Rect(left, top, right, bottom) + self._stable_insets = Rect(0, 0, 0, 0) + self._display_cutout_insets = Rect(0, 0, 0, 0) + self._consumed = False + + def getSystemWindowInsetLeft(self) -> int: + return self._system_window_insets.left + + def getSystemWindowInsetTop(self) -> int: + return self._system_window_insets.top + + def getSystemWindowInsetRight(self) -> int: + return self._system_window_insets.right + + def getSystemWindowInsetBottom(self) -> int: + return self._system_window_insets.bottom + + def getSystemWindowInsets(self) -> Rect: + return self._system_window_insets + + def getStableInsetTop(self) -> int: + return self._stable_insets.top + + def getStableInsetLeft(self) -> int: + return self._stable_insets.left + + def getStableInsetRight(self) -> int: + return self._stable_insets.right + + def getStableInsetBottom(self) -> int: + return self._stable_insets.bottom + + def getDisplayCutoutInsets(self) -> Rect: + return self._display_cutout_insets + + def consumeDisplayCutout(self) -> "WindowInsets": + return WindowInsets() + + def consumeSystemWindowInsets(self) -> "WindowInsets": + return WindowInsets() + + def replaceSystemWindowInsets(self, left: int, top: int, right: int, bottom: int) -> "WindowInsets": + new_ins = WindowInsets(left, top, right, bottom) + new_ins._stable_insets = self._stable_insets + return new_ins + + def isConsumed(self) -> bool: + return self._consumed + + def hasSystemWindowInsets(self) -> bool: + return (self._system_window_insets.left > 0 or self._system_window_insets.top > 0 or + self._system_window_insets.right > 0 or self._system_window_insets.bottom > 0) + + def hasInsets(self) -> bool: + return self.hasSystemWindowInsets() + + def isRound(self) -> bool: + return False + + def getDisplayCutout(self) -> Any: + return None + + def consumeStableInsets(self) -> "WindowInsets": + return WindowInsets() + + def toString(self) -> str: + return f"WindowInsets(system={self._system_window_insets})" + + +# ═══════════════════════════════════════════════════════════════ +# WindowInsetsController +# ═══════════════════════════════════════════════════════════════ + +class WindowInsetsController(Stub): + """WindowInsetsController — 窗口插入控制器""" + + BEHAVIOR_SHOW_BARS_BY_TOUCH = 0 + BEHAVIOR_SHOW_BARS_BY_SWIPE = 1 + BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE = 2 + + APPEARANCE_OPAQUE_STATUS_BARS = 0x00000001 + APPEARANCE_OPAQUE_NAVIGATION_BARS = 0x00000002 + APPEARANCE_LOW_PROFILE_BARS = 0x00000004 + APPEARANCE_LIGHT_STATUS_BARS = 0x00000008 + APPEARANCE_LIGHT_NAVIGATION_BARS = 0x00000010 + + def __init__(self): + super().__init__() + self._appearance = 0 + self._behavior = WindowInsetsController.BEHAVIOR_SHOW_BARS_BY_TOUCH + + def show(self, types: int): + pass + + def hide(self, types: int): + pass + + def setSystemBarsAppearance(self, appearance: int, mask: int): + self._appearance = (self._appearance & ~mask) | (appearance & mask) + + def getSystemBarsAppearance(self) -> int: + return self._appearance + + def setSystemBarsBehavior(self, behavior: int): + self._behavior = behavior + + def getSystemBarsBehavior(self) -> int: + return self._behavior + + def setAnimationsDisabled(self, disabled: bool): + pass + + +# ═══════════════════════════════════════════════════════════════ +# Display +# ═══════════════════════════════════════════════════════════════ + +class Display(Stub): + """Display — 显示信息""" + + DEFAULT_DISPLAY = 0 + + ROTATION_0 = 0 + ROTATION_90 = 1 + ROTATION_180 = 2 + ROTATION_270 = 3 + + FLAG_PRESENTATION = 0x00000008 + FLAG_PRIVATE = 0x00000004 + FLAG_SECURE = 0x00000002 + FLAG_SUPPORTS_PROTECTED_BUFFERS = 0x00000001 + STATE_DOZE = 3 + STATE_DOZE_SUSPEND = 4 + STATE_OFF = 1 + STATE_ON = 2 + STATE_UNKNOWN = 0 + + def __init__(self, display_id: int = DEFAULT_DISPLAY): + super().__init__() + self._display_id = display_id + self._width = 1080 + self._height = 1920 + self._rotation = Display.ROTATION_0 + self._refresh_rate = 60.0 + self._density = 2.0 + self._density_dpi = 320 + self._state = Display.STATE_ON + self._flags = 0 + self._name = "Built-in Screen" + + def getDisplayId(self) -> int: + return self._display_id + + def getWidth(self) -> int: + return self._width + + def getHeight(self) -> int: + return self._height + + def getRotation(self) -> int: + return self._rotation + + def getRefreshRate(self) -> float: + return self._refresh_rate + + def getName(self) -> str: + return self._name + + def getState(self) -> int: + return self._state + + def getFlags(self) -> int: + return self._flags + + def isHdr(self) -> bool: + return False + + def isWideColorGamut(self) -> bool: + return False + + def getSize(self, out_size: Any = None): + if out_size is not None: + out_size.width = self._width + out_size.height = self._height + return None + + def getRealSize(self, out_size: Any = None): + if out_size is not None: + out_size.width = self._width + out_size.height = self._height + return None + + def getMetrics(self, metrics: Any = None): + if metrics is not None: + metrics.widthPixels = self._width + metrics.heightPixels = self._height + metrics.density = self._density + metrics.densityDpi = self._density_dpi + metrics.scaledDensity = self._density + metrics.xdpi = 320.0 + metrics.ydpi = 320.0 + return None + + def getRealMetrics(self, metrics: Any = None): + return self.getMetrics(metrics) + + def getOrientation(self) -> int: + return self._rotation + + def getDisplayAdjustments(self) -> Any: + return None + + def getPixelFormat(self) -> int: + return 1 # RGBA_8888 + + def isValid(self) -> bool: + return True + + def toString(self) -> str: + return f"Display({self._display_id}, {self._width}x{self._height})" + + +# ═══════════════════════════════════════════════════════════════ +# Surface +# ═══════════════════════════════════════════════════════════════ + +class Surface(Stub): + """Surface — 表面，用于绘制""" + + ROTATION_0 = 0 + ROTATION_90 = 1 + ROTATION_180 = 2 + ROTATION_270 = 3 + + CHANGE_FRAME_RATE_ALWAYS = 1 + CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS = 0 + + def __init__(self, surface_control: Any = None): + super().__init__() + self._is_valid = True + self._is_locked = False + self._width = 1080 + self._height = 1920 + self._hardware_accelerated = False + + def isValid(self) -> bool: + return self._is_valid + + def isConsumerRunningBehind(self) -> bool: + return False + + def lockCanvas(self, dirty_rect: Any = None) -> Any: + if not self._is_valid: + return None + self._is_locked = True + return None # 返回空 Canvas + + def lockHardwareCanvas(self) -> Any: + if not self._is_valid: + return None + self._is_locked = True + self._hardware_accelerated = True + return None + + def unlockCanvasAndPost(self, canvas: Any): + self._is_locked = False + + def getSurfaceControl(self) -> Any: + return None + + def release(self): + self._is_valid = False + self._is_locked = False + + def destroy(self): + self.release() + + def getWidth(self) -> int: + return self._width + + def getHeight(self) -> int: + return self._height + + def setFrameRate(self, frame_rate: float, compatibility: int): + pass + + def toString(self) -> str: + return f"Surface(valid={self._is_valid}, {self._width}x{self._height})" + + +# ═══════════════════════════════════════════════════════════════ +# Choreographer +# ═══════════════════════════════════════════════════════════════ + +class Choreographer(Stub): + """Choreographer — 帧渲染协调器""" + + CALLBACK_INPUT = 0 + CALLBACK_ANIMATION = 1 + CALLBACK_INSETS_ANIMATION = 2 + CALLBACK_TRAVERSAL = 3 + CALLBACK_COMMIT = 4 + + _instance: Optional["Choreographer"] = None + + class FrameCallback: + def doFrame(self, frame_time_nanos: int): + pass + + class FrameTimeline: + pass + + def __init__(self): + super().__init__() + + @staticmethod + def getInstance() -> "Choreographer": + if Choreographer._instance is None: + Choreographer._instance = Choreographer() + return Choreographer._instance + + def postFrameCallback(self, callback: "FrameCallback"): + callback.doFrame(int(time.time() * 1_000_000_000)) + + def postFrameCallbackDelayed(self, callback: "FrameCallback", delay_millis: int): + callback.doFrame(int((time.time() + delay_millis / 1000.0) * 1_000_000_000)) + + def removeFrameCallback(self, callback: "FrameCallback"): + pass + + def postCallback(self, callback_type: int, action: Callable, token: Any): + action() + + def postCallbackDelayed(self, callback_type: int, action: Callable, token: Any, delay_millis: int): + import threading + timer = threading.Timer(delay_millis / 1000.0, action) + timer.daemon = True + timer.start() + + def removeCallbacks(self, callback_type: int, action: Callable, token: Any): + pass + + def getFrameTimeNanos(self) -> int: + return int(time.time() * 1_000_000_000) + + def getLastFrameTimeNanos(self) -> int: + return int(time.time() * 1_000_000_000) - 16_666_666 + + +# ═══════════════════════════════════════════════════════════════ +# ActionMode +# ═══════════════════════════════════════════════════════════════ + +class ActionMode(Stub): + """ActionMode — 操作模式""" + + TYPE_FLOATING = 1 + TYPE_PRIMARY = 0 + TYPE_TOOLBAR = 2 + + class Callback: + def onCreateActionMode(self, mode: "ActionMode", menu: Any) -> bool: + return False + def onPrepareActionMode(self, mode: "ActionMode", menu: Any) -> bool: + return False + def onActionItemClicked(self, mode: "ActionMode", item: Any) -> bool: + return False + def onDestroyActionMode(self, mode: "ActionMode"): + pass + + class Callback2(Callback): + def onGetContentRect(self, mode: "ActionMode", view: View, out_rect: Any): + pass + + def __init__(self): + super().__init__() + self._tag: Any = None + self._title: str = "" + self._subtitle: str = "" + self._title_optional_hint: str = "" + self._subtitle_optional_hint: str = "" + self._type = ActionMode.TYPE_PRIMARY + self._menu: Any = None + + def setTitle(self, title: str): + self._title = title + + def getTitle(self) -> str: + return self._title + + def setSubtitle(self, subtitle: str): + self._subtitle = subtitle + + def getSubtitle(self) -> str: + return self._subtitle + + def setTitleOptionalHint(self, hint: bool): + self._title_optional_hint = hint + + def getTitleOptionalHint(self) -> bool: + return bool(self._title_optional_hint) + + def setTag(self, tag: Any): + self._tag = tag + + def getTag(self) -> Any: + return self._tag + + def getMenu(self): + return self._menu + + def setType(self, type_: int): + self._type = type_ + + def getType(self) -> int: + return self._type + + def invalidate(self): + pass + + def invalidateContentRect(self): + pass + + def finish(self): + pass + + def getCustomView(self) -> Optional[View]: + return None + + def setCustomView(self, view: View): + pass + + def setImageDrawable(self, drawable: Any): + pass + + def getMenuInflater(self): + return None + + +# ═══════════════════════════════════════════════════════════════ +# ContextThemeWrapper +# ═══════════════════════════════════════════════════════════════ + +class ContextThemeWrapper(Stub): + """ContextThemeWrapper — 上下文主题包装器""" + + def __init__(self, base: Any = None, theme_res_id: int = 0): + super().__init__() + self._base = base if base is not None else android_context + self._theme_res_id = theme_res_id + self._theme: Any = None + + def attachBaseContext(self, new_base: Any): + self._base = new_base + + def getBaseContext(self): + return self._base + + def setTheme(self, resid: int): + self._theme_res_id = resid + + def getThemeResId(self) -> int: + return self._theme_res_id + + def getTheme(self) -> Any: + return self._theme + + def getResources(self): + if hasattr(self._base, "getResources"): + return self._base.getResources() + return None + + def getSystemService(self, name: str) -> Any: + if hasattr(self._base, "getSystemService"): + return self._base.getSystemService(name) + return None + + def getPackageName(self) -> str: + if hasattr(self._base, "getPackageName"): + return self._base.getPackageName() + return "" + + def getApplicationContext(self): + return self._base + + +# ═══════════════════════════════════════════════════════════════ +# ViewOutlineProvider +# ═══════════════════════════════════════════════════════════════ + +class ViewOutlineProvider(Stub): + """ViewOutlineProvider — 视图轮廓提供者""" + + BACKGROUND = None + BOUNDS = None + PADDED_BOUNDS = None + + def getOutline(self, view: View, outline: Any): + pass + + # 预定义实例 + @staticmethod + def _init_constants(): + if ViewOutlineProvider.BACKGROUND is None: + class _Background(ViewOutlineProvider): + def getOutline(self, view, outline): + if hasattr(outline, "setRect"): + outline.setRect(0, 0, view.getWidth(), view.getHeight()) + ViewOutlineProvider.BACKGROUND = _Background() + + if ViewOutlineProvider.BOUNDS is None: + class _Bounds(ViewOutlineProvider): + def getOutline(self, view, outline): + if hasattr(outline, "setRect"): + outline.setRect(0, 0, view.getWidth(), view.getHeight()) + ViewOutlineProvider.BOUNDS = _Bounds() + + if ViewOutlineProvider.PADDED_BOUNDS is None: + class _PaddedBounds(ViewOutlineProvider): + def getOutline(self, view, outline): + if hasattr(outline, "setRect"): + outline.setRect( + view.getPaddingLeft(), view.getPaddingTop(), + view.getWidth() - view.getPaddingRight(), + view.getHeight() - view.getPaddingBottom(), + ) + ViewOutlineProvider.PADDED_BOUNDS = _PaddedBounds() + + +ViewOutlineProvider._init_constants() + +# ═══════════════════════════════════════════════════════════════ +# RenderNode +# ═══════════════════════════════════════════════════════════════ + +class RenderNode(Stub): + """RenderNode — 渲染节点""" + + STATUS_DISPLAY_LIST_INFLATED = 1 + STATUS_DISPLAY_LIST_READY = 2 + STATUS_DISPLAY_LIST_PREPARE = 3 + STATUS_DISPLAY_LIST_UNUSED = 0 + + def __init__(self, name: str = ""): + super().__init__() + self._name = name + self._alpha = 1.0 + self._translation_x = 0.0 + self._translation_y = 0.0 + self._translation_z = 0.0 + self._elevation = 0.0 + self._rotation = 0.0 + self._rotation_x = 0.0 + self._rotation_y = 0.0 + self._scale_x = 1.0 + self._scale_y = 1.0 + self._pivot_x = 0.0 + self._pivot_y = 0.0 + self._left = 0 + self._top = 0 + self._right = 0 + self._bottom = 0 + self._clip_to_bounds = False + self._clip_bounds: Optional[Rect] = None + self._has_display_list = False + self._status = RenderNode.STATUS_DISPLAY_LIST_UNUSED + + def setPosition(self, left: int, top: int, right: int, bottom: int) -> bool: + old_left, old_top, old_right, old_bottom = self._left, self._top, self._right, self._bottom + self._left, self._top, self._right, self._bottom = left, top, right, bottom + return (old_left != left or old_top != top or old_right != right or old_bottom != bottom) + + def getLeft(self) -> int: + return self._left + def getTop(self) -> int: + return self._top + def getRight(self) -> int: + return self._right + def getBottom(self) -> int: + return self._bottom + + def setAlpha(self, alpha: float) -> bool: + changed = self._alpha != alpha + self._alpha = alpha + return changed + + def getAlpha(self) -> float: + return self._alpha + + def setTranslationX(self, tx: float) -> bool: + changed = self._translation_x != tx + self._translation_x = tx + return changed + + def getTranslationX(self) -> float: + return self._translation_x + + def setTranslationY(self, ty: float) -> bool: + changed = self._translation_y != ty + self._translation_y = ty + return changed + + def getTranslationY(self) -> float: + return self._translation_y + + def setElevation(self, elevation: float) -> bool: + changed = self._elevation != elevation + self._elevation = elevation + return changed + + def getElevation(self) -> float: + return self._elevation + + def setRotation(self, rotation: float) -> bool: + changed = self._rotation != rotation + self._rotation = rotation + return changed + + def getRotation(self) -> float: + return self._rotation + + def setScaleX(self, scale_x: float) -> bool: + changed = self._scale_x != scale_x + self._scale_x = scale_x + return changed + + def getScaleX(self) -> float: + return self._scale_x + + def setScaleY(self, scale_y: float) -> bool: + changed = self._scale_y != scale_y + self._scale_y = scale_y + return changed + + def getScaleY(self) -> float: + return self._scale_y + + def setPivotX(self, pivot_x: float) -> bool: + changed = self._pivot_x != pivot_x + self._pivot_x = pivot_x + return changed + + def getPivotX(self) -> float: + return self._pivot_x + + def setPivotY(self, pivot_y: float) -> bool: + changed = self._pivot_y != pivot_y + self._pivot_y = pivot_y + return changed + + def getPivotY(self) -> float: + return self._pivot_y + + def setClipToBounds(self, clip_to_bounds: bool) -> bool: + changed = self._clip_to_bounds != clip_to_bounds + self._clip_to_bounds = clip_to_bounds + return changed + + def getClipToBounds(self) -> bool: + return self._clip_to_bounds + + def setClipBounds(self, clip_rect: Optional[Rect]): + self._clip_bounds = clip_rect + + def getClipBounds(self) -> Optional[Rect]: + return self._clip_bounds + + def setHasDisplayList(self, has_display_list: bool): + self._has_display_list = has_display_list + + def hasDisplayList(self) -> bool: + return self._has_display_list + + def getName(self) -> str: + return self._name + + def discardDisplayList(self): + self._has_display_list = False + self._status = RenderNode.STATUS_DISPLAY_LIST_UNUSED + + def start(self) -> Any: + return None + + def end(self): + pass + + def offsetLeftAndRight(self, offset: int): + self._left += offset + self._right += offset + + def offsetTopAndBottom(self, offset: int): + self._top += offset + self._bottom += offset + + def getMatrix(self, out_matrix: Any): + pass + + def getInverseMatrix(self, out_matrix: Any): + pass + + def useLighting(self) -> bool: + return False + + def setUseLighting(self, use_lighting: bool): + pass + + def setLayerType(self, layer_type: int): + pass + + def getLayerType(self) -> int: + return 0 + + +# ═══════════════════════════════════════════════════════════════ +# ScrollCaptureCallback +# ═══════════════════════════════════════════════════════════════ + +class ScrollCaptureCallback(Stub): + """ScrollCaptureCallback — 滚动捕获回调""" + + def onScrollCaptureSearch(self, l: int, t: int, r: int, b: int) -> Optional[Any]: + return None + + def onScrollCaptureStart(self, session: Any) -> Optional[Any]: + return None + + def onScrollCaptureImageRequest(self, session: Any, request: Any) -> int: + return 0 + + def onScrollCaptureEnd(self, session: Any): + pass + + +# ═══════════════════════════════════════════════════════════════ +# KeyboardShortcutGroup +# ═══════════════════════════════════════════════════════════════ + +class KeyboardShortcutGroup(Stub): + """KeyboardShortcutGroup — 键盘快捷键分组""" + + def __init__(self, label: str, items: Optional[List[Any]] = None): + super().__init__() + self._label = label + self._items: List[Any] = items if items is not None else [] + self._system_group = False + + def getLabel(self) -> str: + return self._label + + def getItems(self) -> List[Any]: + return list(self._items) + + def addItem(self, item: Any): + self._items.append(item) + + def setSystemGroup(self, is_system: bool): + self._system_group = is_system + + def isSystemGroup(self) -> bool: + return self._system_group + + +# ═══════════════════════════════════════════════════════════════ +# SoundEffectConstants +# ═══════════════════════════════════════════════════════════════ + +class SoundEffectConstants: + """SoundEffectConstants — 音效常量""" + + CLICK = 0 + NAVIGATION_LEFT = 1 + NAVIGATION_UP = 2 + NAVIGATION_RIGHT = 3 + NAVIGATION_DOWN = 4 + NAVIGATION_REPEAT_LEFT = 5 + NAVIGATION_REPEAT_UP = 6 + NAVIGATION_REPEAT_RIGHT = 7 + NAVIGATION_REPEAT_DOWN = 8 + + @staticmethod + def getDirectionForNavigation(gravity: int) -> int: + return SoundEffectConstants.NAVIGATION_UP + + +# ═══════════════════════════════════════════════════════════════ +# FocusFinder +# ═══════════════════════════════════════════════════════════════ + +class FocusFinder(Stub): + """FocusFinder — 焦点查找器""" + + _instance: Optional["FocusFinder"] = None + + def __init__(self): + super().__init__() + + @staticmethod + def getInstance() -> "FocusFinder": + if FocusFinder._instance is None: + FocusFinder._instance = FocusFinder() + return FocusFinder._instance + + def findNextFocus(self, root: ViewGroup, focused: View, direction: int) -> Optional[View]: + return None + + def findNearestTouchable(self, root: ViewGroup, x: int, y: int, direction: int, + deltas: List[int]) -> Optional[View]: + return None + + +# ═══════════════════════════════════════════════════════════════ +# ViewGroup override for children list +# ═══════════════════════════════════════════════════════════════ + +# Ensure ViewGroup._children is separate from View._children +ViewGroup._children = [] # Will be overridden in __init__ + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "View", + "ViewGroup", + "ViewParent", + "ViewManager", + "WindowManager", + "MotionEvent", + "KeyEvent", + "GestureDetector", + "ScaleGestureDetector", + "VelocityTracker", + "DragEvent", + "AccessibilityDelegate", + "ViewTreeObserver", + "ViewConfiguration", + "SurfaceView", + "TextureView", + "Window", + "WindowInsets", + "WindowInsetsController", + "Display", + "Surface", + "Choreographer", + "ActionMode", + "ContextThemeWrapper", + "Gravity", + "ViewOutlineProvider", + "RenderNode", + "ScrollCaptureCallback", + "KeyboardShortcutGroup", + "MeasureSpec", + "ViewPropertyAnimator", + "SurfaceHolder", + "SurfaceTexture", + "FocusFinder", + "SoundEffectConstants", + "Rect", +] \ No newline at end of file diff --git a/android_pyapi/android/view_accessibility.py b/android_pyapi/android/view_accessibility.py new file mode 100644 index 0000000..7e306bc --- /dev/null +++ b/android_pyapi/android/view_accessibility.py @@ -0,0 +1,1488 @@ +""" +Android View Accessibility 组件 — AccessibilityEvent, AccessibilityNodeInfo, +AccessibilityService, AccessibilityManager 等 +方法签名完全对齐 Android SDK +""" + +import sys +from typing import Any, Callable, Dict, List, Optional, Tuple + +from .._core import Stub, AndroidOnlyError, android_context + + +# ═══════════════════════════════════════════════════════════════ +# AccessibilityEvent +# ═══════════════════════════════════════════════════════════════ + +class AccessibilityEvent(Stub): + """AccessibilityEvent — 无障碍事件""" + + # 事件类型 + TYPE_VIEW_CLICKED = 0x00000001 + TYPE_VIEW_LONG_CLICKED = 0x00000002 + TYPE_VIEW_SELECTED = 0x00000004 + TYPE_VIEW_FOCUSED = 0x00000008 + TYPE_VIEW_TEXT_CHANGED = 0x00000010 + TYPE_WINDOW_STATE_CHANGED = 0x00000020 + TYPE_NOTIFICATION_STATE_CHANGED = 0x00000040 + TYPE_VIEW_HOVER_ENTER = 0x00000080 + TYPE_VIEW_HOVER_EXIT = 0x00000100 + TYPE_TOUCH_EXPLORATION_GESTURE_START = 0x00000200 + TYPE_TOUCH_EXPLORATION_GESTURE_END = 0x00000400 + TYPE_WINDOW_CONTENT_CHANGED = 0x00000800 + TYPE_VIEW_SCROLLED = 0x00001000 + TYPE_VIEW_TEXT_SELECTION_CHANGED = 0x00002000 + TYPE_ANNOUNCEMENT = 0x00004000 + TYPE_VIEW_ACCESSIBILITY_FOCUSED = 0x00008000 + TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED = 0x00010000 + TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY = 0x00020000 + TYPE_GESTURE_DETECTION_START = 0x00040000 + TYPE_GESTURE_DETECTION_END = 0x00080000 + TYPE_TOUCH_INTERACTION_START = 0x00100000 + TYPE_TOUCH_INTERACTION_END = 0x00200000 + TYPE_WINDOWS_CHANGED = 0x00400000 + TYPE_VIEW_CONTEXT_CLICKED = 0x00800000 + TYPE_ASSIST_READING_CONTENT = 0x01000000 + + # 内容变化类型 + CONTENT_CHANGE_TYPE_CONTENT_DESCRIPTION = 0x00000001 + CONTENT_CHANGE_TYPE_STATE_DESCRIPTION = 0x00000002 + CONTENT_CHANGE_TYPE_SUBTREE = 0x00000004 + CONTENT_CHANGE_TYPE_TEXT = 0x00000010 + CONTENT_CHANGE_TYPE_UNDEFINED = 0x00000000 + CONTENT_CHANGE_TYPE_PANE_TITLE = 0x00000020 + CONTENT_CHANGE_TYPE_DRAG_STARTED = 0x00000040 + CONTENT_CHANGE_TYPE_DRAG_CANCELLED = 0x00000080 + CONTENT_CHANGE_TYPE_DRAG_DROPPED = 0x00000100 + CONTENT_CHANGE_TYPE_CLEAR_FOCUS = 0x00000200 + CONTENT_CHANGE_TYPE_ADDED = 0x00000400 + CONTENT_CHANGE_TYPE_REMOVED = 0x00000800 + CONTENT_CHANGE_TYPE_VISIBILITY_CHANGED = 0x00001000 + CONTENT_CHANGE_TYPE_PANE_APPEARED = 0x00002000 + CONTENT_CHANGE_TYPE_PANE_DISAPPEARED = 0x00004000 + CONTENT_CHANGE_TYPE_ERROR = 0x00008000 + + # 窗口变化类型 + WINDOWS_CHANGE_ADDED = 0x00000001 + WINDOWS_CHANGE_REMOVED = 0x00000002 + WINDOWS_CHANGE_TITLE = 0x00000004 + WINDOWS_CHANGE_BOUNDS = 0x00000008 + WINDOWS_CHANGE_LAYER = 0x00000010 + WINDOWS_CHANGE_ACTIVE = 0x00000020 + WINDOWS_CHANGE_FOCUSED = 0x00000040 + WINDOWS_CHANGE_ACCESSIBILITY_FOCUSED = 0x00000080 + WINDOWS_CHANGE_PARENT = 0x00000100 + WINDOWS_CHANGE_CHILDREN = 0x00000200 + WINDOWS_CHANGE_PIP = 0x00000400 + + MAX_TEXT_LENGTH = 500 + + # 预留回收池 + _pool: List["AccessibilityEvent"] = [] + _pool_max = 10 + + def __init__(self): + super().__init__() + self._event_type: int = 0 + self._source: Optional[Any] = None + self._source_node_id: int = -1 + self._class_name: Optional[str] = None + self._package_name: Optional[str] = None + self._content_description: Optional[str] = None + self._text: List[str] = [] + self._action: int = 0 + self._from_index: int = -1 + self._to_index: int = -1 + self._item_count: int = 0 + self._current_item_index: int = 0 + self._enabled: bool = True + self._password: bool = False + self._checked: bool = False + self._full_package_name: Optional[str] = None + self._before_text: Optional[str] = None + self._movement_granularity: int = 0 + self._added_count: int = 0 + self._removed_count: int = 0 + self._content_change_types: int = 0 + self._scroll_delta_x: float = 0.0 + self._scroll_delta_y: float = 0.0 + self._max_scroll_x: float = 0.0 + self._max_scroll_y: float = 0.0 + self._event_time: int = 0 + self._parcelable_data: Dict[str, Any] = {} + self._record_count: int = 0 + + @staticmethod + def obtain(event: Optional["AccessibilityEvent"] = None) -> "AccessibilityEvent": + if AccessibilityEvent._pool: + result = AccessibilityEvent._pool.pop() + else: + result = AccessibilityEvent() + if event is not None: + result._event_type = event._event_type + result._source = event._source + result._class_name = event._class_name + result._package_name = event._package_name + result._content_description = event._content_description + result._text = list(event._text) + result._action = event._action + return result + + def recycle(self): + self._event_type = 0 + self._source = None + self._source_node_id = -1 + self._class_name = None + self._package_name = None + self._content_description = None + self._text.clear() + self._action = 0 + self._from_index = -1 + self._to_index = -1 + self._item_count = 0 + if len(AccessibilityEvent._pool) < AccessibilityEvent._pool_max: + AccessibilityEvent._pool.append(self) + + def getEventType(self) -> int: + return self._event_type + + def setEventType(self, event_type: int): + self._event_type = event_type + + def getSource(self) -> Optional[Any]: + return self._source + + def setSource(self, source: Optional[Any]): + self._source = source + + def getClassName(self) -> Optional[str]: + return self._class_name + + def setClassName(self, class_name: Optional[str]): + self._class_name = class_name + + def getPackageName(self) -> Optional[str]: + return self._package_name + + def setPackageName(self, package_name: Optional[str]): + self._package_name = package_name + + def getContentDescription(self) -> Optional[str]: + return self._content_description + + def setContentDescription(self, content_description: Optional[str]): + self._content_description = content_description + + def getText(self) -> List[str]: + return list(self._text) + + def getAction(self) -> int: + return self._action + + def setAction(self, action: int): + self._action = action + + def setFromIndex(self, from_index: int): + self._from_index = from_index + + def getFromIndex(self) -> int: + return self._from_index + + def setToIndex(self, to_index: int): + self._to_index = to_index + + def getToIndex(self) -> int: + return self._to_index + + def setItemCount(self, item_count: int): + self._item_count = item_count + + def getItemCount(self) -> int: + return self._item_count + + def setCurrentItemIndex(self, index: int): + self._current_item_index = index + + def getCurrentItemIndex(self) -> int: + return self._current_item_index + + def isEnabled(self) -> bool: + return self._enabled + + def setEnabled(self, enabled: bool): + self._enabled = enabled + + def isPassword(self) -> bool: + return self._password + + def setPassword(self, password: bool): + self._password = password + + def isChecked(self) -> bool: + return self._checked + + def setChecked(self, checked: bool): + self._checked = checked + + def getBeforeText(self) -> Optional[str]: + return self._before_text + + def setBeforeText(self, before_text: Optional[str]): + self._before_text = before_text + + def getMovementGranularity(self) -> int: + return self._movement_granularity + + def setMovementGranularity(self, granularity: int): + self._movement_granularity = granularity + + def getAddedCount(self) -> int: + return self._added_count + + def setAddedCount(self, added_count: int): + self._added_count = added_count + + def getRemovedCount(self) -> int: + return self._removed_count + + def setRemovedCount(self, removed_count: int): + self._removed_count = removed_count + + def getContentChangeTypes(self) -> int: + return self._content_change_types + + def setContentChangeTypes(self, change_types: int): + self._content_change_types = change_types + + def getScrollDeltaX(self) -> float: + return self._scroll_delta_x + + def setScrollDeltaX(self, delta_x: float): + self._scroll_delta_x = delta_x + + def getScrollDeltaY(self) -> float: + return self._scroll_delta_y + + def setScrollDeltaY(self, delta_y: float): + self._scroll_delta_y = delta_y + + def getMaxScrollX(self) -> float: + return self._max_scroll_x + + def setMaxScrollX(self, max_x: float): + self._max_scroll_x = max_x + + def getMaxScrollY(self) -> float: + return self._max_scroll_y + + def setMaxScrollY(self, max_y: float): + self._max_scroll_y = max_y + + def getEventTime(self) -> int: + return self._event_time + + def setEventTime(self, event_time: int): + self._event_time = event_time + + def getParcelableData(self) -> Any: + return self._parcelable_data + + def setParcelableData(self, data: Any): + if isinstance(data, dict): + self._parcelable_data = data + else: + self._parcelable_data = {"data": data} + + def getRecordCount(self) -> int: + return self._record_count + + def appendRecord(self, record: "AccessibilityRecord"): + self._record_count += 1 + + def getRecord(self, index: int) -> Optional["AccessibilityRecord"]: + return None + + def toString(self) -> str: + return (f"AccessibilityEvent(type={hex(self._event_type)}, " + f"className={self._class_name}, " + f"packageName={self._package_name}, " + f"text={self._text})") + + +# ═══════════════════════════════════════════════════════════════ +# AccessibilityRecord +# ═══════════════════════════════════════════════════════════════ + +class AccessibilityRecord(Stub): + """AccessibilityRecord — 无障碍记录""" + + def __init__(self): + super().__init__() + self._source: Optional[Any] = None + self._source_node_id: int = -1 + self._class_name: Optional[str] = None + self._package_name: Optional[str] = None + self._content_description: Optional[str] = None + self._text: List[str] = [] + self._from_index: int = -1 + self._to_index: int = -1 + self._item_count: int = 0 + self._current_item_index: int = 0 + self._scrollable: bool = False + self._scroll_x: int = 0 + self._scroll_y: int = 0 + self._max_scroll_x: int = 0 + self._max_scroll_y: int = 0 + self._enabled: bool = True + self._password: bool = False + self._checked: bool = False + self._full_package_name: Optional[str] = None + self._before_text: Optional[str] = None + self._removed_count: int = 0 + self._added_count: int = 0 + + def setSource(self, source: Optional[Any]): + self._source = source + + def getSource(self) -> Optional[Any]: + return self._source + + def setClassName(self, class_name: Optional[str]): + self._class_name = class_name + + def getClassName(self) -> Optional[str]: + return self._class_name + + def setContentDescription(self, content_description: Optional[str]): + self._content_description = content_description + + def getContentDescription(self) -> Optional[str]: + return self._content_description + + def setPackageName(self, package_name: Optional[str]): + self._package_name = package_name + + def getPackageName(self) -> Optional[str]: + return self._package_name + + def getText(self) -> List[str]: + return list(self._text) + + def setFromIndex(self, from_index: int): + self._from_index = from_index + + def getFromIndex(self) -> int: + return self._from_index + + def setToIndex(self, to_index: int): + self._to_index = to_index + + def getToIndex(self) -> int: + return self._to_index + + def setItemCount(self, item_count: int): + self._item_count = item_count + + def getItemCount(self) -> int: + return self._item_count + + def setScrollable(self, scrollable: bool): + self._scrollable = scrollable + + def getScrollable(self) -> bool: + return self._scrollable + + def setScrollX(self, scroll_x: int): + self._scroll_x = scroll_x + + def getScrollX(self) -> int: + return self._scroll_x + + def setScrollY(self, scroll_y: int): + self._scroll_y = scroll_y + + def getScrollY(self) -> int: + return self._scroll_y + + def setMaxScrollX(self, max_scroll_x: int): + self._max_scroll_x = max_scroll_x + + def getMaxScrollX(self) -> int: + return self._max_scroll_x + + def setMaxScrollY(self, max_scroll_y: int): + self._max_scroll_y = max_scroll_y + + def getMaxScrollY(self) -> int: + return self._max_scroll_y + + def isEnabled(self) -> bool: + return self._enabled + + def setEnabled(self, enabled: bool): + self._enabled = enabled + + def isPassword(self) -> bool: + return self._password + + def setPassword(self, password: bool): + self._password = password + + def isChecked(self) -> bool: + return self._checked + + def setChecked(self, checked: bool): + self._checked = checked + + def getBeforeText(self) -> Optional[str]: + return self._before_text + + def setBeforeText(self, before_text: Optional[str]): + self._before_text = before_text + + def getAddedCount(self) -> int: + return self._added_count + + def setAddedCount(self, added_count: int): + self._added_count = added_count + + def getRemovedCount(self) -> int: + return self._removed_count + + def setRemovedCount(self, removed_count: int): + self._removed_count = removed_count + + def toString(self) -> str: + return (f"AccessibilityRecord(className={self._class_name}, " + f"packageName={self._package_name})") + + +# ═══════════════════════════════════════════════════════════════ +# AccessibilityNodeInfo +# ═══════════════════════════════════════════════════════════════ + +class AccessibilityNodeInfo(Stub): + """AccessibilityNodeInfo — 无障碍节点信息""" + + FLAG_INCLUDE_NOT_IMPORTANT_VIEWS = 0x00000002 + FLAG_REPORT_VIEW_IDS = 0x00000010 + FLAG_PREFETCH_PREDECESSORS = 0x00000001 + FLAG_PREFETCH_SIBLINGS = 0x00000002 + FLAG_PREFETCH_DESCENDANTS = 0x00000004 + + ACTION_CLICK = 0x00000010 + ACTION_LONG_CLICK = 0x00000020 + ACTION_FOCUS = 0x00000040 + ACTION_CLEAR_FOCUS = 0x00000080 + ACTION_SELECT = 0x00000100 + ACTION_CLEAR_SELECTION = 0x00000200 + ACTION_ACCESSIBILITY_FOCUS = 0x00000400 + ACTION_CLEAR_ACCESSIBILITY_FOCUS = 0x00000800 + ACTION_SCROLL_FORWARD = 0x00001000 + ACTION_SCROLL_BACKWARD = 0x00002000 + ACTION_SCROLL_TO_POSITION = 0x00004000 + ACTION_SET_SELECTION = 0x00008000 + ACTION_COPY = 0x00010000 + ACTION_PASTE = 0x00020000 + ACTION_CUT = 0x00030000 + ACTION_SET_TEXT = 0x00040000 + ACTION_EXPAND = 0x00080000 + ACTION_COLLAPSE = 0x00100000 + ACTION_DISMISS = 0x00200000 + ACTION_MOVE_WINDOW = 0x00400000 + ACTION_SHOW_ON_SCREEN = 0x00800000 + ACTION_CONTEXT_CLICK = 0x01000000 + ACTION_SCROLL_UP = 0x02000000 + ACTION_SCROLL_DOWN = 0x04000000 + ACTION_SCROLL_LEFT = 0x08000000 + ACTION_SCROLL_RIGHT = 0x10000000 + ACTION_PAGE_UP = 0x20000000 + ACTION_PAGE_DOWN = 0x40000000 + ACTION_PAGE_LEFT = 0x80000000 + ACTION_PAGE_RIGHT = 0x100000000 + + # 移动粒度 + MOVEMENT_GRANULARITY_CHARACTER = 1 + MOVEMENT_GRANULARITY_WORD = 2 + MOVEMENT_GRANULARITY_LINE = 4 + MOVEMENT_GRANULARITY_PARAGRAPH = 8 + MOVEMENT_GRANULARITY_PAGE = 16 + + def __init__(self): + super().__init__() + self._children: List["AccessibilityNodeInfo"] = [] + self._actions: int = 0 + self._clickable: bool = False + self._focusable: bool = False + self._long_clickable: bool = False + self._scrollable: bool = False + self._content_description: Optional[str] = None + self._text: Optional[str] = None + self._class_name: Optional[str] = None + self._package_name: Optional[str] = None + self._parent: Optional["AccessibilityNodeInfo"] = None + self._view_id: Optional[str] = None + self._enabled: bool = True + self._password: bool = False + self._checked: bool = False + self._checkable: bool = False + self._selected: bool = False + self._focused: bool = False + self._visible_to_user: bool = True + self._accessibility_focused: bool = False + self._can_open_popup: bool = False + self._dismissable: bool = False + self._editable: bool = False + self._multi_line: bool = False + self._important_for_accessibility: bool = True + self._pane_title: Optional[str] = None + self._hint_text: Optional[str] = None + self._tooltip_text: Optional[str] = None + self._error: Optional[str] = None + self._min_text_length: int = -1 + self._max_text_length: int = -1 + self._child_count: int = 0 + self._bounds_in_parent: Optional[Tuple[int, int, int, int]] = None + self._bounds_in_screen: Optional[Tuple[int, int, int, int]] = None + + def findAccessibilityNodeInfosByText(self, text: str) -> List["AccessibilityNodeInfo"]: + result: List["AccessibilityNodeInfo"] = [] + if self._text and text and text.lower() in self._text.lower(): + result.append(self) + for child in self._children: + result.extend(child.findAccessibilityNodeInfosByText(text)) + return result + + def findAccessibilityNodeInfosByViewId(self, view_id: str) -> List["AccessibilityNodeInfo"]: + result: List["AccessibilityNodeInfo"] = [] + if self._view_id == view_id: + result.append(self) + for child in self._children: + result.extend(child.findAccessibilityNodeInfosByViewId(view_id)) + return result + + def performAction(self, action: int) -> bool: + if action & self._actions: + sys.stderr.write(f"[AccessibilityNodeInfo] performAction: {hex(action)}\n") + return True + return False + + def setClickable(self, clickable: bool): + self._clickable = clickable + + def isClickable(self) -> bool: + return self._clickable + + def setFocusable(self, focusable: bool): + self._focusable = focusable + + def isFocusable(self) -> bool: + return self._focusable + + def setLongClickable(self, long_clickable: bool): + self._long_clickable = long_clickable + + def isLongClickable(self) -> bool: + return self._long_clickable + + def setScrollable(self, scrollable: bool): + self._scrollable = scrollable + + def isScrollable(self) -> bool: + return self._scrollable + + def setContentDescription(self, content_description: Optional[str]): + self._content_description = content_description + + def getContentDescription(self) -> Optional[str]: + return self._content_description + + def setText(self, text: Optional[str]): + self._text = text + + def getText(self) -> Optional[str]: + return self._text + + def setClassName(self, class_name: Optional[str]): + self._class_name = class_name + + def getClassName(self) -> Optional[str]: + return self._class_name + + def setPackageName(self, package_name: Optional[str]): + self._package_name = package_name + + def getPackageName(self) -> Optional[str]: + return self._package_name + + def getChild(self, index: int) -> Optional["AccessibilityNodeInfo"]: + if 0 <= index < len(self._children): + return self._children[index] + return None + + def setParent(self, parent: Optional["AccessibilityNodeInfo"]): + self._parent = parent + + def getParent(self) -> Optional["AccessibilityNodeInfo"]: + return self._parent + + def getChildCount(self) -> int: + return len(self._children) + + def addChild(self, child: "AccessibilityNodeInfo"): + self._children.append(child) + child._parent = self + + def addAction(self, action: int): + self._actions |= action + + def setActions(self, actions: int): + self._actions = actions + + def getActions(self) -> int: + return self._actions + + def setViewIdResourceName(self, view_id: str): + self._view_id = view_id + + def getViewIdResourceName(self) -> Optional[str]: + return self._view_id + + def isEnabled(self) -> bool: + return self._enabled + + def setEnabled(self, enabled: bool): + self._enabled = enabled + + def isPassword(self) -> bool: + return self._password + + def setPassword(self, password: bool): + self._password = password + + def isChecked(self) -> bool: + return self._checked + + def setChecked(self, checked: bool): + self._checked = checked + + def isCheckable(self) -> bool: + return self._checkable + + def setCheckable(self, checkable: bool): + self._checkable = checkable + + def isSelected(self) -> bool: + return self._selected + + def setSelected(self, selected: bool): + self._selected = selected + + def isFocused(self) -> bool: + return self._focused + + def setFocused(self, focused: bool): + self._focused = focused + + def isVisibleToUser(self) -> bool: + return self._visible_to_user + + def setVisibleToUser(self, visible: bool): + self._visible_to_user = visible + + def isAccessibilityFocused(self) -> bool: + return self._accessibility_focused + + def setAccessibilityFocused(self, focused: bool): + self._accessibility_focused = focused + + def isEditable(self) -> bool: + return self._editable + + def setEditable(self, editable: bool): + self._editable = editable + + def isMultiLine(self) -> bool: + return self._multi_line + + def setMultiLine(self, multi_line: bool): + self._multi_line = multi_line + + def isImportantForAccessibility(self) -> bool: + return self._important_for_accessibility + + def setImportantForAccessibility(self, important: bool): + self._important_for_accessibility = important + + def setPaneTitle(self, pane_title: Optional[str]): + self._pane_title = pane_title + + def getPaneTitle(self) -> Optional[str]: + return self._pane_title + + def setHintText(self, hint_text: Optional[str]): + self._hint_text = hint_text + + def getHintText(self) -> Optional[str]: + return self._hint_text + + def setTooltipText(self, tooltip_text: Optional[str]): + self._tooltip_text = tooltip_text + + def getTooltipText(self) -> Optional[str]: + return self._tooltip_text + + def setError(self, error: Optional[str]): + self._error = error + + def getError(self) -> Optional[str]: + return self._error + + def setBoundsInParent(self, left: int, top: int, right: int, bottom: int): + self._bounds_in_parent = (left, top, right, bottom) + + def getBoundsInParent(self) -> Optional[Tuple[int, int, int, int]]: + return self._bounds_in_parent + + def setBoundsInScreen(self, left: int, top: int, right: int, bottom: int): + self._bounds_in_screen = (left, top, right, bottom) + + def getBoundsInScreen(self) -> Optional[Tuple[int, int, int, int]]: + return self._bounds_in_screen + + def getWindowId(self) -> int: + return -1 + + def recycle(self): + self._children.clear() + self._parent = None + self._actions = 0 + + def toString(self) -> str: + return (f"AccessibilityNodeInfo(className={self._class_name}, " + f"text={self._text}, " + f"contentDescription={self._content_description})") + + +# ═══════════════════════════════════════════════════════════════ +# AccessibilityNodeProvider +# ═══════════════════════════════════════════════════════════════ + +class AccessibilityNodeProvider(Stub): + """AccessibilityNodeProvider — 无障碍节点提供者""" + + HOST_VIEW_ID = -1 + + def __init__(self): + super().__init__() + + def createAccessibilityNodeInfo(self, virtual_view_id: int) -> AccessibilityNodeInfo: + raise AndroidOnlyError("AccessibilityNodeProvider.createAccessibilityNodeInfo") + + def addExtraDataToAccessibilityNodeInfo(self, virtual_view_id: int, + info: AccessibilityNodeInfo, + extra_data_key: str, + arguments: Optional[Any]): + pass + + def performAction(self, virtual_view_id: int, action: int, + arguments: Optional[Any]) -> bool: + return False + + def findFocus(self, focus: int) -> Optional[AccessibilityNodeInfo]: + return None + + +# ═══════════════════════════════════════════════════════════════ +# AccessibilityServiceInfo +# ═══════════════════════════════════════════════════════════════ + +class AccessibilityServiceInfo(Stub): + """AccessibilityServiceInfo — 无障碍服务信息""" + + FEEDBACK_GENERIC = 16 + FEEDBACK_SPOKEN = 1 + FEEDBACK_HAPTIC = 2 + FEEDBACK_AUDIBLE = 4 + FEEDBACK_VISUAL = 8 + FEEDBACK_BRAILLE = 32 + FEEDBACK_ALL_MASK = -1 + + FLAG_REQUEST_TOUCH_EXPLORATION_MODE = 0x00000001 + FLAG_REQUEST_ENHANCED_WEB_ACCESSIBILITY = 0x00000002 + FLAG_REPORT_VIEW_IDS = 0x00000010 + FLAG_REQUEST_FILTER_KEY_EVENTS = 0x00000020 + FLAG_RETRIEVE_INTERACTIVE_WINDOWS = 0x00000040 + FLAG_INCLUDE_NOT_IMPORTANT_VIEWS = 0x00000080 + FLAG_REQUEST_ACCESSIBILITY_BUTTON = 0x00000100 + FLAG_REQUEST_SHORTCUT_WARNING_DIALOG = 0x00000200 + + CAPABILITY_CAN_RETRIEVE_WINDOW_CONTENT = 1 + CAPABILITY_CAN_REQUEST_TOUCH_EXPLORATION = 2 + CAPABILITY_CAN_REQUEST_ENHANCED_WEB_ACCESSIBILITY = 4 + CAPABILITY_CAN_REQUEST_FILTER_KEY_EVENTS = 8 + CAPABILITY_CAN_CONTROL_MAGNIFICATION = 16 + CAPABILITY_CAN_PERFORM_GESTURES = 32 + + def __init__(self): + super().__init__() + self.eventTypes: int = 0 + self.feedbackType: int = 0 + self.flags: int = 0 + self.notificationTimeout: int = 0 + self.filterTouchExploration: bool = False + self.packageNames: Optional[List[str]] = None + self.descriptionResId: int = 0 + self.description: Optional[str] = None + self.settingsActivityName: Optional[str] = None + self.capabilities: int = 0 + self.interactiveUiTimeout: int = 0 + self.nonInteractiveUiTimeout: int = 0 + + def getCapabilityInfo(self, capability: int) -> Optional[str]: + cap_map = { + self.CAPABILITY_CAN_RETRIEVE_WINDOW_CONTENT: "CAN_RETRIEVE_WINDOW_CONTENT", + self.CAPABILITY_CAN_REQUEST_TOUCH_EXPLORATION: "CAN_REQUEST_TOUCH_EXPLORATION", + self.CAPABILITY_CAN_CONTROL_MAGNIFICATION: "CAN_CONTROL_MAGNIFICATION", + self.CAPABILITY_CAN_PERFORM_GESTURES: "CAN_PERFORM_GESTURES", + } + return cap_map.get(capability) + + def toString(self) -> str: + return (f"AccessibilityServiceInfo(eventTypes={hex(self.eventTypes)}, " + f"feedbackType={self.feedbackType}, " + f"flags={hex(self.flags)})") + + +# ═══════════════════════════════════════════════════════════════ +# AccessibilityWindowInfo +# ═══════════════════════════════════════════════════════════════ + +class AccessibilityWindowInfo(Stub): + """AccessibilityWindowInfo — 无障碍窗口信息""" + + TYPE_APPLICATION = 1 + TYPE_INPUT_METHOD = 2 + TYPE_SYSTEM = 3 + TYPE_ACCESSIBILITY_OVERLAY = 4 + TYPE_SPLIT_SCREEN_DIVIDER = 5 + + UNDEFINED = -1 + ACTIVE = 0x00000001 + FOCUSED = 0x00000002 + ACCESSIBILITY_FOCUSED = 0x00000004 + + def __init__(self): + super().__init__() + self._type: int = TYPE_SYSTEM + self._bounds_in_screen: Tuple[int, int, int, int] = (0, 0, 0, 0) + self._root: Optional[AccessibilityNodeInfo] = None + self._title: Optional[str] = None + self._anchor: Optional[Any] = None + self._parent: Optional["AccessibilityWindowInfo"] = None + self._children: List["AccessibilityWindowInfo"] = [] + self._id: int = -1 + self._layer: int = 0 + self._active: bool = False + self._focused: bool = False + self._accessibility_focused: bool = False + self._picture_in_picture: bool = False + + @staticmethod + def obtain() -> "AccessibilityWindowInfo": + return AccessibilityWindowInfo() + + def recycle(self): + self._root = None + self._children.clear() + self._parent = None + + def getType(self) -> int: + return self._type + + def setType(self, window_type: int): + self._type = window_type + + def getBoundsInScreen(self) -> Tuple[int, int, int, int]: + return self._bounds_in_screen + + def setBoundsInScreen(self, left: int, top: int, right: int, bottom: int): + self._bounds_in_screen = (left, top, right, bottom) + + def getRoot(self) -> Optional[AccessibilityNodeInfo]: + return self._root + + def setRoot(self, root: Optional[AccessibilityNodeInfo]): + self._root = root + + def getTitle(self) -> Optional[str]: + return self._title + + def setTitle(self, title: Optional[str]): + self._title = title + + def getAnchor(self) -> Optional[Any]: + return self._anchor + + def setAnchor(self, anchor: Optional[Any]): + self._anchor = anchor + + def getId(self) -> int: + return self._id + + def setId(self, window_id: int): + self._id = window_id + + def getLayer(self) -> int: + return self._layer + + def setLayer(self, layer: int): + self._layer = layer + + def getParent(self) -> Optional["AccessibilityWindowInfo"]: + return self._parent + + def setParent(self, parent: Optional["AccessibilityWindowInfo"]): + self._parent = parent + + def getChild(self, index: int) -> Optional["AccessibilityWindowInfo"]: + if 0 <= index < len(self._children): + return self._children[index] + return None + + def getChildCount(self) -> int: + return len(self._children) + + def addChild(self, child: "AccessibilityWindowInfo"): + self._children.append(child) + + def isActive(self) -> bool: + return self._active + + def setActive(self, active: bool): + self._active = active + + def isFocused(self) -> bool: + return self._focused + + def setFocused(self, focused: bool): + self._focused = focused + + def isAccessibilityFocused(self) -> bool: + return self._accessibility_focused + + def setAccessibilityFocused(self, focused: bool): + self._accessibility_focused = focused + + def isInPictureInPictureMode(self) -> bool: + return self._picture_in_picture + + def setPictureInPictureMode(self, pip: bool): + self._picture_in_picture = pip + + def toString(self) -> str: + type_names = {1: "APPLICATION", 2: "INPUT_METHOD", 3: "SYSTEM", + 4: "ACCESSIBILITY_OVERLAY", 5: "SPLIT_SCREEN_DIVIDER"} + type_name = type_names.get(self._type, "UNKNOWN") + return f"AccessibilityWindowInfo(id={self._id}, type={type_name}, title={self._title})" + + +# ═══════════════════════════════════════════════════════════════ +# AccessibilityService +# ═══════════════════════════════════════════════════════════════ + +class AccessibilityService(Stub): + """AccessibilityService — 无障碍服务基类""" + + GLOBAL_ACTION_BACK = 1 + GLOBAL_ACTION_HOME = 2 + GLOBAL_ACTION_RECENTS = 3 + GLOBAL_ACTION_NOTIFICATIONS = 4 + GLOBAL_ACTION_QUICK_SETTINGS = 5 + GLOBAL_ACTION_POWER_DIALOG = 6 + GLOBAL_ACTION_TOGGLE_SPLIT_SCREEN = 7 + GLOBAL_ACTION_LOCK_SCREEN = 8 + GLOBAL_ACTION_TAKE_SCREENSHOT = 9 + GLOBAL_ACTION_KEYCODE_HEADSETHOOK = 10 + GLOBAL_ACTION_ACCESSIBILITY_SHORTCUT = 11 + GLOBAL_ACTION_ACCESSIBILITY_BUTTON = 12 + GLOBAL_ACTION_ACCESSIBILITY_BUTTON_CHOOSER = 13 + GLOBAL_ACTION_ACCESSIBILITY_SHORTCUT_CHOOSER = 14 + GLOBAL_ACTION_ACCESSIBILITY_ALL_APPS = 15 + + def __init__(self): + super().__init__() + self._service_info: Optional[AccessibilityServiceInfo] = None + self._root_node: Optional[AccessibilityNodeInfo] = None + self._windows: List[AccessibilityWindowInfo] = [] + + def onAccessibilityEvent(self, event: AccessibilityEvent): + raise AndroidOnlyError("AccessibilityService.onAccessibilityEvent: not implemented") + + def onInterrupt(self): + raise AndroidOnlyError("AccessibilityService.onInterrupt: not implemented") + + def onServiceConnected(self): + pass + + def performGlobalAction(self, action: int) -> bool: + action_names = { + self.GLOBAL_ACTION_BACK: "BACK", + self.GLOBAL_ACTION_HOME: "HOME", + self.GLOBAL_ACTION_RECENTS: "RECENTS", + self.GLOBAL_ACTION_NOTIFICATIONS: "NOTIFICATIONS", + self.GLOBAL_ACTION_QUICK_SETTINGS: "QUICK_SETTINGS", + } + sys.stderr.write(f"[AccessibilityService] performGlobalAction: " + f"{action_names.get(action, hex(action))}\n") + return True + + def getRootInActiveWindow(self) -> Optional[AccessibilityNodeInfo]: + return self._root_node + + def findFocus(self, focus_type: int) -> Optional[AccessibilityNodeInfo]: + return self._root_node + + def getServiceInfo(self) -> Optional[AccessibilityServiceInfo]: + return self._service_info + + def setServiceInfo(self, info: AccessibilityServiceInfo): + self._service_info = info + + def getWindows(self) -> List[AccessibilityWindowInfo]: + return list(self._windows) + + def getWindowsOnScreen(self) -> List[AccessibilityWindowInfo]: + return [w for w in self._windows if w.isActive()] + + def disableSelf(self): + sys.stderr.write("[AccessibilityService] disableSelf\n") + + def onKeyEvent(self, event: Any) -> bool: + return False + + def onGesture(self, gesture_id: int) -> bool: + return False + + def onMotionEvent(self, event: Any) -> bool: + return False + + def onTouchExplorationStateChanged(self, enabled: bool): + pass + + def onMagnificationChanged(self, region: Any, scale: float): + pass + + def onSoftKeyboardShowModeChanged(self, show_mode: int): + pass + + def dispatchKeyEventToInputMethod(self, event: Any) -> bool: + return False + + +# ═══════════════════════════════════════════════════════════════ +# AccessibilityManager +# ═══════════════════════════════════════════════════════════════ + +class AccessibilityManager(Stub): + """AccessibilityManager — 无障碍管理器""" + + def __init__(self): + super().__init__() + self._enabled: bool = False + self._touch_exploration_enabled: bool = False + self._state_listeners: List[Callable] = [] + self._touch_exploration_listeners: List[Callable] = [] + self._accessibility_service_list: List[AccessibilityServiceInfo] = [] + self._request_preparers: List[Any] = [] + + def isEnabled(self) -> bool: + return self._enabled + + def setEnabled(self, enabled: bool): + old = self._enabled + self._enabled = enabled + if old != enabled: + for listener in list(self._state_listeners): + try: + listener.onAccessibilityStateChanged(enabled) + except Exception: + pass + + def isTouchExplorationEnabled(self) -> bool: + return self._touch_exploration_enabled + + def addAccessibilityStateChangeListener(self, listener: Callable) -> bool: + if listener not in self._state_listeners: + self._state_listeners.append(listener) + return True + return False + + def removeAccessibilityStateChangeListener(self, listener: Callable) -> bool: + if listener in self._state_listeners: + self._state_listeners.remove(listener) + return True + return False + + def addTouchExplorationStateChangeListener(self, listener: Callable) -> bool: + if listener not in self._touch_exploration_listeners: + self._touch_exploration_listeners.append(listener) + return True + return False + + def removeTouchExplorationStateChangeListener(self, listener: Callable) -> bool: + if listener in self._touch_exploration_listeners: + self._touch_exploration_listeners.remove(listener) + return True + return False + + def getAccessibilityServiceList(self) -> List[AccessibilityServiceInfo]: + return list(self._accessibility_service_list) + + def addAccessibilityRequestPreparer(self, preparer: Any): + if preparer not in self._request_preparers: + self._request_preparers.append(preparer) + + def removeAccessibilityRequestPreparer(self, preparer: Any): + if preparer in self._request_preparers: + self._request_preparers.remove(preparer) + + def sendAccessibilityEvent(self, event: AccessibilityEvent): + sys.stderr.write(f"[AccessibilityManager] sendEvent: type={hex(event.getEventType())}\n") + + def interrupt(self): + sys.stderr.write("[AccessibilityManager] interrupt\n") + + def getEnabledAccessibilityServiceList(self, feedback_type_flags: int) -> List[AccessibilityServiceInfo]: + return [s for s in self._accessibility_service_list + if s.feedbackType & feedback_type_flags] + + def getInstalledAccessibilityServiceList(self) -> List[AccessibilityServiceInfo]: + return list(self._accessibility_service_list) + + def addAccessibilityStateChangeListener(self, listener: Callable) -> bool: + if listener not in self._state_listeners: + self._state_listeners.append(listener) + return True + return False + + def removeAccessibilityStateChangeListener(self, listener: Callable) -> bool: + if listener in self._state_listeners: + self._state_listeners.remove(listener) + return True + return False + + def toString(self) -> str: + return f"AccessibilityManager(enabled={self._enabled})" + + +# ═══════════════════════════════════════════════════════════════ +# CaptioningManager +# ═══════════════════════════════════════════════════════════════ + +class CaptioningManager(Stub): + """CaptioningManager — 字幕管理器""" + + class CaptionStyle(Stub): + """CaptionStyle — 字幕样式""" + + EDGE_TYPE_NONE = 0 + EDGE_TYPE_OUTLINE = 1 + EDGE_TYPE_DROP_SHADOW = 2 + EDGE_TYPE_RAISED = 3 + EDGE_TYPE_DEPRESSED = 4 + + def __init__(self): + super().__init__() + self._foreground_color: int = 0xFFFFFFFF + self._background_color: int = 0xFF000000 + self._edge_color: int = 0xFF000000 + self._edge_type: int = EDGE_TYPE_NONE + self._typeface: Optional[Any] = None + self._font_scale: float = 1.0 + self._window_color: int = 0xFF000000 + + @staticmethod + def getCustomStyle(css: Any) -> "CaptioningManager.CaptionStyle": + return CaptioningManager.CaptionStyle() + + def getForegroundColor(self) -> int: + return self._foreground_color + + def getBackgroundColor(self) -> int: + return self._background_color + + def getEdgeColor(self) -> int: + return self._edge_color + + def getEdgeType(self) -> int: + return self._edge_type + + def getTypeface(self) -> Optional[Any]: + return self._typeface + + def hasForegroundColor(self) -> bool: + return True + + def hasBackgroundColor(self) -> bool: + return True + + def hasEdgeColor(self) -> bool: + return True + + def hasEdgeType(self) -> bool: + return True + + def hasWindowColor(self) -> bool: + return True + + def getWindowColor(self) -> int: + return self._window_color + + def __init__(self): + super().__init__() + self._enabled: bool = False + self._locale: Optional[str] = None + self._font_scale: float = 1.0 + self._user_style: Optional["CaptioningManager.CaptionStyle"] = None + + def isCaptioningEnabled(self) -> bool: + return self._enabled + + def getLocale(self) -> Optional[str]: + return self._locale + + def getFontScale(self) -> float: + return self._font_scale + + def getUserStyle(self) -> "CaptioningManager.CaptionStyle": + if self._user_style is None: + self._user_style = CaptioningManager.CaptionStyle() + return self._user_style + + def addCaptioningChangeListener(self, listener: Any): + pass + + def removeCaptioningChangeListener(self, listener: Any): + pass + + +# ═══════════════════════════════════════════════════════════════ +# AccessibilityServiceGestureResult +# ═══════════════════════════════════════════════════════════════ + +class AccessibilityServiceGestureResult(Stub): + """AccessibilityServiceGestureResult — 手势结果""" + + def __init__(self, completed: bool): + super().__init__() + self._completed: bool = completed + + def isCompleted(self) -> bool: + return self._completed + + +# ═══════════════════════════════════════════════════════════════ +# TouchExplorationStateChangeListener +# ═══════════════════════════════════════════════════════════════ + +class TouchExplorationStateChangeListener(Stub): + """TouchExplorationStateChangeListener — 触摸探索状态变更监听器""" + + def onTouchExplorationStateChanged(self, enabled: bool): + pass + + +# ═══════════════════════════════════════════════════════════════ +# AccessibilityButtonController +# ═══════════════════════════════════════════════════════════════ + +class AccessibilityButtonController(Stub): + """AccessibilityButtonController — 无障碍按钮控制器""" + + class AccessibilityButtonCallback(Stub): + """AccessibilityButtonCallback — 无障碍按钮回调""" + + def onAvailabilityChanged(self, available: bool): + pass + + def onClicked(self, controller: "AccessibilityButtonController"): + pass + + def __init__(self): + super().__init__() + self._callback: Optional["AccessibilityButtonController.AccessibilityButtonCallback"] = None + + def isAccessibilityButtonAvailable(self) -> bool: + return False + + def registerAccessibilityButtonCallback(self, callback: "AccessibilityButtonController.AccessibilityButtonCallback"): + self._callback = callback + + def unregisterAccessibilityButtonCallback(self, callback: "AccessibilityButtonController.AccessibilityButtonCallback"): + if self._callback == callback: + self._callback = None + + def performAccessibilityButtonAction(self) -> bool: + if self._callback: + self._callback.onClicked(self) + return True + return False + + +# ═══════════════════════════════════════════════════════════════ +# AccessibilityButtonControllerCallback +# ═══════════════════════════════════════════════════════════════ + +class AccessibilityButtonControllerCallback(Stub): + """AccessibilityButtonControllerCallback — 别名""" + + def onAvailabilityChanged(self, available: bool): + pass + + def onClicked(self, controller: AccessibilityButtonController): + pass + + +# ═══════════════════════════════════════════════════════════════ +# MagnificationConfig +# ═══════════════════════════════════════════════════════════════ + +class MagnificationConfig(Stub): + """MagnificationConfig — 放大配置""" + + SCALE = 0 + CENTER_X = 1 + CENTER_Y = 2 + ALL = -1 + + def __init__(self): + super().__init__() + self._scale: float = 1.0 + self._center_x: float = 0.0 + self._center_y: float = 0.0 + self._mode: int = 0 + self._frame_left: float = 0.0 + self._frame_top: float = 0.0 + self._frame_right: float = 0.0 + self._frame_bottom: float = 0.0 + + def getScale(self) -> float: + return self._scale + + def setScale(self, scale: float): + self._scale = scale + + def getCenterX(self) -> float: + return self._center_x + + def setCenterX(self, center_x: float): + self._center_x = center_x + + def getCenterY(self) -> float: + return self._center_y + + def setCenterY(self, center_y: float): + self._center_y = center_y + + def getMode(self) -> int: + return self._mode + + def setMode(self, mode: int): + self._mode = mode + + def toString(self) -> str: + return (f"MagnificationConfig(scale={self._scale}, " + f"center=({self._center_x}, {self._center_y}))") + + +# ═══════════════════════════════════════════════════════════════ +# MagnificationController +# ═══════════════════════════════════════════════════════════════ + +class MagnificationController(Stub): + """MagnificationController — 放大控制器""" + + class OnMagnificationChangedListener(Stub): + def onMagnificationChanged(self, controller: "MagnificationController", + region: Any, scale: float, center_x: float, center_y: float): + pass + + def __init__(self): + super().__init__() + self._listeners: List["MagnificationController.OnMagnificationChangedListener"] = [] + self._scale: float = 1.0 + self._center_x: float = 0.0 + self._center_y: float = 0.0 + self._magnification_region: Any = None + + def getScale(self) -> float: + return self._scale + + def getCenterX(self) -> float: + return self._center_x + + def getCenterY(self) -> float: + return self._center_y + + def getMagnificationRegion(self) -> Any: + return self._magnification_region + + def setScale(self, scale: float, animate: bool = False) -> bool: + self._scale = scale + self._notifyListeners() + return True + + def setCenter(self, center_x: float, center_y: float, animate: bool = False) -> bool: + self._center_x = center_x + self._center_y = center_y + self._notifyListeners() + return True + + def addListener(self, listener: "MagnificationController.OnMagnificationChangedListener"): + if listener not in self._listeners: + self._listeners.append(listener) + + def removeListener(self, listener: "MagnificationController.OnMagnificationChangedListener"): + if listener in self._listeners: + self._listeners.remove(listener) + + def _notifyListeners(self): + for listener in list(self._listeners): + try: + listener.onMagnificationChanged(self, self._magnification_region, + self._scale, self._center_x, self._center_y) + except Exception: + pass + + def isMagnifying(self) -> bool: + return abs(self._scale - 1.0) > 0.01 + + def reset(self, animate: bool = False) -> bool: + if self.isMagnifying(): + self._scale = 1.0 + self._center_x = 0.0 + self._center_y = 0.0 + self._notifyListeners() + return True + return False + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "AccessibilityEvent", "AccessibilityRecord", + "AccessibilityNodeInfo", "AccessibilityNodeProvider", + "AccessibilityService", "AccessibilityServiceInfo", + "AccessibilityWindowInfo", + "CaptioningManager", + "AccessibilityManager", + "AccessibilityServiceGestureResult", + "TouchExplorationStateChangeListener", + "AccessibilityButtonController", + "AccessibilityButtonControllerCallback", + "MagnificationConfig", + "MagnificationController", +] \ No newline at end of file diff --git a/android_pyapi/android/view_animation.py b/android_pyapi/android/view_animation.py new file mode 100644 index 0000000..1c703ea --- /dev/null +++ b/android_pyapi/android/view_animation.py @@ -0,0 +1,935 @@ +""" +Android View Animation 组件 — Animation, AnimationSet, Interpolators, +AnimationUtils, Transformation 等 +方法签名完全对齐 Android SDK +""" + +import math +import sys +import time +from typing import Any, Callable, Dict, List, Optional, Tuple + +from .._core import Stub, AndroidOnlyError, android_context + + +# ═══════════════════════════════════════════════════════════════ +# Interpolator +# ═══════════════════════════════════════════════════════════════ + +class Interpolator(Stub): + """Interpolator — 插值器接口""" + + def getInterpolation(self, input: float) -> float: + return input + + +# ═══════════════════════════════════════════════════════════════ +# AccelerateInterpolator +# ═══════════════════════════════════════════════════════════════ + +class AccelerateInterpolator(Interpolator): + """AccelerateInterpolator — 加速插值器（先慢后快）""" + + def __init__(self, factor: float = 1.0): + super().__init__() + self._factor = factor + self._double_factor = 2.0 * factor + + def getInterpolation(self, input: float) -> float: + if self._factor == 1.0: + return input * input + return input ** (self._double_factor) + + +# ═══════════════════════════════════════════════════════════════ +# DecelerateInterpolator +# ═══════════════════════════════════════════════════════════════ + +class DecelerateInterpolator(Interpolator): + """DecelerateInterpolator — 减速插值器（先快后慢）""" + + def __init__(self, factor: float = 1.0): + super().__init__() + self._factor = factor + + def getInterpolation(self, input: float) -> float: + if self._factor == 1.0: + return 1.0 - (1.0 - input) * (1.0 - input) + return 1.0 - (1.0 - input) ** (2.0 * self._factor) + + +# ═══════════════════════════════════════════════════════════════ +# AccelerateDecelerateInterpolator +# ═══════════════════════════════════════════════════════════════ + +class AccelerateDecelerateInterpolator(Interpolator): + """AccelerateDecelerateInterpolator — 加速减速插值器""" + + def getInterpolation(self, input: float) -> float: + return float(math.cos((input + 1) * math.pi) / 2.0 + 0.5) + + +# ═══════════════════════════════════════════════════════════════ +# LinearInterpolator +# ═══════════════════════════════════════════════════════════════ + +class LinearInterpolator(Interpolator): + """LinearInterpolator — 线性插值器""" + + def getInterpolation(self, input: float) -> float: + return input + + +# ═══════════════════════════════════════════════════════════════ +# OvershootInterpolator +# ═══════════════════════════════════════════════════════════════ + +class OvershootInterpolator(Interpolator): + """OvershootInterpolator — 超出插值器（越过目标再回弹）""" + + def __init__(self, tension: float = 2.0): + super().__init__() + self._tension = tension + + def getInterpolation(self, input: float) -> float: + input -= 1.0 + return input * input * ((self._tension + 1) * input + self._tension) + 1.0 + + +# ═══════════════════════════════════════════════════════════════ +# AnticipateInterpolator +# ═══════════════════════════════════════════════════════════════ + +class AnticipateInterpolator(Interpolator): + """AnticipateInterpolator — 预判插值器（先反向后正向前进）""" + + def __init__(self, tension: float = 2.0): + super().__init__() + self._tension = tension + + def getInterpolation(self, input: float) -> float: + return input * input * ((self._tension + 1) * input - self._tension) + + +# ═══════════════════════════════════════════════════════════════ +# AnticipateOvershootInterpolator +# ═══════════════════════════════════════════════════════════════ + +class AnticipateOvershootInterpolator(Interpolator): + """AnticipateOvershootInterpolator — 预判超出插值器""" + + def __init__(self, tension: float = 2.0, extra_tension: float = 1.5): + super().__init__() + self._tension = tension + self._extra_tension = extra_tension + + def getInterpolation(self, input: float) -> float: + if input < 0.5: + t = input * 2.0 + return 0.5 * t * t * ((self._tension + 1) * t - self._tension) + else: + t = input * 2.0 - 2.0 + return 0.5 * (t * t * ((self._tension + 1) * t + self._tension) + 2.0) + + +# ═══════════════════════════════════════════════════════════════ +# BounceInterpolator +# ═══════════════════════════════════════════════════════════════ + +class BounceInterpolator(Interpolator): + """BounceInterpolator — 弹跳插值器""" + + @staticmethod + def _bounce(t: float) -> float: + t2 = t * t + return t2 * 8.0 + + def getInterpolation(self, input: float) -> float: + if input < 0.3535: + return BounceInterpolator._bounce(input) + elif input < 0.7408: + return BounceInterpolator._bounce(input - 0.54719) + 0.7 + elif input < 0.9644: + return BounceInterpolator._bounce(input - 0.8526) + 0.9 + else: + return BounceInterpolator._bounce(input - 1.0435) + 0.95 + + +# ═══════════════════════════════════════════════════════════════ +# CycleInterpolator +# ═══════════════════════════════════════════════════════════════ + +class CycleInterpolator(Interpolator): + """CycleInterpolator — 周期插值器（正弦循环）""" + + def __init__(self, cycles: float = 1.0): + super().__init__() + self._cycles = cycles + + def getInterpolation(self, input: float) -> float: + return float(math.sin(2.0 * math.pi * self._cycles * input)) + + +# ═══════════════════════════════════════════════════════════════ +# PathInterpolator +# ═══════════════════════════════════════════════════════════════ + +class PathInterpolator(Interpolator): + """PathInterpolator — 路径插值器""" + + def __init__(self, control_x1: float = 0.0, control_y1: float = 0.0, + control_x2: float = 1.0, control_y2: float = 1.0): + super().__init__() + self._control_x1 = control_x1 + self._control_y1 = control_y1 + self._control_x2 = control_x2 + self._control_y2 = control_y2 + + def getInterpolation(self, input: float) -> float: + return self._cubic_bezier(input) + + def _cubic_bezier(self, t: float) -> float: + u = 1.0 - t + return (3.0 * u * u * t * self._control_y1 + + 3.0 * u * t * t * self._control_y2 + + t * t * t) + + +# ═══════════════════════════════════════════════════════════════ +# Transformation +# ═══════════════════════════════════════════════════════════════ + +class Transformation(Stub): + """Transformation — 动画变换矩阵""" + + TYPE_IDENTITY = 0 + TYPE_ALPHA = 1 + TYPE_BOTH = 2 + + def __init__(self): + super().__init__() + self._alpha: float = 1.0 + self._matrix: Any = None # 占位，实际 Android 为 Matrix 对象 + self._transformation_type: int = Transformation.TYPE_IDENTITY + + def getAlpha(self) -> float: + return self._alpha + + def setAlpha(self, alpha: float): + self._alpha = alpha + + def getMatrix(self) -> Any: + return self._matrix + + def setMatrix(self, matrix: Any): + self._matrix = matrix + + def setTransformationType(self, transformation_type: int): + self._transformation_type = transformation_type + + def getTransformationType(self) -> int: + return self._transformation_type + + def clear(self): + self._alpha = 1.0 + self._matrix = None + self._transformation_type = Transformation.TYPE_IDENTITY + + def compose(self, other: "Transformation"): + if other is None: + return + self._alpha *= other._alpha + if self._matrix is None: + self._matrix = other._matrix + elif other._matrix is not None: + pass # 占位：矩阵乘法 + self._transformation_type = max(self._transformation_type, + other._transformation_type) + + def toString(self) -> str: + return (f"Transformation(alpha={self._alpha}, " + f"type={self._transformation_type})") + + +# ═══════════════════════════════════════════════════════════════ +# Animation +# ═══════════════════════════════════════════════════════════════ + +class Animation(Stub): + """Animation — 动画基类""" + + INFINITE = -1 + RESTART = 1 + REVERSE = 2 + + ABSOLUTE = 0 + RELATIVE_TO_SELF = 1 + RELATIVE_TO_PARENT = 2 + + START_ON_FIRST_FRAME = -1 + + class AnimationListener(Stub): + """AnimationListener — 动画监听器""" + + def onAnimationStart(self, animation: "Animation"): + pass + + def onAnimationEnd(self, animation: "Animation"): + pass + + def onAnimationRepeat(self, animation: "Animation"): + pass + + def __init__(self): + super().__init__() + self._duration: int = 0 + self._start_offset: int = 0 + self._repeat_count: int = 0 + self._repeat_mode: int = Animation.RESTART + self._fill_before: bool = False + self._fill_after: bool = False + self._fill_enabled: bool = False + self._z_adjustment: int = 0 + self._interpolator: Optional[Interpolator] = None + self._listener: Optional["Animation.AnimationListener"] = None + self._start_time: Optional[int] = None + self._started: bool = False + self._ended: bool = False + self._cycle: float = 0.0 + self._current_repeat: int = 0 + self._initialized: bool = False + self._scale_factor: float = 1.0 + self._paused: bool = False + self._more: bool = True + + def start(self): + self._start_time = self._current_time_millis() + self._started = True + self._ended = False + self._current_repeat = 0 + self._more = True + if self._listener: + self._listener.onAnimationStart(self) + + def startNow(self): + self.start() + + def cancel(self): + self._ended = True + self._more = False + + def reset(self): + self._start_time = None + self._started = False + self._ended = False + self._current_repeat = 0 + self._cycle = 0.0 + self._more = True + self._initialized = False + + def setDuration(self, duration_millis: int): + self._duration = duration_millis + + def getDuration(self) -> int: + return self._duration + + def setStartOffset(self, start_offset: int): + self._start_offset = start_offset + + def getStartOffset(self) -> int: + return self._start_offset + + def setRepeatCount(self, repeat_count: int): + self._repeat_count = repeat_count + + def getRepeatCount(self) -> int: + return self._repeat_count + + def setRepeatMode(self, repeat_mode: int): + self._repeat_mode = repeat_mode + + def getRepeatMode(self) -> int: + return self._repeat_mode + + def setInterpolator(self, interpolator: Optional[Interpolator]): + self._interpolator = interpolator + + def getInterpolator(self) -> Optional[Interpolator]: + return self._interpolator + + def setAnimationListener(self, listener: "Animation.AnimationListener"): + self._listener = listener + + def getAnimationListener(self) -> Optional["Animation.AnimationListener"]: + return self._listener + + def getTransformation(self, current_time: int, + out_transformation: Transformation) -> bool: + if self._start_time is None: + self._start_time = current_time + + elapsed = current_time - self._start_time - self._start_offset + if elapsed < 0: + out_transformation.clear() + return True + + duration = self._duration + if duration == 0: + duration = 1 + + normalized = elapsed / duration + + if normalized >= 1.0: + if self._current_repeat < self._repeat_count or self._repeat_count == self.INFINITE: + if self._repeat_mode == Animation.REVERSE: + normalized = 0.0 + else: + normalized = 0.0 + self._current_repeat += 1 + if self._listener: + self._listener.onAnimationRepeat(self) + else: + normalized = 1.0 + self._ended = True + self._more = False + self._apply_transformation(1.0, out_transformation) + if self._listener: + self._listener.onAnimationEnd(self) + return False + + if normalized > 1.0: + normalized = 1.0 + + if self._interpolator: + interpolated = self._interpolator.getInterpolation(normalized) + else: + interpolated = normalized + + self._cycle = normalized + self._apply_transformation(interpolated, out_transformation) + return self._more + + def _apply_transformation(self, interpolated_time: float, t: Transformation): + pass + + def hasEnded(self) -> bool: + return self._ended + + def hasStarted(self) -> bool: + return self._started + + def setFillBefore(self, fill_before: bool): + self._fill_before = fill_before + + def getFillBefore(self) -> bool: + return self._fill_before + + def setFillAfter(self, fill_after: bool): + self._fill_after = fill_after + + def getFillAfter(self) -> bool: + return self._fill_after + + def setFillEnabled(self, fill_enabled: bool): + self._fill_enabled = fill_enabled + + def getFillEnabled(self) -> bool: + return self._fill_enabled + + def setZAdjustment(self, z_adjustment: int): + self._z_adjustment = z_adjustment + + def getZAdjustment(self) -> int: + return self._z_adjustment + + def willChangeBounds(self) -> bool: + return True + + def willChangeTransformationMatrix(self) -> bool: + return True + + def initialize(self, width: int, height: int, parent_width: int, parent_height: int): + self._initialized = True + + def restrictDuration(self, duration_millis: int): + if self._duration > duration_millis: + self._duration = duration_millis + + def scaleCurrentDuration(self, scale: float): + self._duration = int(self._duration * scale) + + @staticmethod + def _current_time_millis() -> int: + return int(time.time() * 1000) + + def toString(self) -> str: + return (f"Animation(duration={self._duration}, " + f"repeatCount={self._repeat_count}, " + f"started={self._started})") + + +# ═══════════════════════════════════════════════════════════════ +# AlphaAnimation +# ═══════════════════════════════════════════════════════════════ + +class AlphaAnimation(Animation): + """AlphaAnimation — 透明度动画""" + + def __init__(self, from_alpha: float, to_alpha: float): + super().__init__() + self._from_alpha = from_alpha + self._to_alpha = to_alpha + + def _apply_transformation(self, interpolated_time: float, t: Transformation): + alpha = self._from_alpha + (self._to_alpha - self._from_alpha) * interpolated_time + t.setAlpha(alpha) + + def getFromAlpha(self) -> float: + return self._from_alpha + + def getToAlpha(self) -> float: + return self._to_alpha + + +# ═══════════════════════════════════════════════════════════════ +# ScaleAnimation +# ═══════════════════════════════════════════════════════════════ + +class ScaleAnimation(Animation): + """ScaleAnimation — 缩放动画""" + + def __init__(self, from_x: float, to_x: float, from_y: float, to_y: float, + pivot_x: float = 0.0, pivot_y: float = 0.0, + pivot_x_type: int = Animation.ABSOLUTE, + pivot_y_type: int = Animation.ABSOLUTE): + super().__init__() + self._from_x = from_x + self._to_x = to_x + self._from_y = from_y + self._to_y = to_y + self._pivot_x = pivot_x + self._pivot_y = pivot_y + self._pivot_x_type = pivot_x_type + self._pivot_y_type = pivot_y_type + + def _apply_transformation(self, interpolated_time: float, t: Transformation): + sx = self._from_x + (self._to_x - self._from_x) * interpolated_time + sy = self._from_y + (self._to_y - self._from_y) * interpolated_time + # 占位：Matrix 的缩放操作 + if t.getMatrix() is not None: + pass + + def getFromX(self) -> float: + return self._from_x + + def getToX(self) -> float: + return self._to_x + + def getFromY(self) -> float: + return self._from_y + + def getToY(self) -> float: + return self._to_y + + def getPivotX(self) -> float: + return self._pivot_x + + def getPivotY(self) -> float: + return self._pivot_y + + +# ═══════════════════════════════════════════════════════════════ +# TranslateAnimation +# ═══════════════════════════════════════════════════════════════ + +class TranslateAnimation(Animation): + """TranslateAnimation — 平移动画""" + + def __init__(self, from_x: float, to_x: float, from_y: float, to_y: float, + from_x_type: int = Animation.ABSOLUTE, + to_x_type: int = Animation.ABSOLUTE, + from_y_type: int = Animation.ABSOLUTE, + to_y_type: int = Animation.ABSOLUTE): + super().__init__() + self._from_x = from_x + self._to_x = to_x + self._from_y = from_y + self._to_y = to_y + self._from_x_type = from_x_type + self._to_x_type = to_x_type + self._from_y_type = from_y_type + self._to_y_type = to_y_type + + def _apply_transformation(self, interpolated_time: float, t: Transformation): + dx = self._from_x + (self._to_x - self._from_x) * interpolated_time + dy = self._from_y + (self._to_y - self._from_y) * interpolated_time + if t.getMatrix() is not None: + pass + + def getFromX(self) -> float: + return self._from_x + + def getToX(self) -> float: + return self._to_x + + def getFromY(self) -> float: + return self._from_y + + def getToY(self) -> float: + return self._to_y + + +# ═══════════════════════════════════════════════════════════════ +# RotateAnimation +# ═══════════════════════════════════════════════════════════════ + +class RotateAnimation(Animation): + """RotateAnimation — 旋转动画""" + + def __init__(self, from_degrees: float, to_degrees: float, + pivot_x: float = 0.0, pivot_y: float = 0.0, + pivot_x_type: int = Animation.ABSOLUTE, + pivot_y_type: int = Animation.ABSOLUTE): + super().__init__() + self._from_degrees = from_degrees + self._to_degrees = to_degrees + self._pivot_x = pivot_x + self._pivot_y = pivot_y + self._pivot_x_type = pivot_x_type + self._pivot_y_type = pivot_y_type + + def _apply_transformation(self, interpolated_time: float, t: Transformation): + degrees = self._from_degrees + (self._to_degrees - self._from_degrees) * interpolated_time + if t.getMatrix() is not None: + pass + + def getFromDegrees(self) -> float: + return self._from_degrees + + def getToDegrees(self) -> float: + return self._to_degrees + + def getPivotX(self) -> float: + return self._pivot_x + + def getPivotY(self) -> float: + return self._pivot_y + + +# ═══════════════════════════════════════════════════════════════ +# AnimationSet +# ═══════════════════════════════════════════════════════════════ + +class AnimationSet(Animation): + """AnimationSet — 动画集合""" + + def __init__(self, share_interpolator: bool = True): + super().__init__() + self._share_interpolator = share_interpolator + self._animations: List[Animation] = [] + + def addAnimation(self, animation: Animation): + self._animations.append(animation) + if self._share_interpolator and self._interpolator: + animation.setInterpolator(self._interpolator) + + def getAnimations(self) -> List[Animation]: + return list(self._animations) + + def setDuration(self, duration_millis: int): + super().setDuration(duration_millis) + for anim in self._animations: + anim.setDuration(duration_millis) + + def setFillAfter(self, fill_after: bool): + super().setFillAfter(fill_after) + for anim in self._animations: + anim.setFillAfter(fill_after) + + def setFillBefore(self, fill_before: bool): + super().setFillBefore(fill_before) + for anim in self._animations: + anim.setFillBefore(fill_before) + + def setRepeatMode(self, repeat_mode: int): + super().setRepeatMode(repeat_mode) + for anim in self._animations: + anim.setRepeatMode(repeat_mode) + + def setRepeatCount(self, repeat_count: int): + super().setRepeatCount(repeat_count) + for anim in self._animations: + anim.setRepeatCount(repeat_count) + + def setStartOffset(self, start_offset: int): + super().setStartOffset(start_offset) + for anim in self._animations: + anim.setStartOffset(start_offset) + + def setInterpolator(self, interpolator: Optional[Interpolator]): + super().setInterpolator(interpolator) + if self._share_interpolator: + for anim in self._animations: + anim.setInterpolator(interpolator) + + def start(self): + super().start() + for anim in self._animations: + anim.start() + + def reset(self): + super().reset() + for anim in self._animations: + anim.reset() + + def cancel(self): + super().cancel() + for anim in self._animations: + anim.cancel() + + def getTransformation(self, current_time: int, + out_transformation: Transformation) -> bool: + more = False + for anim in self._animations: + local_t = Transformation() + if anim.getTransformation(current_time, local_t): + more = True + out_transformation.compose(local_t) + return more + + def initialize(self, width: int, height: int, parent_width: int, parent_height: int): + super().initialize(width, height, parent_width, parent_height) + for anim in self._animations: + anim.initialize(width, height, parent_width, parent_height) + + def willChangeBounds(self) -> bool: + for anim in self._animations: + if anim.willChangeBounds(): + return True + return False + + def willChangeTransformationMatrix(self) -> bool: + for anim in self._animations: + if anim.willChangeTransformationMatrix(): + return True + return False + + def getAnimations(self) -> List[Animation]: + return list(self._animations) + + def restrictDuration(self, duration_millis: int): + super().restrictDuration(duration_millis) + for anim in self._animations: + anim.restrictDuration(duration_millis) + + def scaleCurrentDuration(self, scale: float): + super().scaleCurrentDuration(scale) + for anim in self._animations: + anim.scaleCurrentDuration(scale) + + +# ═══════════════════════════════════════════════════════════════ +# Animation.AnimationListener (已定义在 Animation 类中) +# ═══════════════════════════════════════════════════════════════ + +# Animation.AnimationListener is defined inside the Animation class above + + +# ═══════════════════════════════════════════════════════════════ +# AnimationUtils +# ═══════════════════════════════════════════════════════════════ + +class AnimationUtils(Stub): + """AnimationUtils — 动画工具类""" + + @staticmethod + def loadAnimation(context: Any, id: int) -> Animation: + """加载动画资源（占位实现）""" + sys.stderr.write(f"[AnimationUtils] loadAnimation: id={id}\n") + return Animation() + + @staticmethod + def makeInAnimation(context: Any, from_left: bool) -> Animation: + """创建进入动画""" + anim = AlphaAnimation(0.0, 1.0) + anim.setDuration(300) + return anim + + @staticmethod + def makeOutAnimation(context: Any, to_left: bool) -> Animation: + """创建退出动画""" + anim = AlphaAnimation(1.0, 0.0) + anim.setDuration(300) + return anim + + @staticmethod + def makeInChildBottomAnimation(context: Any) -> Animation: + """创建子视图从底部进入动画""" + anim = TranslateAnimation(0, 0, 1.0, 0.0, + from_x_type=Animation.RELATIVE_TO_SELF, + to_x_type=Animation.RELATIVE_TO_SELF, + from_y_type=Animation.RELATIVE_TO_SELF, + to_y_type=Animation.RELATIVE_TO_SELF) + anim.setDuration(300) + return anim + + @staticmethod + def currentAnimationTimeMillis() -> int: + return int(time.time() * 1000) + + +# ═══════════════════════════════════════════════════════════════ +# LayoutAnimationController +# ═══════════════════════════════════════════════════════════════ + +class LayoutAnimationController(Stub): + """LayoutAnimationController — 布局动画控制器""" + + ORDER_NORMAL = 0 + ORDER_REVERSE = 1 + ORDER_RANDOM = 2 + + def __init__(self, animation: Optional[Animation] = None): + super().__init__() + self._animation: Optional[Animation] = animation + self._delay: float = 0.5 + self._order: int = LayoutAnimationController.ORDER_NORMAL + self._initialized: bool = False + self._max_delay: int = 0 + + def setAnimation(self, animation: Animation): + self._animation = animation + + def getAnimation(self) -> Optional[Animation]: + return self._animation + + def setOrder(self, order: int): + self._order = order + + def getOrder(self) -> int: + return self._order + + def setDelay(self, delay: float): + self._delay = delay + + def getDelay(self) -> float: + return self._delay + + def getDelayForView(self, view: Any) -> int: + if self._order == LayoutAnimationController.ORDER_NORMAL: + return 0 + elif self._order == LayoutAnimationController.ORDER_REVERSE: + return 0 + elif self._order == LayoutAnimationController.ORDER_RANDOM: + import random + return int(random.random() * self._max_delay) + return 0 + + def willOverlap(self) -> bool: + return self._delay < 1.0 + + def start(self): + self._initialized = True + + def isDone(self) -> bool: + return True + + def getAnimationForView(self, view: Any) -> Optional[Animation]: + return self._animation + + def setInitialized(self, initialized: bool): + self._initialized = initialized + + +# ═══════════════════════════════════════════════════════════════ +# GridLayoutAnimationController +# ═══════════════════════════════════════════════════════════════ + +class GridLayoutAnimationController(LayoutAnimationController): + """GridLayoutAnimationController — 网格布局动画控制器""" + + DIRECTION_LEFT_TO_RIGHT = 0x0 + DIRECTION_RIGHT_TO_LEFT = 0x1 + DIRECTION_TOP_TO_BOTTOM = 0x2 + DIRECTION_BOTTOM_TO_TOP = 0x3 + DIRECTION_HORIZONTAL_MASK = 0x1 + DIRECTION_VERTICAL_MASK = 0x2 + + def __init__(self, animation: Optional[Animation] = None): + super().__init__(animation) + self._column_delay: float = 0.5 + self._row_delay: float = 0.5 + self._direction: int = GridLayoutAnimationController.DIRECTION_LEFT_TO_RIGHT + self._columns: int = 1 + self._rows: int = 1 + + def setColumnDelay(self, column_delay: float): + self._column_delay = column_delay + + def getColumnDelay(self) -> float: + return self._column_delay + + def setRowDelay(self, row_delay: float): + self._row_delay = row_delay + + def getRowDelay(self) -> float: + return self._row_delay + + def setDirection(self, direction: int): + self._direction = direction + + def getDirection(self) -> int: + return self._direction + + def setColumns(self, columns: int): + self._columns = columns + + def getColumns(self) -> int: + return self._columns + + def setRows(self, rows: int): + self._rows = rows + + def getRows(self) -> int: + return self._rows + + def getDelayForView(self, view: Any) -> int: + duration = 0 + if self._animation: + duration = self._animation.getDuration() + return int(duration * self._column_delay) + + def willOverlap(self) -> bool: + return self._column_delay < 1.0 or self._row_delay < 1.0 + + def getAnimationForView(self, view: Any) -> Optional[Animation]: + return self._animation + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "Animation", + "AnimationSet", + "AlphaAnimation", + "ScaleAnimation", + "TranslateAnimation", + "RotateAnimation", + "AnimationUtils", + "Interpolator", + "AccelerateInterpolator", + "DecelerateInterpolator", + "AccelerateDecelerateInterpolator", + "LinearInterpolator", + "OvershootInterpolator", + "AnticipateInterpolator", + "AnticipateOvershootInterpolator", + "BounceInterpolator", + "CycleInterpolator", + "PathInterpolator", + "Transformation", + "LayoutAnimationController", + "GridLayoutAnimationController", +] \ No newline at end of file diff --git a/android_pyapi/android/view_inputmethod.py b/android_pyapi/android/view_inputmethod.py new file mode 100644 index 0000000..4da8dab --- /dev/null +++ b/android_pyapi/android/view_inputmethod.py @@ -0,0 +1,859 @@ +""" +Android View InputMethod 组件 — InputMethodManager, EditorInfo, +InputConnection, ExtractedText 等 +方法签名完全对齐 Android SDK +""" + +import sys +from typing import Any, Dict, List, Optional, Tuple + +from .._core import Stub, AndroidOnlyError, android_context + + +# ═══════════════════════════════════════════════════════════════ +# InputMethodManager +# ═══════════════════════════════════════════════════════════════ + +class InputMethodManager(Stub): + """InputMethodManager — 输入法管理器""" + + SHOW_IMPLICIT = 0x0001 + SHOW_FORCED = 0x0002 + HIDE_IMPLICIT_ONLY = 0x0001 + HIDE_NOT_ALWAYS = 0x0002 + RESULT_SHOWN = 2 + RESULT_HIDDEN = 3 + RESULT_UNCHANGED_SHOWN = 4 + RESULT_UNCHANGED_HIDDEN = 5 + + def __init__(self): + super().__init__() + self._active: bool = False + self._current_input_connection: Optional["InputConnection"] = None + self._is_accepting_text: bool = True + self._fullscreen_mode: bool = False + self._cursor_x: int = 0 + self._cursor_y: int = 0 + self._selection_start: int = -1 + self._selection_end: int = -1 + self._composing_start: int = -1 + self._composing_end: int = -1 + + def showSoftInput(self, view: Any, flags: int, + result_receiver: Any = None) -> bool: + self._active = True + sys.stderr.write(f"[InputMethodManager] showSoftInput: flags={flags}\n") + return True + + def hideSoftInputFromWindow(self, window_token: Any, flags: int, + result_receiver: Any = None) -> bool: + self._active = False + sys.stderr.write(f"[InputMethodManager] hideSoftInputFromWindow: flags={flags}\n") + return True + + def toggleSoftInput(self, show_flags: int, hide_flags: int): + self._active = not self._active + sys.stderr.write(f"[InputMethodManager] toggleSoftInput: " + f"show={show_flags}, hide={hide_flags}\n") + + def restartInput(self, view: Any): + sys.stderr.write("[InputMethodManager] restartInput\n") + + def startInput(self, view: Any) -> bool: + sys.stderr.write("[InputMethodManager] startInput\n") + return True + + def updateSelection(self, view: Any, sel_start: int, sel_end: int, + composing_start: int, composing_end: int): + self._selection_start = sel_start + self._selection_end = sel_end + self._composing_start = composing_start + self._composing_end = composing_end + + def updateCursorAnchorInfo(self, view: Any, cursor_anchor_info: "CursorAnchorInfo"): + self._cursor_x = cursor_anchor_info.getInsertionMarkerBaseline() + self._cursor_y = cursor_anchor_info.getInsertionMarkerTop() + + def displayCompletions(self, view: Any, completions: List["CompletionInfo"]): + sys.stderr.write(f"[InputMethodManager] displayCompletions: " + f"{len(completions) if completions else 0} items\n") + + def sendKeyChar(self, key_char: str): + sys.stderr.write(f"[InputMethodManager] sendKeyChar: '{key_char}'\n") + + def clearMetaKeyStates(self, view: Any, states: int): + sys.stderr.write(f"[InputMethodManager] clearMetaKeyStates: {states}\n") + + def isAcceptingText(self) -> bool: + return self._is_accepting_text + + def isActive(self) -> bool: + return self._active + + def isFullscreenMode(self) -> bool: + return self._fullscreen_mode + + def setFullscreenMode(self, fullscreen: bool): + self._fullscreen_mode = fullscreen + + def getCurrentInputMethodSubtype(self) -> Optional["InputMethodSubtype"]: + return None + + def getShortcutInputMethodsAndSubtypes(self) -> List[Any]: + return [] + + def showStatusIcon(self, icon: Any): + pass + + def hideStatusIcon(self): + pass + + def registerSuggestionSpansForNotification(self, spans: List[Any], sender: Any): + pass + + def notifySuggestionPicked(self, suggestion: Any): + pass + + def windowDismissed(self, window_token: Any): + self._active = False + + def toString(self) -> str: + return f"InputMethodManager(active={self._active})" + + +# ═══════════════════════════════════════════════════════════════ +# EditorInfo +# ═══════════════════════════════════════════════════════════════ + +class EditorInfo(Stub): + """EditorInfo — 编辑器信息""" + + TYPE_CLASS_TEXT = 0x0001 + TYPE_CLASS_NUMBER = 0x0002 + TYPE_CLASS_PHONE = 0x0004 + TYPE_CLASS_DATETIME = 0x0008 + + TYPE_TEXT_VARIATION_NORMAL = 0x0000 + TYPE_TEXT_VARIATION_URI = 0x0010 + TYPE_TEXT_VARIATION_EMAIL_ADDRESS = 0x0020 + TYPE_TEXT_VARIATION_EMAIL_SUBJECT = 0x0030 + TYPE_TEXT_VARIATION_SHORT_MESSAGE = 0x0040 + TYPE_TEXT_VARIATION_LONG_MESSAGE = 0x0050 + TYPE_TEXT_VARIATION_PERSON_NAME = 0x0060 + TYPE_TEXT_VARIATION_POSTAL_ADDRESS = 0x0070 + TYPE_TEXT_VARIATION_PASSWORD = 0x0080 + TYPE_TEXT_VARIATION_VISIBLE_PASSWORD = 0x0090 + TYPE_TEXT_VARIATION_WEB_EDIT_TEXT = 0x00A0 + TYPE_TEXT_VARIATION_FILTER = 0x00B0 + TYPE_TEXT_VARIATION_PHONETIC = 0x00C0 + TYPE_TEXT_VARIATION_WEB_EMAIL_ADDRESS = 0x00D0 + TYPE_TEXT_VARIATION_WEB_PASSWORD = 0x00E0 + + TYPE_NUMBER_VARIATION_NORMAL = 0x0000 + TYPE_NUMBER_VARIATION_PASSWORD = 0x0010 + + TYPE_DATETIME_VARIATION_NORMAL = 0x0000 + TYPE_DATETIME_VARIATION_DATE = 0x0010 + TYPE_DATETIME_VARIATION_TIME = 0x0020 + + TYPE_NULL = 0x0000 + + IME_ACTION_NONE = 0x0001 + IME_ACTION_GO = 0x0002 + IME_ACTION_SEARCH = 0x0003 + IME_ACTION_SEND = 0x0004 + IME_ACTION_NEXT = 0x0005 + IME_ACTION_DONE = 0x0006 + IME_ACTION_PREVIOUS = 0x0007 + + IME_FLAG_NO_EXTRACT_UI = 0x10000001 + IME_FLAG_NO_ACCESSORY_ACTION = 0x20000000 + IME_FLAG_NO_ENTER_ACTION = 0x40000000 + IME_FLAG_NAVIGATE_NEXT = 0x08000000 + IME_FLAG_NAVIGATE_PREVIOUS = 0x04000000 + IME_FLAG_NO_FULLSCREEN = 0x02000000 + IME_FLAG_FORCE_ASCII = 0x80000000 + + IME_MASK_ACTION = 0x000000FF + + def __init__(self): + super().__init__() + self.inputType: int = EditorInfo.TYPE_CLASS_TEXT + self.imeOptions: int = EditorInfo.IME_ACTION_NONE + self.actionLabel: Optional[str] = None + self.actionId: int = 0 + self.initialSelStart: int = -1 + self.initialSelEnd: int = -1 + self.initialCapsMode: int = 0 + self.hintText: Optional[str] = None + self.label: Optional[str] = None + self.packageName: Optional[str] = None + self.fieldId: int = 0 + self.fieldName: Optional[str] = None + self.extras: Optional[Any] = None + + def toString(self) -> str: + return (f"EditorInfo(inputType={hex(self.inputType)}, " + f"imeOptions={hex(self.imeOptions)}, " + f"actionLabel={self.actionLabel})") + + def dump(self, printer: Any, prefix: str): + sys.stderr.write(f"{prefix}EditorInfo: inputType={hex(self.inputType)}\n") + + +# ═══════════════════════════════════════════════════════════════ +# InputConnection +# ═══════════════════════════════════════════════════════════════ + +class InputConnection(Stub): + """InputConnection — 输入连接接口""" + + def __init__(self): + super().__init__() + self._text: str = "" + self._selection_start: int = 0 + self._selection_end: int = 0 + self._composing_start: int = -1 + self._composing_end: int = -1 + self._batch_edit_count: int = 0 + + def getTextBeforeCursor(self, length: int, flags: int) -> Optional[str]: + end = self._selection_start + start = max(0, end - length) + return self._text[start:end] + + def getTextAfterCursor(self, length: int, flags: int) -> Optional[str]: + start = self._selection_end + end = min(len(self._text), start + length) + return self._text[start:end] + + def getExtractedText(self, request: "ExtractedTextRequest", + flags: int) -> Optional["ExtractedText"]: + result = ExtractedText() + result.text = self._text + result.startOffset = 0 + result.selectionStart = self._selection_start + result.selectionEnd = self._selection_end + result.flags = 0 + return result + + def commitText(self, text: Any, new_cursor_position: int) -> bool: + if isinstance(text, str): + committed = text + else: + committed = str(text) if text else "" + + before = self._text[:self._selection_start] + after = self._text[self._selection_end:] + self._text = before + committed + after + + if new_cursor_position > 0: + self._selection_start = len(before) + new_cursor_position - 1 + else: + self._selection_start = len(before) + len(committed) + new_cursor_position + self._selection_end = self._selection_start + self._composing_start = -1 + self._composing_end = -1 + return True + + def setComposingText(self, text: Any, new_cursor_position: int) -> bool: + if self._composing_start < 0: + self._composing_start = self._selection_start + self._composing_end = self._selection_end + + before = self._text[:self._composing_start] + after = self._text[self._composing_end:] + + if isinstance(text, str): + composing = text + else: + composing = str(text) if text else "" + + self._text = before + composing + after + self._composing_end = self._composing_start + len(composing) + self._selection_start = self._composing_end + new_cursor_position + self._selection_end = self._selection_start + return True + + def setSelection(self, start: int, end: int) -> bool: + self._selection_start = max(0, min(start, len(self._text))) + self._selection_end = max(0, min(end, len(self._text))) + return True + + def deleteSurroundingText(self, before_length: int, after_length: int) -> bool: + start = max(0, self._selection_start - before_length) + end = min(len(self._text), self._selection_end + after_length) + self._text = self._text[:start] + self._text[end:] + new_cursor = max(0, self._selection_start - before_length) + self._selection_start = new_cursor + self._selection_end = new_cursor + return True + + def commitCompletion(self, completion: "CompletionInfo") -> bool: + sys.stderr.write(f"[InputConnection] commitCompletion: " + f"{completion.getText()}\n") + return True + + def commitCorrection(self, correction: "CorrectionInfo") -> bool: + sys.stderr.write(f"[InputConnection] commitCorrection: " + f"{correction.getNewText()}\n") + return True + + def getSelectedText(self, flags: int) -> Optional[str]: + if self._selection_start == self._selection_end: + return "" + return self._text[self._selection_start:self._selection_end] + + def finishComposingText(self) -> bool: + self._composing_start = -1 + self._composing_end = -1 + return True + + def beginBatchEdit(self) -> bool: + self._batch_edit_count += 1 + return True + + def endBatchEdit(self) -> bool: + if self._batch_edit_count > 0: + self._batch_edit_count -= 1 + return True + + def sendKeyEvent(self, event: Any) -> bool: + sys.stderr.write(f"[InputConnection] sendKeyEvent\n") + return True + + def clearMetaKeyStates(self, states: int) -> bool: + return True + + def performEditorAction(self, action_code: int) -> bool: + sys.stderr.write(f"[InputConnection] performEditorAction: {action_code}\n") + return True + + def performContextMenuAction(self, id: int) -> bool: + sys.stderr.write(f"[InputConnection] performContextMenuAction: {id}\n") + return True + + def commitContent(self, input_content: "InputContentInfo", + flags: int, opts: Optional[Any] = None) -> bool: + sys.stderr.write("[InputConnection] commitContent\n") + return True + + def requestCursorUpdates(self, cursor_update_mode: int) -> bool: + return True + + def closeConnection(self): + pass + + def reportFullscreenMode(self, enabled: bool): + pass + + def getSurroundingText(self, before_length: int, after_length: int, + flags: int) -> Optional["SurroundingText"]: + start = max(0, self._selection_start - before_length) + end = min(len(self._text), self._selection_end + after_length) + return SurroundingText( + text=self._text[start:end], + selection_start=self._selection_start - start, + selection_end=self._selection_end - start, + offset=start, + ) + + def takeSnapshot(self) -> Optional[Any]: + """获取输入快照""" + return None + + def setComposingRegion(self, start: int, end: int) -> bool: + self._composing_start = start + self._composing_end = end + return True + + def getCursorCapsMode(self, req_modes: int) -> int: + return 0 + + def getTextBeforeCursor(self, length: int, flags: int) -> Optional[str]: + end = self._selection_start + start = max(0, end - length) + return self._text[start:end] + + def getTextAfterCursor(self, length: int, flags: int) -> Optional[str]: + start = self._selection_end + end = min(len(self._text), start + length) + return self._text[start:end] + + +# ═══════════════════════════════════════════════════════════════ +# ExtractedText +# ═══════════════════════════════════════════════════════════════ + +class ExtractedText(Stub): + """ExtractedText — 提取的文本""" + + FLAG_SINGLE_LINE = 0x0001 + FLAG_SELECTING = 0x0002 + + def __init__(self): + super().__init__() + self.text: Optional[str] = None + self.startOffset: int = 0 + self.partialStartOffset: int = -1 + self.partialEndOffset: int = -1 + self.selectionStart: int = -1 + self.selectionEnd: int = -1 + self.flags: int = 0 + + def toString(self) -> str: + return (f"ExtractedText(startOffset={self.startOffset}, " + f"text={self.text}, " + f"selection=({self.selectionStart}, {self.selectionEnd}))") + + +# ═══════════════════════════════════════════════════════════════ +# ExtractedTextRequest +# ═══════════════════════════════════════════════════════════════ + +class ExtractedTextRequest(Stub): + """ExtractedTextRequest — 提取文本请求""" + + def __init__(self): + super().__init__() + self.token: int = 0 + self.flags: int = 0 + self.hintMaxLines: int = 0 + self.hintMaxChars: int = 0 + + +# ═══════════════════════════════════════════════════════════════ +# InputBinding +# ═══════════════════════════════════════════════════════════════ + +class InputBinding(Stub): + """InputBinding — 输入绑定""" + + def __init__(self, connection: Optional["InputConnection"] = None, + uid: int = -1, pid: int = -1, + private_ime_options: str = ""): + super().__init__() + self._connection: Optional["InputConnection"] = connection + self._uid: int = uid + self._pid: int = pid + self._private_ime_options: str = private_ime_options + + def getConnection(self) -> Optional["InputConnection"]: + return self._connection + + def getUid(self) -> int: + return self._uid + + def getPid(self) -> int: + return self._pid + + def getPrivateImeOptions(self) -> str: + return self._private_ime_options + + def toString(self) -> str: + return (f"InputBinding(uid={self._uid}, pid={self._pid}, " + f"connection={self._connection})") + + +# ═══════════════════════════════════════════════════════════════ +# InputMethodSubtype +# ═══════════════════════════════════════════════════════════════ + +class InputMethodSubtype(Stub): + """InputMethodSubtype — 输入法子类型""" + + SUBTYPE_ID_NONE = -1 + + def __init__(self, locale: str = "", mode: str = "", + extra_value: str = "", is_auxiliary: bool = False, + overrides_ime_theme: bool = False, + subtype_id: int = SUBTYPE_ID_NONE): + super().__init__() + self._locale: str = locale + self._mode: str = mode + self._extra_value: str = extra_value + self._is_auxiliary: bool = is_auxiliary + self._overrides_ime_theme: bool = overrides_ime_theme + self._subtype_id: int = subtype_id + self._display_name_res: int = 0 + self._icon_res: int = 0 + + def getLocale(self) -> str: + return self._locale + + def getMode(self) -> str: + return self._mode + + def getExtraValue(self) -> str: + return self._extra_value + + def getSubtypeId(self) -> int: + return self._subtype_id + + def containsExtraValueKey(self, key: str) -> bool: + if not self._extra_value: + return False + pairs = self._extra_value.split(",") + for pair in pairs: + kv = pair.split("=", 1) + if len(kv) == 2 and kv[0].strip() == key: + return True + return False + + def getDisplayName(self, context: Any, package_name: str, + app_info: Any) -> str: + return self._locale or self._mode + + def isAuxiliary(self) -> bool: + return self._is_auxiliary + + def overridesImeTheme(self) -> bool: + return self._overrides_ime_theme + + def hashCode(self) -> int: + return hash((self._locale, self._mode, self._extra_value)) & 0x7FFFFFFF + + def equals(self, other: Any) -> bool: + if isinstance(other, InputMethodSubtype): + return (self._locale == other._locale and + self._mode == other._mode and + self._extra_value == other._extra_value) + return False + + def toString(self) -> str: + return (f"InputMethodSubtype(locale={self._locale}, " + f"mode={self._mode})") + + +# ═══════════════════════════════════════════════════════════════ +# CursorAnchorInfo +# ═══════════════════════════════════════════════════════════════ + +class CursorAnchorInfo(Stub): + """CursorAnchorInfo — 光标锚点信息""" + + FLAG_HAS_VISIBLE_REGION = 0x01 + FLAG_IS_RTL = 0x02 + + def __init__(self): + super().__init__() + self._insertion_marker_baseline: float = 0.0 + self._insertion_marker_top: float = 0.0 + self._insertion_marker_bottom: float = 0.0 + self._matrix: Optional[Any] = None + self._character_bounds: Dict[int, Tuple[float, float, float, float]] = {} + self._character_bounds_flags: Dict[int, int] = {} + self._composing_text: Optional[str] = None + self._composing_text_start: int = -1 + + def getInsertionMarkerBaseline(self) -> float: + return self._insertion_marker_baseline + + def setInsertionMarkerBaseline(self, baseline: float): + self._insertion_marker_baseline = baseline + + def getInsertionMarkerTop(self) -> float: + return self._insertion_marker_top + + def setInsertionMarkerTop(self, top: float): + self._insertion_marker_top = top + + def getInsertionMarkerBottom(self) -> float: + return self._insertion_marker_bottom + + def setInsertionMarkerBottom(self, bottom: float): + self._insertion_marker_bottom = bottom + + def getMatrix(self) -> Optional[Any]: + return self._matrix + + def setMatrix(self, matrix: Any): + self._matrix = matrix + + def getCharacterBounds(self, index: int) -> Optional[Tuple[float, float, float, float]]: + return self._character_bounds.get(index) + + def setCharacterBounds(self, index: int, left: float, top: float, + right: float, bottom: float, flags: int): + self._character_bounds[index] = (left, top, right, bottom) + self._character_bounds_flags[index] = flags + + def getCharacterBoundsFlags(self, index: int) -> int: + return self._character_bounds_flags.get(index, 0) + + def getComposingText(self) -> Optional[str]: + return self._composing_text + + def getComposingTextStart(self) -> int: + return self._composing_text_start + + def toString(self) -> str: + return (f"CursorAnchorInfo(baseline={self._insertion_marker_baseline}, " + f"top={self._insertion_marker_top})") + + +# ═══════════════════════════════════════════════════════════════ +# CorrectionInfo +# ═══════════════════════════════════════════════════════════════ + +class CorrectionInfo(Stub): + """CorrectionInfo — 校正信息""" + + def __init__(self, old_text: str = "", new_text: str = ""): + super().__init__() + self._old_text: str = old_text + self._new_text: str = new_text + + def getOldText(self) -> str: + return self._old_text + + def getNewText(self) -> str: + return self._new_text + + def toString(self) -> str: + return f"CorrectionInfo('{self._old_text}' -> '{self._new_text}')" + + +# ═══════════════════════════════════════════════════════════════ +# CompletionInfo +# ═══════════════════════════════════════════════════════════════ + +class CompletionInfo(Stub): + """CompletionInfo — 补全信息""" + + def __init__(self, id: int = 0, position: int = 0, + text: str = "", label: str = ""): + super().__init__() + self._id: int = id + self._position: int = position + self._text: str = text + self._label: str = label + + def getId(self) -> int: + return self._id + + def getPosition(self) -> int: + return self._position + + def getText(self) -> str: + return self._text + + def getLabel(self) -> str: + return self._label + + def toString(self) -> str: + return f"CompletionInfo(id={self._id}, text='{self._text}')" + + +# ═══════════════════════════════════════════════════════════════ +# SurroundingText +# ═══════════════════════════════════════════════════════════════ + +class SurroundingText(Stub): + """SurroundingText — 周围文本""" + + def __init__(self, text: str = "", selection_start: int = 0, + selection_end: int = 0, offset: int = 0): + super().__init__() + self._text: str = text + self._selection_start: int = selection_start + self._selection_end: int = selection_end + self._offset: int = offset + + def getText(self) -> str: + return self._text + + def getSelectionStart(self) -> int: + return self._selection_start + + def getSelectionEnd(self) -> int: + return self._selection_end + + def getOffset(self) -> int: + return self._offset + + def toString(self) -> str: + return (f"SurroundingText(text='{self._text}', " + f"selection=({self._selection_start}, {self._selection_end}), " + f"offset={self._offset})") + + +# ═══════════════════════════════════════════════════════════════ +# InputContentInfo +# ═══════════════════════════════════════════════════════════════ + +class InputContentInfo(Stub): + """InputContentInfo — 输入内容信息""" + + def __init__(self, uri: Any = None, description: Any = None, + link_uri: Any = None): + super().__init__() + self._uri: Any = uri + self._description: Any = description + self._link_uri: Any = link_uri + + def getUri(self) -> Any: + return self._uri + + def getDescription(self) -> Any: + return self._description + + def getLinkUri(self) -> Any: + return self._link_uri + + def requestPermission(self): + pass + + def releasePermission(self): + pass + + def toString(self) -> str: + return (f"InputContentInfo(uri={self._uri}, " + f"description={self._description})") + + +# ═══════════════════════════════════════════════════════════════ +# InputConnectionWrapper +# ═══════════════════════════════════════════════════════════════ + +class InputConnectionWrapper(InputConnection): + """InputConnectionWrapper — 输入连接包装器""" + + def __init__(self, target: InputConnection, mutable: bool = True): + super().__init__() + self._target: InputConnection = target + self._mutable: bool = mutable + + def setTarget(self, target: InputConnection): + if self._mutable: + self._target = target + + def getTarget(self) -> InputConnection: + return self._target + + def getTextBeforeCursor(self, length: int, flags: int) -> Optional[str]: + return self._target.getTextBeforeCursor(length, flags) + + def getTextAfterCursor(self, length: int, flags: int) -> Optional[str]: + return self._target.getTextAfterCursor(length, flags) + + def getSelectedText(self, flags: int) -> Optional[str]: + return self._target.getSelectedText(flags) + + def getSurroundingText(self, before_length: int, after_length: int, + flags: int) -> Optional["SurroundingText"]: + return self._target.getSurroundingText(before_length, after_length, flags) + + def getCursorCapsMode(self, req_modes: int) -> int: + return self._target.getCursorCapsMode(req_modes) + + def getExtractedText(self, request: "ExtractedTextRequest", + flags: int) -> Optional["ExtractedText"]: + return self._target.getExtractedText(request, flags) + + def commitText(self, text: Any, new_cursor_position: int) -> bool: + return self._target.commitText(text, new_cursor_position) + + def commitCompletion(self, completion: "CompletionInfo") -> bool: + return self._target.commitCompletion(completion) + + def commitCorrection(self, correction: "CorrectionInfo") -> bool: + return self._target.commitCorrection(correction) + + def commitContent(self, input_content: "InputContentInfo", + flags: int, opts: Optional[Any] = None) -> bool: + return self._target.commitContent(input_content, flags, opts) + + def setComposingText(self, text: Any, new_cursor_position: int) -> bool: + return self._target.setComposingText(text, new_cursor_position) + + def setComposingRegion(self, start: int, end: int) -> bool: + return self._target.setComposingRegion(start, end) + + def finishComposingText(self) -> bool: + return self._target.finishComposingText() + + def setSelection(self, start: int, end: int) -> bool: + return self._target.setSelection(start, end) + + def performEditorAction(self, action_code: int) -> bool: + return self._target.performEditorAction(action_code) + + def performContextMenuAction(self, id: int) -> bool: + return self._target.performContextMenuAction(id) + + def beginBatchEdit(self) -> bool: + return self._target.beginBatchEdit() + + def endBatchEdit(self) -> bool: + return self._target.endBatchEdit() + + def sendKeyEvent(self, event: Any) -> bool: + return self._target.sendKeyEvent(event) + + def clearMetaKeyStates(self, states: int) -> bool: + return self._target.clearMetaKeyStates(states) + + def deleteSurroundingText(self, before_length: int, after_length: int) -> bool: + return self._target.deleteSurroundingText(before_length, after_length) + + def requestCursorUpdates(self, cursor_update_mode: int) -> bool: + return self._target.requestCursorUpdates(cursor_update_mode) + + def closeConnection(self): + self._target.closeConnection() + + def reportFullscreenMode(self, enabled: bool): + self._target.reportFullscreenMode(enabled) + + +# ═══════════════════════════════════════════════════════════════ +# BaseInputConnection +# ═══════════════════════════════════════════════════════════════ + +class BaseInputConnection(InputConnection): + """BaseInputConnection — 输入连接基类""" + + def __init__(self, view: Any, full_editor: bool = True): + super().__init__() + self._view = view + self._full_editor = full_editor + self._text: str = "" + self._selection_start: int = 0 + self._selection_end: int = 0 + self._composing_start: int = -1 + self._composing_end: int = -1 + + def getEditable(self) -> Optional[Any]: + return None + + def reportFullscreenMode(self, enabled: bool): + pass + + def requestCursorUpdates(self, cursor_update_mode: int) -> bool: + return self._full_editor + + def closeConnection(self): + pass + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "InputMethodManager", + "EditorInfo", + "InputConnection", + "ExtractedText", + "ExtractedTextRequest", + "InputBinding", + "InputMethodSubtype", + "CursorAnchorInfo", + "CorrectionInfo", + "CompletionInfo", + "SurroundingText", + "InputContentInfo", + "InputConnectionWrapper", + "BaseInputConnection", +] \ No newline at end of file diff --git a/android_pyapi/android/webkit.py b/android_pyapi/android/webkit.py new file mode 100644 index 0000000..e8000c7 --- /dev/null +++ b/android_pyapi/android/webkit.py @@ -0,0 +1,992 @@ +""" +Android WebKit 组件 — WebView, WebSettings, WebViewClient, WebChromeClient 等 +方法签名完全对齐 Android SDK +""" + +import os +import sys +from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union + +from .._core import ( + Stub, AndroidOnlyError, android_context, + resolve_android_path, to_android_path, + _sdcard_root, _app_data_dir, _package_name, +) + + +# ═══════════════════════════════════════════════════════════════ +# WebResourceRequest / WebResourceResponse / WebResourceError +# ═══════════════════════════════════════════════════════════════ + +class WebResourceRequest(Stub): + """WebResourceRequest — 资源请求""" + + def __init__(self, url: str = "", is_for_main_frame: bool = False, + is_redirect: bool = False, method: str = "GET", + request_headers: Optional[Dict[str, str]] = None): + super().__init__() + self._url = url + self._is_for_main_frame = is_for_main_frame + self._is_redirect = is_redirect + self._method = method + self._request_headers = request_headers or {} + + def getUrl(self) -> str: + return self._url + + def isForMainFrame(self) -> bool: + return self._is_for_main_frame + + def isRedirect(self) -> bool: + return self._is_redirect + + def getMethod(self) -> str: + return self._method + + def getRequestHeaders(self) -> Dict[str, str]: + return dict(self._request_headers) + + def toString(self) -> str: + return f"WebResourceRequest(url={self._url})" + + +class WebResourceResponse(Stub): + """WebResourceResponse — 资源响应""" + + def __init__(self, mime_type: str = "", encoding: str = "", + data: Any = None, status_code: int = 200, + reason_phrase: str = "OK", + response_headers: Optional[Dict[str, str]] = None): + super().__init__() + self._mime_type = mime_type + self._encoding = encoding + self._data = data + self._status_code = status_code + self._reason_phrase = reason_phrase + self._response_headers = response_headers or {} + + def getMimeType(self) -> str: + return self._mime_type + + def getEncoding(self) -> str: + return self._encoding + + def getData(self) -> Any: + return self._data + + def getStatusCode(self) -> int: + return self._status_code + + def getReasonPhrase(self) -> str: + return self._reason_phrase + + def getResponseHeaders(self) -> Dict[str, str]: + return dict(self._response_headers) + + +class WebResourceError(Stub): + """WebResourceError — 资源错误""" + + ERROR_UNKNOWN = -1 + ERROR_HOST_LOOKUP = -2 + ERROR_UNSUPPORTED_AUTH_SCHEME = -3 + ERROR_AUTHENTICATION = -4 + ERROR_PROXY_AUTHENTICATION = -5 + ERROR_CONNECT = -6 + ERROR_IO = -7 + ERROR_TIMEOUT = -8 + ERROR_REDIRECT_LOOP = -9 + ERROR_UNSUPPORTED_SCHEME = -10 + ERROR_FAILED_SSL_HANDSHAKE = -11 + ERROR_BAD_URL = -12 + ERROR_FILE = -13 + ERROR_FILE_NOT_FOUND = -14 + ERROR_TOO_MANY_REQUESTS = -15 + + def __init__(self, error_code: int = ERROR_UNKNOWN, description: str = ""): + super().__init__() + self._error_code = error_code + self._description = description + + def getErrorCode(self) -> int: + return self._error_code + + def getDescription(self) -> str: + return self._description + + +# ═══════════════════════════════════════════════════════════════ +# WebMessage / WebMessagePort +# ═══════════════════════════════════════════════════════════════ + +class WebMessage(Stub): + """WebMessage — Web 消息""" + + def __init__(self, data: str = ""): + super().__init__() + self._data = data + + def getData(self) -> str: + return self._data + + +class WebMessagePort(Stub): + """WebMessagePort — Web 消息端口""" + + def postMessage(self, message: WebMessage): + pass + + def close(self): + pass + + def setWebMessageCallback(self, callback: Any): + pass + + +# ═══════════════════════════════════════════════════════════════ +# JavascriptInterface +# ═══════════════════════════════════════════════════════════════ + +class JavascriptInterface(Stub): + """JavascriptInterface — JavaScript 接口注解""" + + def __init__(self, value: str = ""): + super().__init__() + self._value = value + + def getValue(self) -> str: + return self._value + + +# ═══════════════════════════════════════════════════════════════ +# JsResult / JsPromptResult +# ═══════════════════════════════════════════════════════════════ + +class JsResult(Stub): + """JsResult — JS 对话框结果""" + + def __init__(self): + super().__init__() + self._confirmed = False + + def confirm(self): + self._confirmed = True + + def cancel(self): + self._confirmed = False + + +class JsPromptResult(JsResult): + """JsPromptResult — JS 提示结果""" + + def __init__(self): + super().__init__() + self._string_result: str = "" + + def confirm(self, result: str = ""): + self._confirmed = True + self._string_result = result + + def getStringResult(self) -> str: + return self._string_result + + +# ═══════════════════════════════════════════════════════════════ +# HttpAuthHandler / SslErrorHandler +# ═══════════════════════════════════════════════════════════════ + +class HttpAuthHandler(Stub): + """HttpAuthHandler — HTTP 认证处理器""" + + def __init__(self): + super().__init__() + self._proceeded = False + self._cancelled = False + + def proceed(self, username: str, password: str): + self._proceeded = True + + def cancel(self): + self._cancelled = True + + def useHttpAuthUsernamePassword(self) -> bool: + return False + + +class SslErrorHandler(Stub): + """SslErrorHandler — SSL 错误处理器""" + + def __init__(self): + super().__init__() + self._proceeded = False + self._cancelled = False + + def proceed(self): + self._proceeded = True + + def cancel(self): + self._cancelled = True + + +# ═══════════════════════════════════════════════════════════════ +# PermissionRequest +# ═══════════════════════════════════════════════════════════════ + +class PermissionRequest(Stub): + """PermissionRequest — 权限请求""" + + RESOURCE_VIDEO_CAPTURE = "android.webkit.resource.VIDEO_CAPTURE" + RESOURCE_AUDIO_CAPTURE = "android.webkit.resource.AUDIO_CAPTURE" + RESOURCE_PROTECTED_MEDIA_ID = "android.webkit.resource.PROTECTED_MEDIA_ID" + RESOURCE_MIDI_SYSEX = "android.webkit.resource.MIDI_SYSEX" + + def __init__(self): + super().__init__() + self._origin: Any = None + self._resources: List[str] = [] + self._granted_resources: List[str] = [] + + def getOrigin(self) -> Any: + return self._origin + + def getResources(self) -> List[str]: + return list(self._resources) + + def getGrantedResources(self) -> List[str]: + return list(self._granted_resources) + + def grant(self, resources: List[str]): + self._granted_resources = list(resources) + + def deny(self): + self._granted_resources.clear() + + +# ═══════════════════════════════════════════════════════════════ +# GeolocationPermissions / WebStorage +# ═══════════════════════════════════════════════════════════════ + +class GeolocationPermissions(Stub): + """GeolocationPermissions — 地理位置权限""" + + @staticmethod + def getInstance() -> "GeolocationPermissions": + return GeolocationPermissions() + + def allow(self, origin: str): + pass + + def clear(self, origin: str): + pass + + def clearAll(self): + pass + + def getAllowed(self, origin: str, callback: Any): + pass + + def getOrigins(self, callback: Any): + pass + + +class WebStorage(Stub): + """WebStorage — Web 存储""" + + @staticmethod + def getInstance() -> "WebStorage": + return WebStorage() + + def deleteAllData(self): + pass + + def deleteOrigin(self, origin: str): + pass + + def getOrigins(self, callback: Any): + pass + + def getQuotaForOrigin(self, origin: str, callback: Any): + pass + + def getUsageForOrigin(self, origin: str, callback: Any): + pass + + +# ═══════════════════════════════════════════════════════════════ +# WebBackForwardList / WebHistoryItem +# ═══════════════════════════════════════════════════════════════ + +class WebHistoryItem(Stub): + """WebHistoryItem — 历史项""" + + def __init__(self): + super().__init__() + self._url: str = "" + self._original_url: str = "" + self._title: str = "" + self._favicon: Any = None + + def getUrl(self) -> str: + return self._url + + def getOriginalUrl(self) -> str: + return self._original_url + + def getTitle(self) -> str: + return self._title + + def getFavicon(self) -> Any: + return self._favicon + + def toString(self) -> str: + return f"WebHistoryItem(url={self._url})" + + +class WebBackForwardList(Stub): + """WebBackForwardList — 前进后退列表""" + + def __init__(self): + super().__init__() + self._items: List[WebHistoryItem] = [] + self._current_index: int = -1 + + def getCurrentItem(self) -> Optional[WebHistoryItem]: + if 0 <= self._current_index < len(self._items): + return self._items[self._current_index] + return None + + def getCurrentIndex(self) -> int: + return self._current_index + + def getItemAtIndex(self, index: int) -> Optional[WebHistoryItem]: + if 0 <= index < len(self._items): + return self._items[index] + return None + + def getSize(self) -> int: + return len(self._items) + + +# ═══════════════════════════════════════════════════════════════ +# CookieManager / CookieSyncManager +# ═══════════════════════════════════════════════════════════════ + +class CookieManager(Stub): + """CookieManager — Cookie 管理器""" + + _instance: Optional["CookieManager"] = None + + def __init__(self): + super().__init__() + self._accept_cookies: bool = True + self._accept_third_party: bool = True + self._cookies: Dict[str, str] = {} + + @staticmethod + def getInstance() -> "CookieManager": + if CookieManager._instance is None: + CookieManager._instance = CookieManager() + return CookieManager._instance + + def setAcceptCookies(self, accept: bool): + self._accept_cookies = accept + + def acceptCookies(self) -> bool: + return self._accept_cookies + + def setCookie(self, url: str, value: str): + if self._accept_cookies: + self._cookies[url] = value + + def getCookie(self, url: str) -> Optional[str]: + return self._cookies.get(url) + + def setAcceptThirdPartyCookies(self, webview: Any, accept: bool): + self._accept_third_party = accept + + def acceptThirdPartyCookies(self) -> bool: + return self._accept_third_party + + def removeSessionCookie(self): + pass + + def removeAllCookies(self): + self._cookies.clear() + + def removeAllCookiesSync(self): + self._cookies.clear() + + def removeSessionCookies(self): + pass + + def flush(self): + pass + + def hasCookies(self) -> bool: + return bool(self._cookies) + + def removeExpiredCookie(self): + pass + + +class CookieSyncManager(Stub): + """CookieSyncManager — Cookie 同步管理器""" + + _instance: Optional["CookieSyncManager"] = None + + @staticmethod + def createInstance(context: Any) -> "CookieSyncManager": + if CookieSyncManager._instance is None: + CookieSyncManager._instance = CookieSyncManager() + return CookieSyncManager._instance + + @staticmethod + def getInstance() -> "CookieSyncManager": + if CookieSyncManager._instance is None: + CookieSyncManager._instance = CookieSyncManager() + return CookieSyncManager._instance + + def sync(self): + pass + + def startSync(self): + pass + + def stopSync(self): + pass + + def resetSync(self): + pass + + +# ═══════════════════════════════════════════════════════════════ +# WebSettings +# ═══════════════════════════════════════════════════════════════ + +class WebSettings(Stub): + """WebSettings — WebView 设置""" + + LOAD_DEFAULT = -1 + LOAD_CACHE_ELSE_NETWORK = 1 + LOAD_NO_CACHE = 2 + LOAD_CACHE_ONLY = 3 + + MIXED_CONTENT_ALWAYS_ALLOW = 0 + MIXED_CONTENT_NEVER_ALLOW = 1 + MIXED_CONTENT_COMPATIBILITY_MODE = 2 + + class LayoutAlgorithm(Stub): + NORMAL = 0 + SINGLE_COLUMN = 1 + NARROW_COLUMNS = 2 + TEXT_AUTOSIZING = 3 + + def __init__(self): + super().__init__() + self._js_enabled: bool = True + self._dom_storage_enabled: bool = True + self._allow_file_access: bool = True + self._allow_content_access: bool = True + self._allow_file_access_from_urls: bool = False + self._allow_universal_access_from_urls: bool = False + self._built_in_zoom_controls: bool = True + self._display_zoom_controls: bool = True + self._support_zoom: bool = True + self._load_with_overview_mode: bool = False + self._use_wide_viewport: bool = False + self._user_agent_string: str = "Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36" + self._default_text_encoding: str = "UTF-8" + self._cache_mode: int = self.LOAD_DEFAULT + self._app_cache_enabled: bool = False + self._app_cache_path: str = "" + self._database_enabled: bool = False + self._geolocation_enabled: bool = False + self._js_can_open_windows: bool = False + self._loads_images_automatically: bool = True + self._block_network_image: bool = False + self._block_network_loads: bool = False + self._minimum_font_size: int = 8 + self._default_font_size: int = 16 + self._text_zoom: int = 100 + self._layout_algorithm: int = WebSettings.LayoutAlgorithm.NORMAL + self._mixed_content_mode: int = self.MIXED_CONTENT_NEVER_ALLOW + self._offscreen_pre_raster: bool = False + self._safe_browsing_enabled: bool = True + self._javascript_can_open_windows_automatically: bool = False + + def setJavaScriptEnabled(self, enabled: bool): + self._js_enabled = enabled + + def setDomStorageEnabled(self, enabled: bool): + self._dom_storage_enabled = enabled + + def setAllowFileAccess(self, allow: bool): + self._allow_file_access = allow + + def setAllowContentAccess(self, allow: bool): + self._allow_content_access = allow + + def setAllowFileAccessFromFileURLs(self, allow: bool): + self._allow_file_access_from_urls = allow + + def setAllowUniversalAccessFromFileURLs(self, allow: bool): + self._allow_universal_access_from_urls = allow + + def setBuiltInZoomControls(self, enabled: bool): + self._built_in_zoom_controls = enabled + + def setDisplayZoomControls(self, enabled: bool): + self._display_zoom_controls = enabled + + def setSupportZoom(self, support: bool): + self._support_zoom = support + + def setLoadWithOverviewMode(self, overview: bool): + self._load_with_overview_mode = overview + + def setUseWideViewPort(self, use: bool): + self._use_wide_viewport = use + + def setUserAgentString(self, ua: str): + self._user_agent_string = ua + + def getUserAgentString(self) -> str: + return self._user_agent_string + + def setDefaultTextEncodingName(self, encoding: str): + self._default_text_encoding = encoding + + def getDefaultTextEncodingName(self) -> str: + return self._default_text_encoding + + def setCacheMode(self, mode: int): + self._cache_mode = mode + + def getCacheMode(self) -> int: + return self._cache_mode + + def setAppCacheEnabled(self, enabled: bool): + self._app_cache_enabled = enabled + + def setAppCachePath(self, path: str): + self._app_cache_path = path + + def setDatabaseEnabled(self, enabled: bool): + self._database_enabled = enabled + + def setGeolocationEnabled(self, enabled: bool): + self._geolocation_enabled = enabled + + def setJavaScriptCanOpenWindowsAutomatically(self, auto: bool): + self._javascript_can_open_windows_automatically = auto + + def setLoadsImagesAutomatically(self, auto: bool): + self._loads_images_automatically = auto + + def setBlockNetworkImage(self, block: bool): + self._block_network_image = block + + def setBlockNetworkLoads(self, block: bool): + self._block_network_loads = block + + def setMinimumFontSize(self, size: int): + self._minimum_font_size = size + + def getMinimumFontSize(self) -> int: + return self._minimum_font_size + + def setDefaultFontSize(self, size: int): + self._default_font_size = size + + def getDefaultFontSize(self) -> int: + return self._default_font_size + + def setTextZoom(self, zoom: int): + self._text_zoom = zoom + + def getTextZoom(self) -> int: + return self._text_zoom + + def setLayoutAlgorithm(self, algo: int): + self._layout_algorithm = algo + + def getLayoutAlgorithm(self) -> int: + return self._layout_algorithm + + def setMixedContentMode(self, mode: int): + self._mixed_content_mode = mode + + def getMixedContentMode(self) -> int: + return self._mixed_content_mode + + def setOffscreenPreRaster(self, enabled: bool): + self._offscreen_pre_raster = enabled + + def getOffscreenPreRaster(self) -> bool: + return self._offscreen_pre_raster + + def setSafeBrowsingEnabled(self, enabled: bool): + self._safe_browsing_enabled = enabled + + def getSafeBrowsingEnabled(self) -> bool: + return self._safe_browsing_enabled + + def toString(self) -> str: + return f"WebSettings(js={self._js_enabled})" + + +# ═══════════════════════════════════════════════════════════════ +# WebViewClient +# ═══════════════════════════════════════════════════════════════ + +class WebViewClient(Stub): + """WebViewClient — WebView 客户端""" + + def onPageStarted(self, view: "WebView", url: str, favicon: Any): + pass + + def onPageFinished(self, view: "WebView", url: str): + pass + + def onLoadResource(self, view: "WebView", url: str): + pass + + def shouldOverrideUrlLoading(self, view: "WebView", request: Any) -> bool: + return False + + def shouldOverrideUrlLoading(self, view: "WebView", url: str) -> bool: + return False + + def shouldInterceptRequest(self, view: "WebView", request: WebResourceRequest) -> Optional[WebResourceResponse]: + return None + + def shouldInterceptRequest(self, view: "WebView", url: str) -> Optional[WebResourceResponse]: + return None + + def onReceivedHttpError(self, view: "WebView", request: WebResourceRequest, + error_response: WebResourceResponse): + pass + + def onReceivedSslError(self, view: "WebView", handler: SslErrorHandler, error: Any): + pass + + def onReceivedClientCertRequest(self, view: "WebView", request: Any): + pass + + def onReceivedHttpAuthRequest(self, view: "WebView", handler: HttpAuthHandler, + host: str, realm: str): + pass + + def onFormResubmission(self, view: "WebView", dont_resend: Any, resend: Any): + pass + + def doUpdateVisitedHistory(self, view: "WebView", url: str, is_reload: bool): + pass + + def onScaleChanged(self, view: "WebView", old_scale: float, new_scale: float): + pass + + def onUnhandledKeyEvent(self, view: "WebView", event: Any): + pass + + def shouldOverrideKeyEvent(self, view: "WebView", event: Any) -> bool: + return False + + +# ═══════════════════════════════════════════════════════════════ +# WebChromeClient +# ═══════════════════════════════════════════════════════════════ + +class WebChromeClient(Stub): + """WebChromeClient — WebView Chrome 客户端""" + + def onProgressChanged(self, view: "WebView", new_progress: int): + pass + + def onReceivedTitle(self, view: "WebView", title: str): + pass + + def onReceivedIcon(self, view: "WebView", icon: Any): + pass + + def onReceivedTouchIconUrl(self, view: "WebView", url: str, precomposed: bool): + pass + + def onShowCustomView(self, view: Any, callback: Any): + pass + + def onHideCustomView(self): + pass + + def onCreateWindow(self, view: "WebView", is_dialog: bool, + is_user_gesture: bool, result_msg: Any) -> bool: + return False + + def onRequestFocus(self, view: "WebView"): + pass + + def onCloseWindow(self, window: "WebView"): + pass + + def onJsAlert(self, view: "WebView", url: str, message: str, + result: JsResult) -> bool: + return False + + def onJsConfirm(self, view: "WebView", url: str, message: str, + result: JsResult) -> bool: + return False + + def onJsPrompt(self, view: "WebView", url: str, message: str, + default_value: str, result: JsPromptResult) -> bool: + return False + + def onJsBeforeUnload(self, view: "WebView", url: str, message: str, + result: JsResult) -> bool: + return False + + def onExceededDatabaseQuota(self, url: str, database_identifier: str, + quota: int, estimated_database_size: int, + total_quota: int, quota_updater: Any): + pass + + def onReachedMaxAppCacheSize(self, space_needed: int, total_quota: int, + quota_updater: Any): + pass + + def onGeolocationPermissionsShowPrompt(self, origin: str, + callback: Any): + pass + + def onGeolocationPermissionsHidePrompt(self): + pass + + def onPermissionRequest(self, request: PermissionRequest): + pass + + def onPermissionRequestCanceled(self, request: PermissionRequest): + pass + + def onConsoleMessage(self, message: Any) -> bool: + return True + + +# ═══════════════════════════════════════════════════════════════ +# WebView +# ═══════════════════════════════════════════════════════════════ + +class WebView(Stub): + """WebView — Web 视图""" + + _instance_count = 0 + + def __init__(self, context: Any = None, attrs: Any = None): + super().__init__() + WebView._instance_count += 1 + self._context = context + self._settings = WebSettings() + self._webview_client: Optional[WebViewClient] = None + self._chrome_client: Optional[WebChromeClient] = None + self._current_url: str = "" + self._original_url: str = "" + self._title: str = "" + self._progress: int = 100 + self._content_height: int = 0 + self._scale: float = 1.0 + self._background_color: int = 0xFFFFFFFF + self._back_forward_list = WebBackForwardList() + self._javascript_interfaces: Dict[str, Any] = {} + self._paused: bool = False + self._timers_paused: bool = False + self._network_available: bool = True + + def loadUrl(self, url: str, additional_headers: Optional[Dict[str, str]] = None): + self._current_url = url + self._original_url = url + self._title = url + self._progress = 0 + if self._webview_client: + try: + self._webview_client.onPageStarted(self, url, None) + self._webview_client.onPageFinished(self, url) + except Exception: + pass + self._progress = 100 + + def loadData(self, data: str, mime_type: str = "text/html", + encoding: str = "utf-8"): + self._current_url = "data:text/html;charset=utf-8," + self._progress = 100 + + def loadDataWithBaseURL(self, base_url: str, data: str, + mime_type: str, encoding: str, + history_url: str): + self._current_url = history_url or base_url + self._progress = 100 + + def setWebViewClient(self, client: WebViewClient): + self._webview_client = client + + def setWebChromeClient(self, client: WebChromeClient): + self._chrome_client = client + + def getSettings(self) -> WebSettings: + return self._settings + + def goBack(self): + pass + + def goForward(self): + pass + + def canGoBack(self) -> bool: + return False + + def canGoForward(self) -> bool: + return False + + def goBackOrForward(self, steps: int): + pass + + def reload(self): + pass + + def stopLoading(self): + pass + + def clearHistory(self): + pass + + def clearCache(self, include_disk_files: bool): + pass + + def clearView(self): + pass + + def destroy(self): + WebView._instance_count -= 1 + + def getUrl(self) -> Optional[str]: + return self._current_url or None + + def getTitle(self) -> Optional[str]: + return self._title or None + + def getProgress(self) -> int: + return self._progress + + def getContentHeight(self) -> int: + return self._content_height + + def getScale(self) -> float: + return self._scale + + def addJavascriptInterface(self, obj: Any, interface_name: str): + self._javascript_interfaces[interface_name] = obj + + def removeJavascriptInterface(self, interface_name: str): + if interface_name in self._javascript_interfaces: + del self._javascript_interfaces[interface_name] + + def evaluateJavascript(self, script: str, callback: Any = None): + pass + + def setInitialScale(self, scale_in_percent: int): + self._scale = scale_in_percent / 100.0 + + def setBackgroundColor(self, color: int): + self._background_color = color + + def scrollTo(self, x: int, y: int): + pass + + def scrollBy(self, x: int, y: int): + pass + + def pageUp(self, top: bool) -> bool: + return True + + def pageDown(self, bottom: bool) -> bool: + return True + + def findNext(self, forward: bool): + pass + + def findAll(self, find: str) -> int: + return 0 + + def findAllAsync(self, find: str): + pass + + def clearMatches(self): + pass + + def zoomIn(self): + self._scale *= 1.25 + + def zoomOut(self): + self._scale /= 1.25 + + def setNetworkAvailable(self, available: bool): + self._network_available = available + + def pauseTimers(self): + self._timers_paused = True + + def resumeTimers(self): + self._timers_paused = False + + def onPause(self): + self._paused = True + + def onResume(self): + self._paused = False + + def onWindowFocusChanged(self, has_focus: bool): + pass + + def setLayoutParams(self, params: Any): + pass + + def requestFocus(self, direction: int = 0): + pass + + def getOriginalUrl(self) -> Optional[str]: + return self._original_url or None + + def canZoomIn(self) -> bool: + return True + + def canZoomOut(self) -> bool: + return self._scale > 0.25 + + def toString(self) -> str: + return f"WebView(url={self._current_url})" + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + "WebView", + "WebSettings", + "WebViewClient", + "WebChromeClient", + "WebResourceRequest", + "WebResourceResponse", + "WebResourceError", + "WebMessage", + "WebMessagePort", + "JavascriptInterface", + "CookieManager", + "CookieSyncManager", + "JsResult", + "JsPromptResult", + "HttpAuthHandler", + "SslErrorHandler", + "PermissionRequest", + "GeolocationPermissions", + "WebStorage", + "WebBackForwardList", + "WebHistoryItem", +] \ No newline at end of file diff --git a/android_pyapi/android/widget.py b/android_pyapi/android/widget.py new file mode 100644 index 0000000..98c2544 --- /dev/null +++ b/android_pyapi/android/widget.py @@ -0,0 +1,4777 @@ +""" +Android Widget 组件 — TextView, Button, RecyclerView, ListView, WebView 等 +方法签名完全对齐 Android SDK +""" + +import math +import time +from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union + +from .._core import Stub, AndroidOnlyError, android_context +from .view import ( + View, ViewGroup, ViewTreeObserver, + MotionEvent, KeyEvent, Gravity, SurfaceView, + ViewGroup as VG, +) + + +# ═══════════════════════════════════════════════════════════════ +# TextView +# ═══════════════════════════════════════════════════════════════ + +class TextView(View): + """TextView — 文本显示视图""" + + # 自动链接 + AUTO_LINK_NONE = 0x00 + AUTO_LINK_WEB_URLS = 0x01 + AUTO_LINK_EMAIL_ADDRESSES = 0x02 + AUTO_LINK_PHONE_NUMBERS = 0x04 + AUTO_LINK_MAP_ADDRESSES = 0x08 + AUTO_LINK_ALL = 0x0F + + # Buffer类型 + BUFFER_TYPE_NORMAL = 0 + BUFFER_TYPE_SPANNABLE = 1 + BUFFER_TYPE_EDITABLE = 2 + + # 截断位置 + TRUNCATE_AT_END = 0 + TRUNCATE_AT_MIDDLE = 1 + TRUNCATE_AT_START = 2 + + # 文本方向 + TEXT_DIRECTION_INHERIT = 0 + TEXT_DIRECTION_FIRST_STRONG = 1 + TEXT_DIRECTION_ANY_RTL = 2 + TEXT_DIRECTION_LTR = 3 + TEXT_DIRECTION_RTL = 4 + TEXT_DIRECTION_LOCALE = 5 + TEXT_DIRECTION_FIRST_STRONG_LTR = 6 + TEXT_DIRECTION_FIRST_STRONG_RTL = 7 + + # 文本对齐 + TEXT_ALIGNMENT_INHERIT = 0 + TEXT_ALIGNMENT_GRAVITY = 1 + TEXT_ALIGNMENT_TEXT_START = 2 + TEXT_ALIGNMENT_TEXT_END = 3 + TEXT_ALIGNMENT_CENTER = 4 + TEXT_ALIGNMENT_VIEW_START = 5 + TEXT_ALIGNMENT_VIEW_END = 6 + + def __init__(self, context=None): + super().__init__(context) + self._text: str = "" + self._hint: str = "" + self._text_size: float = 14.0 + self._text_color: int = 0xFF000000 + self._hint_text_color: int = 0xFF808080 + self._link_text_color: int = 0xFFFF0000 + self._highlight_color: int = 0x556633CC + self._gravity = Gravity.NO_GRAVITY + self._typeface: Any = None + self._input_type: int = 0 + self._lines: int = 0 + self._max_lines: int = 0 + self._min_lines: int = 0 + self._single_line: bool = False + self._ellipsize: Optional[str] = None # "end", "start", "middle", "marquee" + self._movement_method: Any = None + self._auto_link_mask: int = TextView.AUTO_LINK_NONE + self._transformation_method: Optional[Callable] = None + self._shadow_radius: float = 0.0 + self._shadow_dx: float = 0.0 + self._shadow_dy: float = 0.0 + self._shadow_color: int = 0 + self._line_spacing_extra: float = 0.0 + self._line_spacing_mult: float = 1.0 + self._compound_drawables: List[Any] = [None, None, None, None] + self._compound_drawable_padding: int = 0 + self._include_font_padding: bool = True + self._elegant_text_height: bool = False + self._letter_spacing: float = 0.0 + self._font_feature_settings: str = "" + self._key_listener: Any = None + self._filters: List[Any] = [] + self._select_all_on_focus: bool = False + self._horizontally_scrolling: bool = False + self._on_editor_action_listener: Optional[Callable] = None + self._paint: Any = None + self._line_count: int = 1 + self._layout: Any = None + self._links_clickable: bool = False + self._cursor_visible: bool = True + self._editable: bool = False + self._selection_start: int = 0 + self._selection_end: int = 0 + self._scroll_horizontally: bool = False + + # ─── text ────────────────────────────────────────────────── + + def setText(self, text: str, buffer_type: int = BUFFER_TYPE_NORMAL): + self._text = str(text) if text is not None else "" + self._line_count = self._text.count("\n") + 1 if self._text else 0 + + def getText(self) -> str: + return self._text + + def append(self, text: str): + self._text += str(text) if text is not None else "" + self._line_count = self._text.count("\n") + 1 if self._text else 0 + + # ─── text size / color ───────────────────────────────────── + + def setTextSize(self, size: float, unit: int = 2): # unit=2 means SP + self._text_size = size + + def getTextSize(self) -> float: + return self._text_size + + def setTextColor(self, color: int): + self._text_color = color + + def getCurrentTextColor(self) -> int: + return self._text_color + + def setHintTextColor(self, color: int): + self._hint_text_color = color + + def getHintTextColor(self) -> int: + return self._hint_text_color + + def setLinkTextColor(self, color: int): + self._link_text_color = color + + def getLinkTextColor(self) -> int: + return self._link_text_color + + def setHighlightColor(self, color: int): + self._highlight_color = color + + def getHighlightColor(self) -> int: + return self._highlight_color + + # ─── gravity ────────────────────────────────────────────── + + def setGravity(self, gravity: int): + self._gravity = gravity + + def getGravity(self) -> int: + return self._gravity + + # ─── typeface ────────────────────────────────────────────── + + def setTypeface(self, typeface: Any, style: int = 0): + self._typeface = typeface + + def getTypeface(self) -> Any: + return self._typeface + + # ─── hint ────────────────────────────────────────────────── + + def setHint(self, hint: str): + self._hint = str(hint) if hint is not None else "" + + def getHint(self) -> str: + return self._hint + + # ─── input type ──────────────────────────────────────────── + + def setInputType(self, input_type: int): + self._input_type = input_type + + def getInputType(self) -> int: + return self._input_type + + # ─── lines ───────────────────────────────────────────────── + + def setLines(self, lines: int): + self._lines = lines + + def setMaxLines(self, max_lines: int): + self._max_lines = max_lines + + def getMaxLines(self) -> int: + return self._max_lines + + def setMinLines(self, min_lines: int): + self._min_lines = min_lines + + def getMinLines(self) -> int: + return self._min_lines + + def getLineCount(self) -> int: + return self._line_count + + def setSingleLine(self, single_line: bool = True): + self._single_line = single_line + + # ─── ellipsize ───────────────────────────────────────────── + + def setEllipsize(self, where: Optional[str]): + self._ellipsize = where + + def getEllipsize(self) -> Optional[str]: + return self._ellipsize + + # ─── movement method ────────────────────────────────────── + + def setMovementMethod(self, movement: Any): + self._movement_method = movement + + def getMovementMethod(self) -> Any: + return self._movement_method + + # ─── auto link ───────────────────────────────────────────── + + def setAutoLinkMask(self, mask: int): + self._auto_link_mask = mask + + def getAutoLinkMask(self) -> int: + return self._auto_link_mask + + # ─── transformation ─────────────────────────────────────── + + def setTransformationMethod(self, method: Optional[Callable]): + self._transformation_method = method + + def getTransformationMethod(self) -> Optional[Callable]: + return self._transformation_method + + # ─── shadow ──────────────────────────────────────────────── + + def setShadowLayer(self, radius: float, dx: float, dy: float, color: int): + self._shadow_radius = radius + self._shadow_dx = dx + self._shadow_dy = dy + self._shadow_color = color + + # ─── line spacing ───────────────────────────────────────── + + def setLineSpacing(self, extra: float, multiplier: float): + self._line_spacing_extra = extra + self._line_spacing_mult = multiplier + + # ─── compound drawables ─────────────────────────────────── + + def setCompoundDrawables(self, left: Any, top: Any, right: Any, bottom: Any): + self._compound_drawables = [left, top, right, bottom] + + def setCompoundDrawablesWithIntrinsicBounds(self, left: Any, top: Any, + right: Any, bottom: Any): + self._compound_drawables = [left, top, right, bottom] + + def setCompoundDrawablePadding(self, pad: int): + self._compound_drawable_padding = pad + + def getCompoundDrawablePadding(self) -> int: + return self._compound_drawable_padding + + def getCompoundDrawables(self) -> List[Any]: + return list(self._compound_drawables) + + # ─── editor action ──────────────────────────────────────── + + def setOnEditorActionListener(self, listener: Optional[Callable]): + self._on_editor_action_listener = listener + + # ─── key listener ───────────────────────────────────────── + + def setKeyListener(self, key_listener: Any): + self._key_listener = key_listener + + def getKeyListener(self) -> Any: + return self._key_listener + + # ─── filters ─────────────────────────────────────────────── + + def setFilters(self, filters: List[Any]): + self._filters = list(filters) + + def getFilters(self) -> List[Any]: + return list(self._filters) + + # ─── misc ────────────────────────────────────────────────── + + def setSelectAllOnFocus(self, select_all_on_focus: bool): + self._select_all_on_focus = select_all_on_focus + + def setHorizontallyScrolling(self, horizontally_scrolling: bool): + self._horizontally_scrolling = horizontally_scrolling + + def setIncludeFontPadding(self, include_font_padding: bool): + self._include_font_padding = include_font_padding + + def setElegantTextHeight(self, elegant: bool): + self._elegant_text_height = elegant + + def setLetterSpacing(self, letter_spacing: float): + self._letter_spacing = letter_spacing + + def getLetterSpacing(self) -> float: + return self._letter_spacing + + def setFontFeatureSettings(self, settings: str): + self._font_feature_settings = settings + + def getFontFeatureSettings(self) -> str: + return self._font_feature_settings + + def getPaint(self) -> Any: + return self._paint + + def getLayout(self) -> Any: + return self._layout + + def setLinksClickable(self, links_clickable: bool): + self._links_clickable = links_clickable + + def getLinksClickable(self) -> bool: + return self._links_clickable + + def setCursorVisible(self, visible: bool): + self._cursor_visible = visible + + def isCursorVisible(self) -> bool: + return self._cursor_visible + + def setTextCursorDrawable(self, drawable: Any): + pass + + def setFreezesText(self, freezes_text: bool): + pass + + def getFreezesText(self) -> bool: + return False + + def setEditableFactory(self, factory: Any): + pass + + def setSpannableFactory(self, factory: Any): + pass + + def getTextSize(self) -> float: + return self._text_size + + def setBackgroundColor(self, color: int): + super().setBackgroundColor(color) + + def setPadding(self, left: int, top: int, right: int, bottom: int): + super().setPadding(left, top, right, bottom) + + def onMeasure(self, width_measure_spec: int, height_measure_spec: int): + from .view import MeasureSpec + w = MeasureSpec.getSize(width_measure_spec) + h = MeasureSpec.getSize(height_measure_spec) + if MeasureSpec.getMode(width_measure_spec) == MeasureSpec.AT_MOST: + text_len = len(self._text) * 4 + w = min(w, max(100, text_len)) + if MeasureSpec.getMode(height_measure_spec) == MeasureSpec.AT_MOST: + text_lines = self._line_count + h = min(h, max(20, text_lines * int(self._text_size) + 10)) + self.setMeasuredDimension(w, h) + + def onDraw(self, canvas: Any): + pass + + +# ═══════════════════════════════════════════════════════════════ +# EditText +# ═══════════════════════════════════════════════════════════════ + +class EditText(TextView): + """EditText — 可编辑文本""" + + def __init__(self, context=None): + super().__init__(context) + self._editable = True + self._selection_start = 0 + self._selection_end = 0 + + def setSelection(self, start: int, stop: Optional[int] = None): + if stop is None: + self._selection_start = start + self._selection_end = start + else: + self._selection_start = start + self._selection_end = stop + + def getSelectionStart(self) -> int: + return self._selection_start + + def getSelectionEnd(self) -> int: + return self._selection_end + + def selectAll(self): + self._selection_start = 0 + self._selection_end = len(self._text) + + def extendSelection(self, index: int): + self._selection_end = index + + def setText(self, text: str, buffer_type: int = TextView.BUFFER_TYPE_EDITABLE): + super().setText(text, buffer_type) + + def getEditableText(self): + return self._text + + +# ═══════════════════════════════════════════════════════════════ +# Button +# ═══════════════════════════════════════════════════════════════ + +class Button(TextView): + """Button — 按钮""" + + def __init__(self, context=None): + super().__init__(context) + self._clickable = True + self._focusable = True + + def onTouchEvent(self, event: MotionEvent) -> bool: + if event.getAction() == MotionEvent.ACTION_UP: + self.performClick() + return super().onTouchEvent(event) + + +class CheckBox(Button): + """CheckBox — 复选框""" + + def __init__(self, context=None): + super().__init__(context) + self._checked = False + + def setChecked(self, checked: bool): + self._checked = checked + + def isChecked(self) -> bool: + return self._checked + + def toggle(self): + self._checked = not self._checked + + def performClick(self) -> bool: + self.toggle() + return super().performClick() + + +class RadioButton(Button): + """RadioButton — 单选按钮""" + + def __init__(self, context=None): + super().__init__(context) + self._checked = False + + def setChecked(self, checked: bool): + self._checked = checked + + def isChecked(self) -> bool: + return self._checked + + def toggle(self): + self._checked = not self._checked + + def performClick(self) -> bool: + self.toggle() + return super().performClick() + + +class ToggleButton(Button): + """ToggleButton — 开关按钮""" + + def __init__(self, context=None): + super().__init__(context) + self._checked = False + self._text_on = "ON" + self._text_off = "OFF" + self._disabled_alpha = 0.5 + + def setChecked(self, checked: bool): + self._checked = checked + if self._checked: + self.setText(self._text_on) + else: + self.setText(self._text_off) + + def isChecked(self) -> bool: + return self._checked + + def toggle(self): + self.setChecked(not self._checked) + + def setTextOn(self, text_on: str): + self._text_on = text_on + if self._checked: + self.setText(text_on) + + def getTextOn(self) -> str: + return self._text_on + + def setTextOff(self, text_off: str): + self._text_off = text_off + if not self._checked: + self.setText(text_off) + + def getTextOff(self) -> str: + return self._text_off + + def performClick(self) -> bool: + self.toggle() + return super().performClick() + + +class Switch(Button): + """Switch — 开关组件""" + + def __init__(self, context=None): + super().__init__(context) + self._checked = False + self._show_text = True + self._split_track = False + self._thumb_text_padding: int = 0 + self._switch_min_width: int = 0 + self._switch_padding: int = 0 + self._thumb_drawable: Any = None + self._track_drawable: Any = None + self._text_on = "ON" + self._text_off = "OFF" + self._thumb_width = 40 + self._switch_width = 100 + + def isChecked(self) -> bool: + return self._checked + + def setChecked(self, checked: bool): + self._checked = checked + + def toggle(self): + self._checked = not self._checked + + def setShowText(self, show_text: bool): + self._show_text = show_text + + def getShowText(self) -> bool: + return self._show_text + + def setSplitTrack(self, split_track: bool): + self._split_track = split_track + + def getSplitTrack(self) -> bool: + return self._split_track + + def setThumbTextPadding(self, padding: int): + self._thumb_text_padding = padding + + def getThumbTextPadding(self) -> int: + return self._thumb_text_padding + + def setSwitchMinWidth(self, min_width: int): + self._switch_min_width = min_width + + def getSwitchMinWidth(self) -> int: + return self._switch_min_width + + def setSwitchPadding(self, padding: int): + self._switch_padding = padding + + def getSwitchPadding(self) -> int: + return self._switch_padding + + def getThumbDrawable(self) -> Any: + return self._thumb_drawable + + def setThumbDrawable(self, drawable: Any): + self._thumb_drawable = drawable + + def getTrackDrawable(self) -> Any: + return self._track_drawable + + def setTrackDrawable(self, drawable: Any): + self._track_drawable = drawable + + def setTextOn(self, text_on: str): + self._text_on = text_on + + def getTextOn(self) -> str: + return self._text_on + + def setTextOff(self, text_off: str): + self._text_off = text_off + + def getTextOff(self) -> str: + return self._text_off + + def performClick(self) -> bool: + self.toggle() + return super().performClick() + + def onMeasure(self, width_measure_spec: int, height_measure_spec: int): + from .view import MeasureSpec + w = MeasureSpec.getSize(width_measure_spec) + h = MeasureSpec.getSize(height_measure_spec) + self.setMeasuredDimension(w, max(30, h)) + + +# ═══════════════════════════════════════════════════════════════ +# ImageView +# ═══════════════════════════════════════════════════════════════ + +class ImageView(View): + """ImageView — 图片视图""" + + # ScaleType常量 + ScaleType = type("ScaleType", (), { + "MATRIX": 0, + "FIT_XY": 1, + "FIT_START": 2, + "FIT_CENTER": 3, + "FIT_END": 4, + "CENTER": 5, + "CENTER_CROP": 6, + "CENTER_INSIDE": 7, + }) + + def __init__(self, context=None): + super().__init__(context) + self._drawable: Any = None + self._image_resource: int = 0 + self._uri: Any = None + self._scale_type: int = ImageView.ScaleType.FIT_CENTER + self._max_width: int = 0 + self._max_height: int = 0 + self._adjust_view_bounds: bool = False + self._crop_to_padding: bool = False + self._baseline: int = 0 + self._baseline_align_bottom: bool = False + self._image_matrix: Any = None + self._image_bitmap: Any = None + + def setImageDrawable(self, drawable: Any): + self._drawable = drawable + + def getDrawable(self) -> Any: + return self._drawable + + def setImageResource(self, res_id: int): + self._image_resource = res_id + + def setImageURI(self, uri: Any): + self._uri = uri + + def setImageBitmap(self, bitmap: Any): + self._image_bitmap = bitmap + + def getImageBitmap(self) -> Any: + return self._image_bitmap + + def setScaleType(self, scale_type: int): + self._scale_type = scale_type + + def getScaleType(self) -> int: + return self._scale_type + + def setMaxWidth(self, max_width: int): + self._max_width = max_width + + def setMaxHeight(self, max_height: int): + self._max_height = max_height + + def setAdjustViewBounds(self, adjust: bool): + self._adjust_view_bounds = adjust + + def getAdjustViewBounds(self) -> bool: + return self._adjust_view_bounds + + def setCropToPadding(self, crop: bool): + self._crop_to_padding = crop + + def getCropToPadding(self) -> bool: + return self._crop_to_padding + + def setBaseline(self, baseline: int): + self._baseline = baseline + + def getBaseline(self) -> int: + return self._baseline + + def setBaselineAlignBottom(self, aligned: bool): + self._baseline_align_bottom = aligned + + def getBaselineAlignBottom(self) -> bool: + return self._baseline_align_bottom + + def setImageMatrix(self, matrix: Any): + self._image_matrix = matrix + + def getImageMatrix(self) -> Any: + return self._image_matrix + + def invalidateDrawable(self, dr: Any): + pass + + def onMeasure(self, width_measure_spec: int, height_measure_spec: int): + from .view import MeasureSpec + w = MeasureSpec.getSize(width_measure_spec) + h = MeasureSpec.getSize(height_measure_spec) + if w == 0: + w = 100 + if h == 0: + h = 100 + self.setMeasuredDimension(w, h) + + +class ImageButton(ImageView): + """ImageButton — 图片按钮""" + + def __init__(self, context=None): + super().__init__(context) + self._clickable = True + self._focusable = True + + def onTouchEvent(self, event: MotionEvent) -> bool: + if event.getAction() == MotionEvent.ACTION_UP: + self.performClick() + return super().onTouchEvent(event) + + +# ═══════════════════════════════════════════════════════════════ +# ProgressBar +# ═══════════════════════════════════════════════════════════════ + +class ProgressBar(View): + """ProgressBar — 进度条""" + + def __init__(self, context=None, attrs: Any = None, def_style_attr: int = 0, + def_style_res: int = 0): + super().__init__(context) + self._progress: int = 0 + self._max: int = 100 + self._indeterminate: bool = False + self._indeterminate_drawable: Any = None + self._progress_drawable: Any = None + self._secondary_progress: int = 0 + self._min: int = 0 + self._interpolator: Any = None + self._animation: Any = None + + def setProgress(self, progress: int): + self._progress = max(self._min, min(self._max, progress)) + + def getProgress(self) -> int: + return self._progress + + def setMax(self, max_val: int): + self._max = max_val + if self._progress > self._max: + self._progress = self._max + + def getMax(self) -> int: + return self._max + + def setMin(self, min_val: int): + self._min = min_val + + def getMin(self) -> int: + return self._min + + def incrementProgressBy(self, diff: int): + self.setProgress(self._progress + diff) + + def setIndeterminate(self, indeterminate: bool): + self._indeterminate = indeterminate + + def isIndeterminate(self) -> bool: + return self._indeterminate + + def getIndeterminateDrawable(self) -> Any: + return self._indeterminate_drawable + + def setIndeterminateDrawable(self, drawable: Any): + self._indeterminate_drawable = drawable + + def setProgressDrawable(self, drawable: Any): + self._progress_drawable = drawable + + def getProgressDrawable(self) -> Any: + return self._progress_drawable + + def setSecondaryProgress(self, secondary_progress: int): + self._secondary_progress = max(self._min, min(self._max, secondary_progress)) + + def getSecondaryProgress(self) -> int: + return self._secondary_progress + + def setInterpolator(self, interpolator: Any): + self._interpolator = interpolator + + def getInterpolator(self) -> Any: + return self._interpolator + + def setAnimation(self, animation: Any): + self._animation = animation + + def onMeasure(self, width_measure_spec: int, height_measure_spec: int): + from .view import MeasureSpec + w = MeasureSpec.getSize(width_measure_spec) + h = MeasureSpec.getSize(height_measure_spec) + if h == 0: + h = 20 + self.setMeasuredDimension(w, h) + + +class SeekBar(ProgressBar): + """SeekBar — 可拖动进度条""" + + def __init__(self, context=None, attrs: Any = None, + def_style_attr: int = 0, def_style_res: int = 0): + super().__init__(context, attrs, def_style_attr, def_style_res) + self._on_seek_bar_change_listener: Optional[Callable] = None + + class OnSeekBarChangeListener: + def onProgressChanged(self, seek_bar: "SeekBar", progress: int, from_user: bool): + pass + def onStartTrackingTouch(self, seek_bar: "SeekBar"): + pass + def onStopTrackingTouch(self, seek_bar: "SeekBar"): + pass + + def setOnSeekBarChangeListener(self, listener: Optional[OnSeekBarChangeListener]): + self._on_seek_bar_change_listener = listener + + def getOnSeekBarChangeListener(self) -> Optional[OnSeekBarChangeListener]: + return self._on_seek_bar_change_listener + + def setThumb(self, thumb: Any): + pass + + def getThumb(self) -> Any: + return None + + def setThumbOffset(self, thumb_offset: int): + pass + + def getThumbOffset(self) -> int: + return 0 + + def setKeyProgressIncrement(self, increment: int): + pass + + def getKeyProgressIncrement(self) -> int: + return 1 + + +class RatingBar(ProgressBar): + """RatingBar — 评分条""" + + def __init__(self, context=None, attrs: Any = None, + def_style_attr: int = 0, def_style_res: int = 0): + super().__init__(context, attrs, def_style_attr, def_style_res) + self._num_stars: int = 5 + self._rating: float = 0.0 + self._step_size: float = 0.5 + self._is_indicator: bool = False + self._on_rating_bar_change_listener: Optional[Callable] = None + + class OnRatingBarChangeListener: + def onRatingChanged(self, rating_bar: "RatingBar", rating: float, from_user: bool): + pass + + def setOnRatingBarChangeListener(self, listener: Optional[OnRatingBarChangeListener]): + self._on_rating_bar_change_listener = listener + + def getOnRatingBarChangeListener(self) -> Optional[OnRatingBarChangeListener]: + return self._on_rating_bar_change_listener + + def setNumStars(self, num_stars: int): + self._num_stars = max(1, num_stars) + + def getNumStars(self) -> int: + return self._num_stars + + def setRating(self, rating: float): + self._rating = max(0.0, min(float(self._num_stars), rating)) + + def getRating(self) -> float: + return self._rating + + def setStepSize(self, step_size: float): + self._step_size = max(0.1, step_size) + + def getStepSize(self) -> float: + return self._step_size + + def setIsIndicator(self, is_indicator: bool): + self._is_indicator = is_indicator + + def isIndicator(self) -> bool: + return self._is_indicator + + +# ═══════════════════════════════════════════════════════════════ +# AdapterView +# ═══════════════════════════════════════════════════════════════ + +class AdapterView(ViewGroup): + """AdapterView — 适配器视图基类""" + + CHOICE_MODE_NONE = 0 + CHOICE_MODE_SINGLE = 1 + CHOICE_MODE_MULTIPLE = 2 + CHOICE_MODE_MULTIPLE_MODAL = 3 + + INVALID_POSITION = -1 + INVALID_ROW_ID = -9223372036854775808 # Long.MIN_VALUE + + def __init__(self, context=None): + super().__init__(context) + self._adapter: Any = None + self._on_item_click_listener: Optional[Callable] = None + self._on_item_long_click_listener: Optional[Callable] = None + self._on_item_selected_listener: Optional[Callable] = None + self._choice_mode = AdapterView.CHOICE_MODE_NONE + self._checked_item_positions: Dict[int, bool] = {} + self._checked_id_positions: Dict[int, bool] = {} + self._selected_position = AdapterView.INVALID_POSITION + self._empty_view: Optional[View] = None + self._selection_notifier: Any = None + + def setAdapter(self, adapter: Any): + self._adapter = adapter + + def getAdapter(self) -> Any: + return self._adapter + + def setOnItemClickListener(self, listener: Optional[Callable]): + self._on_item_click_listener = listener + + def getOnItemClickListener(self) -> Optional[Callable]: + return self._on_item_click_listener + + def setOnItemLongClickListener(self, listener: Optional[Callable]): + self._on_item_long_click_listener = listener + + def getOnItemLongClickListener(self) -> Optional[Callable]: + return self._on_item_long_click_listener + + def setOnItemSelectedListener(self, listener: Optional[Callable]): + self._on_item_selected_listener = listener + + def getOnItemSelectedListener(self) -> Optional[Callable]: + return self._on_item_selected_listener + + def getSelectedItemPosition(self) -> int: + return self._selected_position + + def getSelectedItemId(self) -> int: + return 0 + + def getSelectedItem(self) -> Any: + if self._adapter is not None and 0 <= self._selected_position < self._adapter.getCount(): + return self._adapter.getItem(self._selected_position) + return None + + def setSelection(self, position: int): + self._selected_position = position + + def setEmptyView(self, empty_view: View): + self._empty_view = empty_view + + def getEmptyView(self) -> Optional[View]: + return self._empty_view + + def setChoiceMode(self, choice_mode: int): + self._choice_mode = choice_mode + + def getChoiceMode(self) -> int: + return self._choice_mode + + def setItemChecked(self, position: int, checked: bool): + if self._choice_mode == AdapterView.CHOICE_MODE_SINGLE: + self._checked_item_positions.clear() + self._checked_item_positions[position] = checked + elif self._choice_mode == AdapterView.CHOICE_MODE_MULTIPLE: + self._checked_item_positions[position] = checked + + def isItemChecked(self, position: int) -> bool: + return self._checked_item_positions.get(position, False) + + def getCheckedItemPositions(self) -> Dict[int, bool]: + return dict(self._checked_item_positions) + + def getCheckedItemCount(self) -> int: + return len(self._checked_item_positions) + + def getCheckedItemIds(self) -> List[int]: + return list(self._checked_id_positions.keys()) + + def performItemClick(self, view: View, position: int, id_: int) -> bool: + if self._on_item_click_listener: + self._on_item_click_listener(self, view, position, id_) + return True + return False + + +# ═══════════════════════════════════════════════════════════════ +# ListView +# ═══════════════════════════════════════════════════════════════ + +class ListView(AdapterView): + """ListView — 列表视图""" + + CHOICE_MODE_NONE = 0 + CHOICE_MODE_SINGLE = 1 + CHOICE_MODE_MULTIPLE = 2 + CHOICE_MODE_MULTIPLE_MODAL = 3 + + TRANSCRIPT_MODE_DISABLED = 0 + TRANSCRIPT_MODE_NORMAL = 1 + TRANSCRIPT_MODE_ALWAYS_SCROLL = 2 + + def __init__(self, context=None): + super().__init__(context) + self._divider: Any = None + self._divider_height: int = 0 + self._footer_divider: Any = None + self._header_divider: Any = None + self._footer_views: List[View] = [] + self._header_views: List[View] = [] + self._transcript_mode = ListView.TRANSCRIPT_MODE_DISABLED + self._items_can_focus = True + self._smooth_scroll_position = 0 + self._stack_from_bottom = False + self._selection_division = 0 + + def setAdapter(self, adapter: Any): + super().setAdapter(adapter) + + def getAdapter(self) -> Any: + return super().getAdapter() + + def setSelection(self, position: int): + super().setSelection(position) + + def smoothScrollToPosition(self, position: int): + self._smooth_scroll_position = position + + def setDivider(self, divider: Any): + self._divider = divider + + def setDividerHeight(self, height: int): + self._divider_height = height + + def getDivider(self) -> Any: + return self._divider + + def getDividerHeight(self) -> int: + return self._divider_height + + def addFooterView(self, v: View, data: Any = None, is_selectable: bool = True): + self._footer_views.append(v) + + def removeFooterView(self, v: View) -> bool: + if v in self._footer_views: + self._footer_views.remove(v) + return True + return False + + def addHeaderView(self, v: View, data: Any = None, is_selectable: bool = True): + self._header_views.append(v) + + def removeHeaderView(self, v: View) -> bool: + if v in self._header_views: + self._header_views.remove(v) + return True + return False + + def getHeaderViewsCount(self) -> int: + return len(self._header_views) + + def getFooterViewsCount(self) -> int: + return len(self._footer_views) + + def setTranscriptMode(self, mode: int): + self._transcript_mode = mode + + def getTranscriptMode(self) -> int: + return self._transcript_mode + + def setItemsCanFocus(self, items_can_focus: bool): + self._items_can_focus = items_can_focus + + def getItemsCanFocus(self) -> bool: + return self._items_can_focus + + def setStackFromBottom(self, stack_from_bottom: bool): + self._stack_from_bottom = stack_from_bottom + + def isStackFromBottom(self) -> bool: + return self._stack_from_bottom + + def getCheckItemIds(self) -> List[int]: + return list(self._checked_id_positions.keys()) + + +class GridView(AdapterView): + """GridView — 网格视图""" + + def __init__(self, context=None): + super().__init__(context) + self._num_columns: int = 1 + self._column_width: int = 0 + self._horizontal_spacing: int = 0 + self._vertical_spacing: int = 0 + self._stretch_mode: int = 0 # NO_STRETCH + self._gravity = Gravity.LEFT + + STRETCH_NO_STRETCH = 0 + STRETCH_STRETCH_COLUMN_WIDTH = 1 + STRETCH_STRETCH_SPACING = 2 + STRETCH_STRETCH_SPACING_UNIFORM = 3 + STRETCH_STRETCH_COLUMN_WIDTH_UNIFORM = 4 + + def setNumColumns(self, num_columns: int): + self._num_columns = max(1, num_columns) + + def getNumColumns(self) -> int: + return self._num_columns + + def setColumnWidth(self, column_width: int): + self._column_width = column_width + + def getColumnWidth(self) -> int: + return self._column_width + + def setHorizontalSpacing(self, horizontal_spacing: int): + self._horizontal_spacing = horizontal_spacing + + def getHorizontalSpacing(self) -> int: + return self._horizontal_spacing + + def setVerticalSpacing(self, vertical_spacing: int): + self._vertical_spacing = vertical_spacing + + def getVerticalSpacing(self) -> int: + return self._vertical_spacing + + def setStretchMode(self, stretch_mode: int): + self._stretch_mode = stretch_mode + + def getStretchMode(self) -> int: + return self._stretch_mode + + def setGravity(self, gravity: int): + self._gravity = gravity + + def getGravity(self) -> int: + return self._gravity + + def setAdapter(self, adapter: Any): + super().setAdapter(AdapterView) + + +# ═══════════════════════════════════════════════════════════════ +# RecyclerView +# ═══════════════════════════════════════════════════════════════ + +class RecyclerView(ViewGroup): + """RecyclerView — 可回收视图列表""" + + HORIZONTAL = 0 + VERTICAL = 1 + NO_POSITION = -1 + INVALID_TYPE = -1 + TOUCH_SLOP_DEFAULT = 0 + TOUCH_SLOP_PAGING = 1 + + def __init__(self, context=None): + super().__init__(context) + self._adapter: Optional["RecyclerView.Adapter"] = None + self._layout_manager: Optional["RecyclerView.LayoutManager"] = None + self._item_decorations: List[Any] = [] + self._recycler: Any = None + self._child_attached_listener: Optional[Callable] = None + self._child_detached_listener: Optional[Callable] = None + self._item_animator: Any = None + self._on_scroll_listener: Optional[Callable] = None + self._nested_scrolling_enabled = True + self._scroll_state = RecyclerView.SCROLL_STATE_IDLE + self._layout_frozen = False + self._suppress_layout = False + self._clip_to_padding = True + + SCROLL_STATE_IDLE = 0 + SCROLL_STATE_DRAGGING = 1 + SCROLL_STATE_SETTLING = 2 + + # ─── Adapter ───────────────────────────────────────────── + + class Adapter(Stub): + """RecyclerView.Adapter — 适配器""" + + def __init__(self): + super().__init__() + self._observable: Any = None + self._has_stable_ids = False + self._state_restoration_policy = 0 + + def onCreateViewHolder(self, parent: "RecyclerView", view_type: int) -> "RecyclerView.ViewHolder": + raise NotImplementedError + + def onBindViewHolder(self, holder: "RecyclerView.ViewHolder", position: int): + raise NotImplementedError + + def getItemCount(self) -> int: + return 0 + + def getItemViewType(self, position: int) -> int: + return 0 + + def getItemId(self, position: int) -> int: + return position + + def hasStableIds(self) -> bool: + return self._has_stable_ids + + def setHasStableIds(self, has_stable_ids: bool): + self._has_stable_ids = has_stable_ids + + def onAttachedToRecyclerView(self, recycler_view: "RecyclerView"): + pass + + def onDetachedFromRecyclerView(self, recycler_view: "RecyclerView"): + pass + + def onViewAttachedToWindow(self, holder: "RecyclerView.ViewHolder"): + pass + + def onViewDetachedFromWindow(self, holder: "RecyclerView.ViewHolder"): + pass + + def onViewRecycled(self, holder: "RecyclerView.ViewHolder"): + pass + + def onFailedToRecycleView(self, holder: "RecyclerView.ViewHolder") -> bool: + return False + + def notifyDataSetChanged(self): + pass + + def notifyItemChanged(self, position: int): + pass + + def notifyItemInserted(self, position: int): + pass + + def notifyItemRemoved(self, position: int): + pass + + def notifyItemMoved(self, from_position: int, to_position: int): + pass + + def notifyItemRangeChanged(self, position_start: int, item_count: int): + pass + + def notifyItemRangeInserted(self, position_start: int, item_count: int): + pass + + def notifyItemRangeRemoved(self, position_start: int, item_count: int): + pass + + def getStateRestorationPolicy(self) -> int: + return 0 + + # ─── ViewHolder ─────────────────────────────────────────── + + class ViewHolder(Stub): + """RecyclerView.ViewHolder — 视图持有者""" + + FLAG_BOUND = 1 + FLAG_NOT_RECYCLABLE = 2 + FLAG_RETURNED_FROM_SCRAP = 4 + FLAG_CHANGED = 8 + FLAG_IGNORE = 16 + FLAG_TMP_DETACHED = 32 + FLAG_UPDATE = 64 + FLAG_ADAPTER_POSITION_UNKNOWN = 128 + FLAG_ADAPTER_FULLUPDATE = 256 + FLAG_MOVED = 512 + FLAG_APPEARED_IN_PRE_LAYOUT = 1024 + + def __init__(self, item_view: View): + super().__init__() + self.itemView = item_view + self._position = RecyclerView.NO_POSITION + self._old_position = RecyclerView.NO_POSITION + self._item_id = RecyclerView.NO_ID + self._item_view_type = RecyclerView.INVALID_TYPE + self._flags = 0 + self._pre_layout_position = RecyclerView.NO_POSITION + self._is_recyclable = True + self._scrap_container: Optional[RecyclerView] = None + self._shadowed_holder: Optional["RecyclerView.ViewHolder"] = None + self._shadowing_holder: Optional["RecyclerView.ViewHolder"] = None + + NO_ID = -1 + + def getAdapterPosition(self) -> int: + return self._position + + def getLayoutPosition(self) -> int: + return self._position + + def getOldPosition(self) -> int: + return self._old_position + + def getItemId(self) -> int: + return self._item_id + + def getItemViewType(self) -> int: + return self._item_view_type + + def setIsRecyclable(self, recyclable: bool): + self._is_recyclable = recyclable + + def isRecyclable(self) -> bool: + return self._is_recyclable + + def getBindingAdapterPosition(self) -> int: + return self._position + + # ─── LayoutManager ──────────────────────────────────────── + + class LayoutManager(Stub): + """RecyclerView.LayoutManager — 布局管理器""" + + def __init__(self): + super().__init__() + self._recycler_view: Optional["RecyclerView"] = None + self._child_count = 0 + self._width = 0 + self._height = 0 + self._auto_measure = True + self._item_prefetch_enabled = True + + def onLayoutChildren(self, recycler: Any, state: Any): + pass + + def getChildCount(self) -> int: + return self._child_count + + def getPosition(self, view: View) -> int: + if isinstance(view, View): + return 0 + return RecyclerView.NO_POSITION + + def scrollToPosition(self, position: int): + pass + + def smoothScrollToPosition(self, recycler_view: "RecyclerView", state: Any, position: int): + pass + + def onAdapterChanged(self, old_adapter: Any, new_adapter: Any): + pass + + def generateDefaultLayoutParams(self) -> ViewGroup.LayoutParams: + return ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, + ViewGroup.LayoutParams.WRAP_CONTENT) + + def getWidth(self) -> int: + return self._width + + def getHeight(self) -> int: + return self._height + + def setAutoMeasureEnabled(self, enabled: bool): + self._auto_measure = enabled + + def isAutoMeasureEnabled(self) -> bool: + return self._auto_measure + + def requestLayout(self): + pass + + def requestSimpleAnimationsInNextLayout(self): + pass + + def assertNotInLayoutOrScroll(self, tag: str = ""): + pass + + def getPaddingLeft(self) -> int: + return 0 + + def getPaddingTop(self) -> int: + return 0 + + def getPaddingRight(self) -> int: + return 0 + + def getPaddingBottom(self) -> int: + return 0 + + # ─── ItemDecoration ────────────────────────────────────── + + class ItemDecoration(Stub): + """RecyclerView.ItemDecoration — 条目装饰""" + + def onDraw(self, c: Any, parent: "RecyclerView", state: Any): + pass + + def onDrawOver(self, c: Any, parent: "RecyclerView", state: Any): + pass + + def getItemOffsets(self, out_rect: Any, view: View, parent: "RecyclerView", state: Any): + if hasattr(out_rect, "set"): + out_rect.set(0, 0, 0, 0) + + # ─── RecycledViewPool ───────────────────────────────────── + + class RecycledViewPool(Stub): + """RecyclerView.RecycledViewPool — 回收视图池""" + + def __init__(self): + super().__init__() + self._max_recycled_views = 5 + + def getRecycledView(self, view_type: int) -> Optional["RecyclerView.ViewHolder"]: + return None + + def putRecycledView(self, scrap: "RecyclerView.ViewHolder"): + pass + + def setMaxRecycledViews(self, view_type: int, max_count: int): + self._max_recycled_views = max_count + + def clear(self): + pass + + # ─── Recycler ───────────────────────────────────────────── + + class Recycler(Stub): + """RecyclerView.Recycler — 回收器""" + + def __init__(self): + super().__init__() + self._view_cache: Dict[int, List["RecyclerView.ViewHolder"]] = {} + + def getViewForPosition(self, position: int) -> View: + raise AndroidOnlyError("RecyclerView.Recycler.getViewForPosition") + + def recycleView(self, view: View): + pass + + def getRecycledViewPool(self) -> "RecyclerView.RecycledViewPool": + return RecyclerView.RecycledViewPool() + + def setViewCacheSize(self, view_count: int): + pass + + def clear(self): + self._view_cache.clear() + + # ─── RecyclerView Instance Methods ─────────────────────── + + def setAdapter(self, adapter: Optional["RecyclerView.Adapter"]): + self._adapter = adapter + + def getAdapter(self) -> Optional["RecyclerView.Adapter"]: + return self._adapter + + def setLayoutManager(self, layout_manager: Optional["RecyclerView.LayoutManager"]): + self._layout_manager = layout_manager + if layout_manager: + layout_manager._recycler_view = self + + def getLayoutManager(self) -> Optional["RecyclerView.LayoutManager"]: + return self._layout_manager + + def addItemDecoration(self, decoration: "RecyclerView.ItemDecoration", index: int = -1): + if index < 0 or index >= len(self._item_decorations): + self._item_decorations.append(decoration) + else: + self._item_decorations.insert(index, decoration) + + def removeItemDecoration(self, decoration: "RecyclerView.ItemDecoration"): + if decoration in self._item_decorations: + self._item_decorations.remove(decoration) + + def getItemDecorationAt(self, index: int) -> "RecyclerView.ItemDecoration": + return self._item_decorations[index] + + def getItemDecorationCount(self) -> int: + return len(self._item_decorations) + + def swapAdapter(self, adapter: Optional["RecyclerView.Adapter"], remove_and_recycle: bool): + self._adapter = adapter + + def getRecycledViewPool(self) -> "RecyclerView.RecycledViewPool": + return RecyclerView.RecycledViewPool() + + def setRecycledViewPool(self, pool: "RecyclerView.RecycledViewPool"): + pass + + def getRecycler(self) -> "RecyclerView.Recycler": + return RecyclerView.Recycler() + + def setItemAnimator(self, animator: Any): + self._item_animator = animator + + def getItemAnimator(self) -> Any: + return self._item_animator + + def setOnScrollListener(self, listener: Optional[Callable]): + self._on_scroll_listener = listener + + def addOnScrollListener(self, listener: Callable): + pass + + def removeOnScrollListener(self, listener: Callable): + pass + + def clearOnScrollListeners(self): + pass + + def addOnChildAttachStateChangeListener(self, listener: Callable): + self._child_attached_listener = listener + + def removeOnChildAttachStateChangeListener(self, listener: Callable): + pass + + def setHasFixedSize(self, has_fixed_size: bool): + pass + + def hasFixedSize(self) -> bool: + return False + + def setNestedScrollingEnabled(self, enabled: bool): + self._nested_scrolling_enabled = enabled + + def isNestedScrollingEnabled(self) -> bool: + return self._nested_scrolling_enabled + + def startNestedScroll(self, axes: int) -> bool: + return False + + def stopNestedScroll(self): + pass + + def hasNestedScrollingParent(self) -> bool: + return False + + def dispatchNestedPreScroll(self, dx: int, dy: int, consumed: List[int], offset: List[int]) -> bool: + return False + + def dispatchNestedScroll(self, dx_consumed: int, dy_consumed: int, + dx_unconsumed: int, dy_unconsumed: int, + offset: List[int]) -> bool: + return False + + def dispatchNestedPreFling(self, velocity_x: float, velocity_y: float) -> bool: + return False + + def dispatchNestedFling(self, velocity_x: float, velocity_y: float, consumed: bool) -> bool: + return False + + def stopScroll(self): + pass + + def getScrollState(self) -> int: + return self._scroll_state + + def setLayoutFrozen(self, frozen: bool): + self._layout_frozen = frozen + + def isLayoutFrozen(self) -> bool: + return self._layout_frozen + + def smoothScrollBy(self, dx: int, dy: int): + pass + + def scrollBy(self, x: int, y: int): + pass + + def computeHorizontalScrollOffset(self) -> int: + return 0 + + def computeHorizontalScrollRange(self) -> int: + return 0 + + def computeVerticalScrollOffset(self) -> int: + return 0 + + def computeVerticalScrollRange(self) -> int: + return 0 + + def findViewHolderForAdapterPosition(self, position: int) -> Optional["RecyclerView.ViewHolder"]: + return None + + def findViewHolderForLayoutPosition(self, position: int) -> Optional["RecyclerView.ViewHolder"]: + return None + + def findViewHolderForItemId(self, id_: int) -> Optional["RecyclerView.ViewHolder"]: + return None + + NO_ID = -1 + + +# 为 __all__ 导出创建别名 +RecyclerViewAdapter = RecyclerView.Adapter +RecyclerViewViewHolder = RecyclerView.ViewHolder +RecyclerViewLayoutManager = RecyclerView.LayoutManager + + +class LinearLayoutManager(RecyclerView.LayoutManager): + """LinearLayoutManager — 线性布局管理器""" + + HORIZONTAL = 0 + VERTICAL = 1 + + def __init__(self, context: Any = None, orientation: int = VERTICAL, reverse_layout: bool = False): + super().__init__() + self._orientation = orientation + self._reverse_layout = reverse_layout + self._stack_from_end = False + self._item_count = 0 + + def setOrientation(self, orientation: int): + self._orientation = orientation + + def getOrientation(self) -> int: + return self._orientation + + def setReverseLayout(self, reverse_layout: bool): + self._reverse_layout = reverse_layout + + def getReverseLayout(self) -> bool: + return self._reverse_layout + + def setStackFromEnd(self, stack_from_end: bool): + self._stack_from_end = stack_from_end + + def getStackFromEnd(self) -> bool: + return self._stack_from_end + + def generateDefaultLayoutParams(self) -> ViewGroup.LayoutParams: + return ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, + ViewGroup.LayoutParams.WRAP_CONTENT) + + def onLayoutChildren(self, recycler: Any, state: Any): + pass + + +class GridLayoutManager(LinearLayoutManager): + """GridLayoutManager — 网格布局管理器""" + + def __init__(self, context: Any = None, span_count: int = 1, + orientation: int = LinearLayoutManager.VERTICAL, + reverse_layout: bool = False): + super().__init__(context, orientation, reverse_layout) + self._span_count = max(1, span_count) + + class SpanSizeLookup(Stub): + """GridLayoutManager.SpanSizeLookup — 跨度大小查找""" + + def __init__(self): + super().__init__() + self._span_index_cache = {} + + def getSpanSize(self, position: int) -> int: + return 1 + + def getSpanIndex(self, position: int, span_count: int) -> int: + return position % span_count + + def getSpanGroupIndex(self, position: int, span_count: int) -> int: + return position // span_count + + def invalidateSpanIndexCache(self): + self._span_index_cache.clear() + + def setSpanCount(self, span_count: int): + self._span_count = max(1, span_count) + + def getSpanCount(self) -> int: + return self._span_count + + def setSpanSizeLookup(self, span_size_lookup: SpanSizeLookup): + pass + + def getSpanSizeLookup(self) -> SpanSizeLookup: + return GridLayoutManager.SpanSizeLookup() + + +class StaggeredGridLayoutManager(RecyclerView.LayoutManager): + """StaggeredGridLayoutManager — 瀑布流布局管理器""" + + HORIZONTAL = 0 + VERTICAL = 1 + + GAP_HANDLING_NONE = 0 + GAP_HANDLING_LAZY = 1 + GAP_HANDLING_MOVE_ITEMS_BETWEEN_SPANS = 2 + + def __init__(self, span_count: int = 1, orientation: int = VERTICAL): + super().__init__() + self._span_count = max(1, span_count) + self._orientation = orientation + self._gap_strategy = StaggeredGridLayoutManager.GAP_HANDLING_LAZY + + def setSpanCount(self, span_count: int): + self._span_count = max(1, span_count) + + def getSpanCount(self) -> int: + return self._span_count + + def setOrientation(self, orientation: int): + self._orientation = orientation + + def getOrientation(self) -> int: + return self._orientation + + def setGapStrategy(self, gap_strategy: int): + self._gap_strategy = gap_strategy + + def getGapStrategy(self) -> int: + return self._gap_strategy + + +# ═══════════════════════════════════════════════════════════════ +# LinearLayout +# ═══════════════════════════════════════════════════════════════ + +class LinearLayout(ViewGroup): + """LinearLayout — 线性布局""" + + HORIZONTAL = 0 + VERTICAL = 1 + SHOW_DIVIDER_NONE = 0 + SHOW_DIVIDER_BEGINNING = 1 + SHOW_DIVIDER_MIDDLE = 2 + SHOW_DIVIDER_END = 4 + + def __init__(self, context=None): + super().__init__(context) + self._orientation = LinearLayout.VERTICAL + self._gravity = Gravity.NO_GRAVITY + self._weight_sum: float = 0.0 + self._baseline_aligned = True + self._baseline_aligned_child_index = -1 + self._divider: Any = None + self._divider_padding: int = 0 + self._divider_show: int = LinearLayout.SHOW_DIVIDER_NONE + self._total_length: int = 0 + + def setOrientation(self, orientation: int): + self._orientation = orientation + + def getOrientation(self) -> int: + return self._orientation + + def setGravity(self, gravity: int): + self._gravity = gravity + + def getGravity(self) -> int: + return self._gravity + + def setWeightSum(self, weight_sum: float): + self._weight_sum = weight_sum + + def getWeightSum(self) -> float: + return self._weight_sum + + def setBaselineAligned(self, baseline_aligned: bool): + self._baseline_aligned = baseline_aligned + + def isBaselineAligned(self) -> bool: + return self._baseline_aligned + + def setDividerDrawable(self, divider: Any): + self._divider = divider + + def setShowDividers(self, show_dividers: int): + self._divider_show = show_dividers + + def getShowDividers(self) -> int: + return self._divider_show + + def getDividerDrawable(self) -> Any: + return self._divider + + def setDividerPadding(self, padding: int): + self._divider_padding = padding + + def getDividerPadding(self) -> int: + return self._divider_padding + + def getBaseline(self) -> int: + return -1 + + def onMeasure(self, width_measure_spec: int, height_measure_spec: int): + from .view import MeasureSpec + w = MeasureSpec.getSize(width_measure_spec) + h = MeasureSpec.getSize(height_measure_spec) + self.setMeasuredDimension(w, h) + + def onLayout(self, changed: bool, l: int, t: int, r: int, b: int): + pass + + class LayoutParams(ViewGroup.MarginLayoutParams): + """LinearLayout.LayoutParams — 线性布局参数""" + + def __init__(self, width: int = ViewGroup.LayoutParams.WRAP_CONTENT, + height: int = ViewGroup.LayoutParams.WRAP_CONTENT, + weight: float = 0.0): + super().__init__(width, height) + self.weight = weight + self.gravity = -1 + + def setLayoutWeight(self, weight: float): + self.weight = weight + + +# ═══════════════════════════════════════════════════════════════ +# RelativeLayout +# ═══════════════════════════════════════════════════════════════ + +class RelativeLayout(ViewGroup): + """RelativeLayout — 相对布局""" + + TRUE = -1 + FALSE = 0 + + # 规则常量 + ALIGN_PARENT_LEFT = 0 + ALIGN_PARENT_TOP = 1 + ALIGN_PARENT_RIGHT = 2 + ALIGN_PARENT_BOTTOM = 3 + ALIGN_PARENT_START = 4 + ALIGN_PARENT_END = 5 + CENTER_IN_PARENT = 6 + CENTER_HORIZONTAL = 7 + CENTER_VERTICAL = 8 + ABOVE = 9 + BELOW = 10 + LEFT_OF = 11 + RIGHT_OF = 12 + ALIGN_LEFT = 13 + ALIGN_TOP = 14 + ALIGN_RIGHT = 15 + ALIGN_BOTTOM = 16 + ALIGN_BASELINE = 17 + ALIGN_WITH_PARENT_IF_MISSING = 18 + START_OF = 19 + END_OF = 20 + ALIGN_START = 21 + ALIGN_END = 22 + + def __init__(self, context=None): + super().__init__(context) + self._gravity = Gravity.NO_GRAVITY + self._ignore_gravity_of_view_ids: List[int] = [] + self._has_left_weight = False + self._has_right_weight = False + self._has_top_weight = False + self._has_bottom_weight = False + + def setGravity(self, gravity: int): + self._gravity = gravity + + def getGravity(self) -> int: + return self._gravity + + def setHorizontalGravity(self, horizontal_gravity: int): + pass + + def setVerticalGravity(self, vertical_gravity: int): + pass + + def onMeasure(self, width_measure_spec: int, height_measure_spec: int): + from .view import MeasureSpec + w = MeasureSpec.getSize(width_measure_spec) + h = MeasureSpec.getSize(height_measure_spec) + self.setMeasuredDimension(w, h) + + def onLayout(self, changed: bool, l: int, t: int, r: int, b: int): + pass + + class LayoutParams(ViewGroup.MarginLayoutParams): + """RelativeLayout.LayoutParams — 相对布局参数""" + + def __init__(self, width: int = ViewGroup.LayoutParams.WRAP_CONTENT, + height: int = ViewGroup.LayoutParams.WRAP_CONTENT): + super().__init__(width, height) + self._rules: Dict[int, int] = {} + self.align_with_parent = False + + def addRule(self, verb: int, subject: int = -1): + self._rules[verb] = subject + + def removeRule(self, verb: int): + self._rules.pop(verb, None) + + def getRule(self, verb: int) -> int: + return self._rules.get(verb, 0) + + def getRules(self) -> Dict[int, int]: + return dict(self._rules) + + def addLayoutRules(self, layout_rules: int): + pass + + def removeLayoutRule(self, layout_rule: int): + pass + + +# ═══════════════════════════════════════════════════════════════ +# FrameLayout +# ═══════════════════════════════════════════════════════════════ + +class FrameLayout(ViewGroup): + """FrameLayout — 帧布局""" + + def __init__(self, context=None): + super().__init__(context) + self._foreground: Any = None + self._foreground_gravity = Gravity.FILL + self._measure_all_children = False + self._foreground_bounds_padding: int = 0 + self._foreground_in_padding = False + + def setForeground(self, drawable: Any): + self._foreground = drawable + + def getForeground(self) -> Any: + return self._foreground + + def setForegroundGravity(self, gravity: int): + self._foreground_gravity = gravity + + def getForegroundGravity(self) -> int: + return self._foreground_gravity + + def setMeasureAllChildren(self, measure_all: bool): + self._measure_all_children = measure_all + + def getMeasureAllChildren(self) -> bool: + return self._measure_all_children + + def setForegroundBoundsPadding(self, padding: int): + self._foreground_bounds_padding = padding + + def onMeasure(self, width_measure_spec: int, height_measure_spec: int): + from .view import MeasureSpec + w = MeasureSpec.getSize(width_measure_spec) + h = MeasureSpec.getSize(height_measure_spec) + if self._measure_all_children: + for child in self._children: + child.measure(width_measure_spec, height_measure_spec) + self.setMeasuredDimension(w, h) + + def onLayout(self, changed: bool, l: int, t: int, r: int, b: int): + pass + + def gatherTransparentRegion(self, region: Any) -> bool: + return False + + +# ═══════════════════════════════════════════════════════════════ +# TableLayout / TableRow +# ═══════════════════════════════════════════════════════════════ + +class TableLayout(LinearLayout): + """TableLayout — 表格布局""" + + def __init__(self, context=None): + super().__init__(context) + self._stretchable_columns: List[bool] = [] + self._shrinkable_columns: List[bool] = [] + self._collapsed_columns: List[bool] = [] + self._max_columns: int = 0 + + def setStretchAllColumns(self, stretch_all: bool): + pass + + def setShrinkAllColumns(self, shrink_all: bool): + pass + + def setColumnStretchable(self, column_index: int, stretchable: bool): + pass + + def setColumnShrinkable(self, column_index: int, shrinkable: bool): + pass + + def setColumnCollapsed(self, column_index: int, collapsed: bool): + pass + + def isColumnStretchable(self, column_index: int) -> bool: + return False + + def isColumnShrinkable(self, column_index: int) -> bool: + return False + + def isColumnCollapsed(self, column_index: int) -> bool: + return False + + +class TableRow(LinearLayout): + """TableRow — 表格行""" + + def __init__(self, context=None): + super().__init__(context) + self._layout_params: Dict[int, Any] = {} + + class LayoutParams(LinearLayout.LayoutParams): + """TableRow.LayoutParams — 表格行布局参数""" + + def __init__(self, width: int = ViewGroup.LayoutParams.WRAP_CONTENT, + height: int = ViewGroup.LayoutParams.WRAP_CONTENT): + super().__init__(width, height) + self.column = -1 + self.span = 1 + + +# ═══════════════════════════════════════════════════════════════ +# ScrollView / HorizontalScrollView +# ═══════════════════════════════════════════════════════════════ + +class ScrollView(FrameLayout): + """ScrollView — 滚动视图""" + + def __init__(self, context=None): + super().__init__(context) + self._fill_viewport = False + self._smooth_scrolling_enabled = True + self._max_scroll_amount = 0 + self._scroll_position = 0 + self._is_layout_after_scroll = False + + def setFillViewport(self, fill_viewport: bool): + self._fill_viewport = fill_viewport + + def isFillViewport(self) -> bool: + return self._fill_viewport + + def setSmoothScrollingEnabled(self, enabled: bool): + self._smooth_scrolling_enabled = enabled + + def isSmoothScrollingEnabled(self) -> bool: + return self._smooth_scrolling_enabled + + def fullScroll(self, direction: int) -> bool: + return True + + def arrowScroll(self, direction: int) -> bool: + return True + + def smoothScrollTo(self, x: int, y: int): + self._scroll_position = y + + def smoothScrollBy(self, dx: int, dy: int): + self._scroll_position += dy + + def pageScroll(self, direction: int) -> bool: + return True + + def getMaxScrollAmount(self) -> int: + return self._max_scroll_amount + + def computeScrollDeltaToGetChildRectOnScreen(self, rect: Any) -> int: + return 0 + + def isLayoutAfterScroll(self) -> bool: + return self._is_layout_after_scroll + + +class HorizontalScrollView(FrameLayout): + """HorizontalScrollView — 水平滚动视图""" + + def __init__(self, context=None): + super().__init__(context) + self._fill_viewport = False + + def setFillViewport(self, fill_viewport: bool): + self._fill_viewport = fill_viewport + + def isFillViewport(self) -> bool: + return self._fill_viewport + + def fullScroll(self, direction: int) -> bool: + return True + + def arrowScroll(self, direction: int) -> bool: + return True + + def smoothScrollTo(self, x: int, y: int): + pass + + def smoothScrollBy(self, dx: int, dy: int): + pass + + def pageScroll(self, direction: int) -> bool: + return True + + +# ═══════════════════════════════════════════════════════════════ +# WebView +# ═══════════════════════════════════════════════════════════════ + +class WebView(ViewGroup): + """WebView — 网页视图""" + + # 布局模式 + NORMAL = 0 + SMALL_SCREEN = 1 + LARGE_SCREEN = 2 + + def __init__(self, context=None): + super().__init__(context) + self._settings: "WebSettings" = WebSettings() + self._web_view_client: Optional[Callable] = None + self._web_chrome_client: Optional[Callable] = None + self._can_go_back: bool = False + self._can_go_forward: bool = False + self._current_url: str = "" + self._history: List[str] = [] + self._current_index: int = -1 + self._download_listener: Optional[Callable] = None + self._find_listener: Optional[Callable] = None + self._picture_listener: Optional[Callable] = None + + def loadUrl(self, url: str, additional_headers: Optional[Dict[str, str]] = None): + self._current_url = url + self._history = self._history[:self._current_index + 1] + self._history.append(url) + self._current_index = len(self._history) - 1 + self._can_go_back = self._current_index > 0 + self._can_go_forward = False + + def loadData(self, data: str, mime_type: str = "text/html", + encoding: str = "utf-8"): + self._current_url = "about:blank" + + def loadDataWithBaseURL(self, base_url: str, data: str, mime_type: str, + encoding: str, history_url: str): + self._current_url = base_url or "about:blank" + + def getSettings(self) -> "WebSettings": + return self._settings + + def setWebViewClient(self, client: Any): + self._web_view_client = client + + def getWebViewClient(self) -> Any: + return self._web_view_client + + def setWebChromeClient(self, client: Any): + self._web_chrome_client = client + + def getWebChromeClient(self) -> Any: + return self._web_chrome_client + + def goBack(self): + if self._can_go_back: + self._current_index -= 1 + self._current_url = self._history[self._current_index] + self._can_go_back = self._current_index > 0 + self._can_go_forward = True + + def goForward(self): + if self._can_go_forward: + self._current_index += 1 + self._current_url = self._history[self._current_index] + self._can_go_forward = self._current_index < len(self._history) - 1 + self._can_go_back = True + + def reload(self): + pass + + def canGoBack(self) -> bool: + return self._can_go_back + + def canGoForward(self) -> bool: + return self._can_go_forward + + def clearHistory(self): + self._history.clear() + self._current_index = -1 + self._can_go_back = False + self._can_go_forward = False + + def destroy(self): + pass + + def onPause(self): + pass + + def onResume(self): + pass + + def pauseTimers(self): + pass + + def resumeTimers(self): + pass + + def getUrl(self) -> Optional[str]: + return self._current_url if self._current_url else None + + def getTitle(self) -> Optional[str]: + return None + + def evaluateJavascript(self, script: str, callback: Optional[Callable] = None): + if callback: + callback("") + + def addJavascriptInterface(self, obj: Any, name: str): + pass + + def removeJavascriptInterface(self, name: str): + pass + + def canGoBackOrForward(self, steps: int) -> bool: + target = self._current_index + steps + return 0 <= target < len(self._history) + + def goBackOrForward(self, steps: int): + target = self._current_index + steps + if 0 <= target < len(self._history): + self._current_index = target + self._current_url = self._history[target] + self._can_go_back = target > 0 + self._can_go_forward = target < len(self._history) - 1 + + def setDownloadListener(self, listener: Optional[Callable]): + self._download_listener = listener + + def setFindListener(self, listener: Optional[Callable]): + self._find_listener = listener + + class WebViewTransport: + def setWebView(self, web_view: "WebView"): + pass + def getWebView(self) -> Optional["WebView"]: + return None + + class HitTestResult: + UNKNOWN_TYPE = 0 + ANCHOR_TYPE = 1 + EDIT_TEXT_TYPE = 2 + IMAGE_TYPE = 3 + SRC_ANCHOR_TYPE = 4 + SRC_IMAGE_ANCHOR_TYPE = 5 + PHONE_TYPE = 6 + GEO_TYPE = 7 + EMAIL_TYPE = 8 + + def __init__(self): + self._type = WebView.HitTestResult.UNKNOWN_TYPE + self._extra = "" + + def getType(self) -> int: + return self._type + def getExtra(self) -> str: + return self._extra + + def getHitTestResult(self) -> HitTestResult: + return WebView.HitTestResult() + + def findAllAsync(self, find_str: str): + pass + + def findNext(self, forward: bool): + pass + + def clearMatches(self): + pass + + def zoomIn(self) -> bool: + return False + + def zoomOut(self) -> bool: + return False + + def setInitialScale(self, scale_in_percent: int): + pass + + def getScale(self) -> float: + return 1.0 + + def setPictureListener(self, listener: Optional[Callable]): + self._picture_listener = listener + + +class WebSettings(Stub): + """WebSettings — WebView 设置""" + + # 渲染模式 + RENDER_GOES_BROWSER = 0 + RENDER_GOES_SURFACE_VIEW = 1 + RENDER_GOES_DISPLAY_LIST = 2 + RENDER_GOES_GPU = 3 + RENDER_GOES_SURFACE = 4 + + # 布局算法 + LAYOUT_ALGORITHM_NORMAL = 0 + LAYOUT_ALGORITHM_SINGLE_COLUMN = 1 + LAYOUT_ALGORITHM_NARROW_COLUMNS = 2 + LAYOUT_ALGORITHM_TEXT_AUTOSIZING = 3 + + def __init__(self): + super().__init__() + self._javascript_enabled = False + self._dom_storage_enabled = False + self._allow_file_access = True + self._built_in_zoom_controls = True + self._display_zoom_controls = True + self._load_with_overview_mode = False + self._support_zoom = True + self._use_wide_view_port = False + self._database_enabled = False + self._allow_content_access = True + self._cache_mode = -1 # LOAD_DEFAULT + self._user_agent_string: str = "Mozilla/5.0 (Linux; Android 13)" + self._default_font_size = 16 + self._minimum_font_size = 8 + self._text_zoom = 100 + self._standard_font_family = "sans-serif" + self._serif_font_family = "serif" + self._sans_serif_font_family = "sans-serif" + self._fixed_font_family = "monospace" + self._cursive_font_family = "cursive" + self._fantasy_font_family = "fantasy" + self._default_encoding = "utf-8" + self._layout_algorithm = WebSettings.LAYOUT_ALGORITHM_NORMAL + self._block_network_image = False + self._block_network_loads = False + self._mixed_content_mode = 0 # MIXED_CONTENT_ALWAYS_ALLOW + self._offscreen_pre_raster = False + self._safe_browsing_enabled = True + + def setJavaScriptEnabled(self, enabled: bool): + self._javascript_enabled = enabled + + def getJavaScriptEnabled(self) -> bool: + return self._javascript_enabled + + def setDomStorageEnabled(self, enabled: bool): + self._dom_storage_enabled = enabled + + def getDomStorageEnabled(self) -> bool: + return self._dom_storage_enabled + + def setAllowFileAccess(self, allow: bool): + self._allow_file_access = allow + + def getAllowFileAccess(self) -> bool: + return self._allow_file_access + + def setBuiltInZoomControls(self, enabled: bool): + self._built_in_zoom_controls = enabled + + def getBuiltInZoomControls(self) -> bool: + return self._built_in_zoom_controls + + def setDisplayZoomControls(self, enabled: bool): + self._display_zoom_controls = enabled + + def getDisplayZoomControls(self) -> bool: + return self._display_zoom_controls + + def setSupportZoom(self, support: bool): + self._support_zoom = support + + def supportZoom(self) -> bool: + return self._support_zoom + + def setLoadWithOverviewMode(self, overview: bool): + self._load_with_overview_mode = overview + + def getLoadWithOverviewMode(self) -> bool: + return self._load_with_overview_mode + + def setUseWideViewPort(self, use: bool): + self._use_wide_view_port = use + + def getUseWideViewPort(self) -> bool: + return self._use_wide_view_port + + def setDatabaseEnabled(self, enabled: bool): + self._database_enabled = enabled + + def getDatabaseEnabled(self) -> bool: + return self._database_enabled + + def setAllowContentAccess(self, allow: bool): + self._allow_content_access = allow + + def getAllowContentAccess(self) -> bool: + return self._allow_content_access + + def setCacheMode(self, mode: int): + self._cache_mode = mode + + def getCacheMode(self) -> int: + return self._cache_mode + + LOAD_DEFAULT = -1 + LOAD_CACHE_ELSE_NETWORK = 1 + LOAD_NO_CACHE = 2 + LOAD_CACHE_ONLY = 3 + + def setUserAgentString(self, ua: str): + self._user_agent_string = ua + + def getUserAgentString(self) -> str: + return self._user_agent_string + + def setDefaultFontSize(self, size: int): + self._default_font_size = size + + def getDefaultFontSize(self) -> int: + return self._default_font_size + + def setMinimumFontSize(self, size: int): + self._minimum_font_size = size + + def getMinimumFontSize(self) -> int: + return self._minimum_font_size + + def setTextZoom(self, text_zoom: int): + self._text_zoom = text_zoom + + def getTextZoom(self) -> int: + return self._text_zoom + + def setStandardFontFamily(self, font: str): + self._standard_font_family = font + + def setSerifFontFamily(self, font: str): + self._serif_font_family = font + + def setSansSerifFontFamily(self, font: str): + self._sans_serif_font_family = font + + def setFixedFontFamily(self, font: str): + self._fixed_font_family = font + + def setCursiveFontFamily(self, font: str): + self._cursive_font_family = font + + def setFantasyFontFamily(self, font: str): + self._fantasy_font_family = font + + def setDefaultTextEncodingName(self, encoding: str): + self._default_encoding = encoding + + def getDefaultTextEncodingName(self) -> str: + return self._default_encoding + + def setLayoutAlgorithm(self, algorithm: int): + self._layout_algorithm = algorithm + + def getLayoutAlgorithm(self) -> int: + return self._layout_algorithm + + def setBlockNetworkImage(self, block: bool): + self._block_network_image = block + + def getBlockNetworkImage(self) -> bool: + return self._block_network_image + + def setBlockNetworkLoads(self, block: bool): + self._block_network_loads = block + + def getBlockNetworkLoads(self) -> bool: + return self._block_network_loads + + def setMixedContentMode(self, mode: int): + self._mixed_content_mode = mode + + def getMixedContentMode(self) -> int: + return self._mixed_content_mode + + MIXED_CONTENT_ALWAYS_ALLOW = 0 + MIXED_CONTENT_NEVER_ALLOW = 1 + MIXED_CONTENT_COMPATIBILITY_MODE = 2 + + def setOffscreenPreRaster(self, enabled: bool): + self._offscreen_pre_raster = enabled + + def getOffscreenPreRaster(self) -> bool: + return self._offscreen_pre_raster + + def setSafeBrowsingEnabled(self, enabled: bool): + self._safe_browsing_enabled = enabled + + def getSafeBrowsingEnabled(self) -> bool: + return self._safe_browsing_enabled + + def setNeedInitialFocus(self, flag: bool): + pass + + +# ═══════════════════════════════════════════════════════════════ +# ViewAnimator / ViewFlipper / ViewSwitcher etc. +# ═══════════════════════════════════════════════════════════════ + +class ViewAnimator(FrameLayout): + """ViewAnimator — 视图动画容器""" + + def __init__(self, context=None): + super().__init__(context) + self._which_child: int = 0 + self._animate_first_view: bool = False + self._in_animation: Any = None + self._out_animation: Any = None + + def setDisplayedChild(self, which_child: int): + if 0 <= which_child < self.getChildCount(): + self._which_child = which_child + + def getDisplayedChild(self) -> int: + return self._which_child + + def showNext(self): + if self._which_child < self.getChildCount() - 1: + self._which_child += 1 + + def showPrevious(self): + if self._which_child > 0: + self._which_child -= 1 + + def setInAnimation(self, in_animation: Any): + self._in_animation = in_animation + + def getInAnimation(self) -> Any: + return self._in_animation + + def setOutAnimation(self, out_animation: Any): + self._out_animation = out_animation + + def getOutAnimation(self) -> Any: + return self._out_animation + + def setAnimateFirstView(self, animate: bool): + self._animate_first_view = animate + + def getAnimateFirstView(self) -> bool: + return self._animate_first_view + + def getBaseline(self) -> int: + return -1 + + +class ViewFlipper(ViewAnimator): + """ViewFlipper — 视图翻转器""" + + def __init__(self, context=None): + super().__init__(context) + self._flip_interval: int = 3000 + self._auto_start: bool = False + self._running: bool = False + self._flip_timer: Any = None + + def setFlipInterval(self, milliseconds: int): + self._flip_interval = milliseconds + + def getFlipInterval(self) -> int: + return self._flip_interval + + def setAutoStart(self, auto_start: bool): + self._auto_start = auto_start + + def isAutoStart(self) -> bool: + return self._auto_start + + def startFlipping(self): + self._running = True + + def stopFlipping(self): + self._running = False + + def isFlipping(self) -> bool: + return self._running + + def onDetachedFromWindow(self): + super().onDetachedFromWindow() + self._running = False + + def onAttachedToWindow(self): + super().onAttachedToWindow() + if self._auto_start: + self._running = True + + +class ViewSwitcher(ViewAnimator): + """ViewSwitcher — 视图切换器""" + + def __init__(self, context=None): + super().__init__(context) + self._factory: Optional[Callable] = None + + class ViewFactory: + def makeView(self) -> View: + return View() + + def setFactory(self, factory: ViewFactory): + self._factory = factory + + def getCurrentView(self) -> Optional[View]: + return self.getChildAt(self._which_child) + + def getNextView(self) -> Optional[View]: + next_index = self._which_child + 1 + if next_index < self.getChildCount(): + return self.getChildAt(next_index) + return None + + def setInAnimation(self, in_animation: Any): + super().setInAnimation(in_animation) + + def setOutAnimation(self, out_animation: Any): + super().setOutAnimation(out_animation) + + +class ImageSwitcher(ViewSwitcher): + """ImageSwitcher — 图片切换器""" + + def setImageDrawable(self, drawable: Any): + pass + + def setImageResource(self, resid: int): + pass + + def setImageURI(self, uri: Any): + pass + + def setImageBitmap(self, bitmap: Any): + pass + + +class TextSwitcher(ViewSwitcher): + """TextSwitcher — 文本切换器""" + + def setCurrentText(self, text: str): + if self.getChildCount() > 0: + child = self.getChildAt(0) + if hasattr(child, "setText"): + child.setText(text) + + def setText(self, text: str): + self.setCurrentText(text) + + +class AdapterViewAnimator(AdapterView): + """AdapterViewAnimator — 适配器视图动画器""" + + def __init__(self, context=None): + super().__init__(context) + self._in_animation: Any = None + self._out_animation: Any = None + self._displayed_child: int = 0 + self._loop_views: bool = False + + def setDisplayedChild(self, which_child: int): + self._displayed_child = which_child + + def getDisplayedChild(self) -> int: + return self._displayed_child + + def showNext(self): + self._displayed_child = (self._displayed_child + 1) % max(1, self.getCount()) + + def showPrevious(self): + last = max(1, self.getCount()) + self._displayed_child = (self._displayed_child - 1) % last + + def setInAnimation(self, in_animation: Any): + self._in_animation = in_animation + + def getInAnimation(self) -> Any: + return self._in_animation + + def setOutAnimation(self, out_animation: Any): + self._out_animation = out_animation + + def getOutAnimation(self) -> Any: + return self._out_animation + + def getCurrentView(self) -> Optional[View]: + return self.getChildAt(self._displayed_child) + + def getBaseline(self) -> int: + return -1 + + def getCount(self) -> int: + if self._adapter: + return self._adapter.getCount() + return 0 + + +class AdapterViewFlipper(AdapterViewAnimator): + """AdapterViewFlipper — 适配器视图翻转器""" + + def __init__(self, context=None): + super().__init__(context) + self._flip_interval: int = 10000 + self._auto_start: bool = False + self._running: bool = False + + def setFlipInterval(self, milliseconds: int): + self._flip_interval = milliseconds + + def getFlipInterval(self) -> int: + return self._flip_interval + + def startFlipping(self): + self._running = True + + def stopFlipping(self): + self._running = False + + def isFlipping(self) -> bool: + return self._running + + def setAutoStart(self, auto_start: bool): + self._auto_start = auto_start + + def isAutoStart(self) -> bool: + return self._auto_start + + +class StackView(AdapterViewAnimator): + """StackView — 栈视图""" + pass + + +# ═══════════════════════════════════════════════════════════════ +# Adapters +# ═══════════════════════════════════════════════════════════════ + +class BaseAdapter(Stub): + """BaseAdapter — 基础适配器""" + + def __init__(self): + super().__init__() + self._data_set_observable: Any = None + + def getCount(self) -> int: + return 0 + + def getItem(self, position: int) -> Any: + return None + + def getItemId(self, position: int) -> int: + return position + + def getView(self, position: int, convert_view: Optional[View], parent: Optional[ViewGroup]) -> View: + return View() + + def getItemViewType(self, position: int) -> int: + return 0 + + def getViewTypeCount(self) -> int: + return 1 + + def hasStableIds(self) -> bool: + return False + + def isEmpty(self) -> bool: + return self.getCount() == 0 + + def areAllItemsEnabled(self) -> bool: + return True + + def isEnabled(self, position: int) -> bool: + return True + + def getDropDownView(self, position: int, convert_view: Optional[View], + parent: Optional[ViewGroup]) -> View: + return self.getView(position, convert_view, parent) + + def notifyDataSetChanged(self): + pass + + def notifyDataSetInvalidated(self): + pass + + def registerDataSetObserver(self, observer: Any): + pass + + def unregisterDataSetObserver(self, observer: Any): + pass + + +class ArrayAdapter(BaseAdapter): + """ArrayAdapter — 数组适配器""" + + def __init__(self, context: Any, resource: int, objects: Optional[List[Any]] = None): + super().__init__() + self._context = context + self._resource = resource + self._drop_down_resource = resource + self._objects: List[Any] = list(objects) if objects is not None else [] + self._field_id = 0 + self._notify_on_change = True + + def getCount(self) -> int: + return len(self._objects) + + def getItem(self, position: int) -> Any: + if 0 <= position < len(self._objects): + return self._objects[position] + return None + + def getPosition(self, item: Any) -> int: + try: + return self._objects.index(item) + except ValueError: + return -1 + + def getView(self, position: int, convert_view: Optional[View], + parent: Optional[ViewGroup]) -> View: + if convert_view is not None: + tv = convert_view + else: + tv = TextView(self._context) + if hasattr(tv, "setText"): + tv.setText(str(self.getItem(position) if self.getItem(position) is not None else "")) + return tv + + def add(self, obj: Any): + self._objects.append(obj) + if self._notify_on_change: + self.notifyDataSetChanged() + + def addAll(self, *items: Any): + for item in items: + self._objects.append(item) + if self._notify_on_change: + self.notifyDataSetChanged() + + def insert(self, obj: Any, index: int): + self._objects.insert(index, obj) + if self._notify_on_change: + self.notifyDataSetChanged() + + def remove(self, obj: Any): + if obj in self._objects: + self._objects.remove(obj) + if self._notify_on_change: + self.notifyDataSetChanged() + + def clear(self): + self._objects.clear() + if self._notify_on_change: + self.notifyDataSetChanged() + + def sort(self, comparator: Callable): + self._objects.sort(key=comparator) + if self._notify_on_change: + self.notifyDataSetChanged() + + def setNotifyOnChange(self, notify_on_change: bool): + self._notify_on_change = notify_on_change + + def getContext(self): + return self._context + + def getCount(self) -> int: + return len(self._objects) + + def setDropDownViewResource(self, resource: int): + self._drop_down_resource = resource + + def getDropDownViewResource(self) -> int: + return self._drop_down_resource + + +class SimpleAdapter(BaseAdapter): + """SimpleAdapter — 简单适配器""" + + def __init__(self, context: Any, data: List[Dict[str, Any]], resource: int, + from_cols: List[str], to_ids: List[int]): + super().__init__() + self._context = context + self._data = data + self._resource = resource + self._from = from_cols + self._to = to_ids + self._drop_down_resource = resource + + def getCount(self) -> int: + return len(self._data) + + def getItem(self, position: int) -> Any: + if 0 <= position < len(self._data): + return self._data[position] + return None + + def getView(self, position: int, convert_view: Optional[View], + parent: Optional[ViewGroup]) -> View: + if convert_view is not None: + v = convert_view + else: + v = View(self._context) + return v + + def setDropDownViewResource(self, resource: int): + self._drop_down_resource = resource + + +class CursorAdapter(BaseAdapter): + """CursorAdapter — 游标适配器""" + + FLAG_AUTO_REQUERY = 0x01 + FLAG_REGISTER_CONTENT_OBSERVER = 0x02 + + def __init__(self, context: Any, c: Any, flags: int = FLAG_AUTO_REQUERY): + super().__init__() + self._context = context + self._cursor = c + self._flags = flags + + def getCount(self) -> int: + return 0 + + def getItem(self, position: int) -> Any: + return None + + def getView(self, position: int, convert_view: Optional[View], + parent: Optional[ViewGroup]) -> View: + return View(self._context) + + def bindView(self, view: View, context: Any, cursor: Any): + pass + + def newView(self, context: Any, cursor: Any, parent: ViewGroup) -> View: + return View(context) + + def getCursor(self) -> Any: + return self._cursor + + def changeCursor(self, cursor: Any): + self._cursor = cursor + self.notifyDataSetChanged() + + def swapCursor(self, new_cursor: Any) -> Any: + old = self._cursor + self._cursor = new_cursor + self.notifyDataSetChanged() + return old + + +# ═══════════════════════════════════════════════════════════════ +# Spinner +# ═══════════════════════════════════════════════════════════════ + +class Spinner(AdapterView): + """Spinner — 下拉选择器""" + + MODE_DIALOG = 0 + MODE_DROPDOWN = 1 + + def __init__(self, context=None, mode: int = MODE_DROPDOWN): + super().__init__(context) + self._mode = mode + self._prompt: str = "" + self._popup: Any = None + self._on_item_selected_listener: Optional[Callable] = None + + class OnItemSelectedListener: + def onItemSelected(self, parent: AdapterView, view: View, position: int, id_: int): + pass + def onNothingSelected(self, parent: AdapterView): + pass + + def setOnItemSelectedListener(self, listener: Optional[OnItemSelectedListener]): + self._on_item_selected_listener = listener + + def getOnItemSelectedListener(self) -> Optional[OnItemSelectedListener]: + return self._on_item_selected_listener + + def setSelection(self, position: int, animate: bool = True): + super().setSelection(position) + + def getSelectedItem(self) -> Any: + return super().getSelectedItem() + + def getSelectedItemPosition(self) -> int: + return self._selected_position + + def getSelectedView(self) -> Optional[View]: + return None + + def setPrompt(self, prompt: str): + self._prompt = prompt + + def getPrompt(self) -> str: + return self._prompt + + def setPopupBackgroundDrawable(self, drawable: Any): + pass + + def getPopupBackgroundDrawable(self) -> Any: + return None + + def performClick(self) -> bool: + return True + + +# ═══════════════════════════════════════════════════════════════ +# AutoCompleteTextView +# ═══════════════════════════════════════════════════════════════ + +class AutoCompleteTextView(EditText): + """AutoCompleteTextView — 自动完成文本""" + + def __init__(self, context=None): + super().__init__(context) + self._threshold: int = 2 + self._completion_hint: str = "" + self._drop_down_anchor: Optional[View] = None + self._drop_down_horizontal_offset: int = 0 + self._drop_down_vertical_offset: int = 0 + self._drop_down_width: int = 0 + self._drop_down_height: int = 0 + self._on_item_click_listener: Optional[Callable] = None + self._on_dismiss_listener: Optional[Callable] = None + self._validator: Optional[Callable] = None + + def setThreshold(self, threshold: int): + self._threshold = max(1, threshold) + + def getThreshold(self) -> int: + return self._threshold + + def setAdapter(self, adapter: Any): + self._adapter = adapter + + def getAdapter(self) -> Any: + return self._adapter + + def setOnItemClickListener(self, listener: Optional[Callable]): + self._on_item_click_listener = listener + + def getOnItemClickListener(self) -> Optional[Callable]: + return self._on_item_click_listener + + def setCompletionHint(self, hint: str): + self._completion_hint = hint + + def getCompletionHint(self) -> str: + return self._completion_hint + + def setDropDownAnchor(self, anchor_id: int): + pass + + def setDropDownHorizontalOffset(self, offset: int): + self._drop_down_horizontal_offset = offset + + def getDropDownHorizontalOffset(self) -> int: + return self._drop_down_horizontal_offset + + def setDropDownVerticalOffset(self, offset: int): + self._drop_down_vertical_offset = offset + + def getDropDownVerticalOffset(self) -> int: + return self._drop_down_vertical_offset + + def setDropDownWidth(self, width: int): + self._drop_down_width = width + + def getDropDownWidth(self) -> int: + return self._drop_down_width + + def showDropDown(self): + pass + + def dismissDropDown(self): + pass + + def isDropDownShowing(self) -> bool: + return False + + def enoughToFilter(self) -> bool: + return len(self._text) >= self._threshold + + def setValidator(self, validator: Optional[Callable]): + self._validator = validator + + def getValidator(self) -> Optional[Callable]: + return self._validator + + def performValidation(self): + pass + + def setOnDismissListener(self, listener: Optional[Callable]): + self._on_dismiss_listener = listener + + def performFiltering(self, text: str, key_code: int): + pass + + def onFilterComplete(self, count: int): + pass + + +class MultiAutoCompleteTextView(AutoCompleteTextView): + """MultiAutoCompleteTextView — 多值自动完成文本""" + + def __init__(self, context=None): + super().__init__(context) + self._tokenizer: Optional[Callable] = None + + class CommaTokenizer: + def tokenize(self, text: str) -> List[str]: + return text.split(",") + def findTokenStart(self, text: str, cursor: int) -> int: + return text.rfind(",", 0, cursor) + 1 + def findTokenEnd(self, text: str, cursor: int) -> int: + next_comma = text.find(",", cursor) + return next_comma if next_comma >= 0 else len(text) + def terminateToken(self, text: str) -> str: + return text + "," + + def setTokenizer(self, tokenizer: Any): + self._tokenizer = tokenizer + + def getTokenizer(self) -> Any: + return self._tokenizer + + +# ═══════════════════════════════════════════════════════════════ +# DatePicker / TimePicker / CalendarView / NumberPicker +# ═══════════════════════════════════════════════════════════════ + +class DatePicker(FrameLayout): + """DatePicker — 日期选择器""" + + def __init__(self, context=None): + super().__init__(context) + self._year: int = 2024 + self._month: int = 0 # 0-based + self._day_of_month: int = 1 + self._min_date: int = 0 + self._max_date: int = 0 + self._spinners_shown: bool = True + self._calendar_view_shown: bool = False + self._on_date_changed_listener: Optional[Callable] = None + self._calendar_view: Optional[CalendarView] = None + + class OnDateChangedListener: + def onDateChanged(self, view: "DatePicker", year: int, month_of_year: int, day_of_month: int): + pass + + def init(self, year: int, month: int, day_of_month: int, + listener: Optional[OnDateChangedListener] = None): + self._year = year + self._month = month + self._day_of_month = day_of_month + self._on_date_changed_listener = listener + if listener: + listener.onDateChanged(self, year, month, day_of_month) + + def getYear(self) -> int: + return self._year + + def getMonth(self) -> int: + return self._month + + def getDayOfMonth(self) -> int: + return self._day_of_month + + def setMinDate(self, min_date: int): + self._min_date = min_date + + def getMinDate(self) -> int: + return self._min_date + + def setMaxDate(self, max_date: int): + self._max_date = max_date + + def getMaxDate(self) -> int: + return self._max_date + + def setSpinnersShown(self, shown: bool): + self._spinners_shown = shown + + def setCalendarViewShown(self, shown: bool): + self._calendar_view_shown = shown + + def getCalendarView(self) -> Optional["CalendarView"]: + return self._calendar_view + + def setOnDateChangedListener(self, listener: Optional[OnDateChangedListener]): + self._on_date_changed_listener = listener + + def updateDate(self, year: int, month: int, day_of_month: int): + self._year = year + self._month = month + self._day_of_month = day_of_month + if self._on_date_changed_listener: + self._on_date_changed_listener.onDateChanged(self, year, month, day_of_month) + + +class TimePicker(FrameLayout): + """TimePicker — 时间选择器""" + + MODE_CLOCK = 0 + MODE_SPINNER = 1 + + def __init__(self, context=None, mode: int = MODE_CLOCK): + super().__init__(context) + self._current_hour: int = 12 + self._current_minute: int = 0 + self._is24_hour_view: Optional[bool] = None # None = system default + self._mode = mode + self._on_time_changed_listener: Optional[Callable] = None + + class OnTimeChangedListener: + def onTimeChanged(self, view: "TimePicker", hour_of_day: int, minute: int): + pass + + def setOnTimeChangedListener(self, listener: Optional[OnTimeChangedListener]): + self._on_time_changed_listener = listener + + def getOnTimeChangedListener(self) -> Optional[OnTimeChangedListener]: + return self._on_time_changed_listener + + def getCurrentHour(self) -> int: + return self._current_hour + + def setCurrentHour(self, current_hour: int): + self._current_hour = current_hour % 24 + if self._on_time_changed_listener: + self._on_time_changed_listener.onTimeChanged(self, self._current_hour, self._current_minute) + + def getCurrentMinute(self) -> int: + return self._current_minute + + def setCurrentMinute(self, current_minute: int): + self._current_minute = current_minute % 60 + if self._on_time_changed_listener: + self._on_time_changed_listener.onTimeChanged(self, self._current_hour, self._current_minute) + + def setIs24HourView(self, is24_hour_view: Optional[bool]): + self._is24_hour_view = is24_hour_view + + def is24HourView(self) -> bool: + if self._is24_hour_view is not None: + return self._is24_hour_view + return False + + def getMode(self) -> int: + return self._mode + + def setHour(self, hour: int): + self.setCurrentHour(hour) + + def getHour(self) -> int: + return self.getCurrentHour() + + def setMinute(self, minute: int): + self.setCurrentMinute(minute) + + def getMinute(self) -> int: + return self.getCurrentMinute() + + +class CalendarView(FrameLayout): + """CalendarView — 日历视图""" + + def __init__(self, context=None): + super().__init__(context) + self._date: int = 0 + self._min_date: int = 0 + self._max_date: int = 0 + self._first_day_of_week: int = 1 # Sunday=1 + self._week_separator: bool = False + self._on_date_change_listener: Optional[Callable] = None + self._shown_week_count: int = 6 + + class OnDateChangeListener: + def onSelectedDayChange(self, view: "CalendarView", year: int, month: int, day_of_month: int): + pass + + def setOnDateChangeListener(self, listener: Optional[OnDateChangeListener]): + self._on_date_change_listener = listener + + def getDate(self) -> int: + return self._date + + def setDate(self, date: int, animate: bool = True, center: bool = True): + self._date = date + + def getMinDate(self) -> int: + return self._min_date + + def setMinDate(self, min_date: int): + self._min_date = min_date + + def getMaxDate(self) -> int: + return self._max_date + + def setMaxDate(self, max_date: int): + self._max_date = max_date + + def getFirstDayOfWeek(self) -> int: + return self._first_day_of_week + + def setFirstDayOfWeek(self, first_day_of_week: int): + self._first_day_of_week = first_day_of_week + + def setWeekSeparatorDrawable(self, drawable: Any): + self._week_separator = True + + def getShownWeekCount(self) -> int: + return self._shown_week_count + + def setShownWeekCount(self, count: int): + self._shown_week_count = count + + +class NumberPicker(ViewGroup): + """NumberPicker — 数字选择器""" + + def __init__(self, context=None): + super().__init__(context) + self._min_value: int = 0 + self._max_value: int = 100 + self._value: int = 0 + self._displayed_values: Optional[List[str]] = None + self._on_value_change_listener: Optional[Callable] = None + self._on_scroll_listener: Optional[Callable] = None + self._wrap_selector_wheel: bool = True + self._selection_divider: bool = True + + class OnValueChangeListener: + def onValueChange(self, picker: "NumberPicker", old_val: int, new_val: int): + pass + + class OnScrollListener: + def onScrollStateChange(self, picker: "NumberPicker", state: int): + pass + + SCROLL_STATE_IDLE = 0 + SCROLL_STATE_TOUCH_SCROLL = 1 + SCROLL_STATE_FLING = 2 + + def setMinValue(self, min_value: int): + self._min_value = min_value + if self._value < self._min_value: + self._value = self._min_value + + def getMinValue(self) -> int: + return self._min_value + + def setMaxValue(self, max_value: int): + self._max_value = max_value + if self._value > self._max_value: + self._value = self._max_value + + def getMaxValue(self) -> int: + return self._max_value + + def setValue(self, value: int): + old_value = self._value + self._value = max(self._min_value, min(self._max_value, value)) + if self._on_value_change_listener and old_value != self._value: + self._on_value_change_listener.onValueChange(self, old_value, self._value) + + def getValue(self) -> int: + return self._value + + def setDisplayedValues(self, displayed_values: Optional[List[str]]): + self._displayed_values = displayed_values + + def getDisplayedValues(self) -> Optional[List[str]]: + return self._displayed_values + + def setOnValueChangedListener(self, listener: Optional[OnValueChangeListener]): + self._on_value_change_listener = listener + + def setOnScrollListener(self, listener: Optional[OnScrollListener]): + self._on_scroll_listener = listener + + def setWrapSelectorWheel(self, wrap: bool): + self._wrap_selector_wheel = wrap + + def getWrapSelectorWheel(self) -> bool: + return self._wrap_selector_wheel + + def setSelectionDivider(self, divider: Any): + self._selection_divider = True + + +# ═══════════════════════════════════════════════════════════════ +# VideoView / MediaController +# ═══════════════════════════════════════════════════════════════ + +class VideoView(SurfaceView): + """VideoView — 视频播放视图""" + + def __init__(self, context=None): + super().__init__(context) + self._video_path: Optional[str] = None + self._uri: Any = None + self._media_controller: Optional["MediaController"] = None + self._on_prepared_listener: Optional[Callable] = None + self._on_completion_listener: Optional[Callable] = None + self._on_error_listener: Optional[Callable] = None + self._is_playing: bool = False + self._current_position: int = 0 + self._duration: int = 0 + self._can_seek_back: bool = True + self._can_seek_forward: bool = True + self._can_pause: bool = True + self._video_width: int = 0 + self._video_height: int = 0 + + def setVideoPath(self, path: str): + self._video_path = path + + def setVideoURI(self, uri: Any): + self._uri = uri + + def setMediaController(self, controller: "MediaController"): + self._media_controller = controller + + def setOnPreparedListener(self, listener: Optional[Callable]): + self._on_prepared_listener = listener + + def setOnCompletionListener(self, listener: Optional[Callable]): + self._on_completion_listener = listener + + def setOnErrorListener(self, listener: Optional[Callable]): + self._on_error_listener = listener + + def start(self): + self._is_playing = True + + def stopPlayback(self): + self._is_playing = False + self._current_position = 0 + + def pause(self): + self._is_playing = False + + def resume(self): + self._is_playing = True + + def seekTo(self, msec: int): + self._current_position = max(0, min(msec, self._duration)) + + def getCurrentPosition(self) -> int: + return self._current_position + + def getDuration(self) -> int: + return self._duration + + def isPlaying(self) -> bool: + return self._is_playing + + def canSeekForward(self) -> bool: + return self._can_seek_forward + + def canSeekBackward(self) -> bool: + return self._can_seek_back + + def canPause(self) -> bool: + return self._can_pause + + def getBufferPercentage(self) -> int: + return 100 + + def resolveAdjustedSize(self, desired_size: int, measure_spec: int) -> int: + from .view import MeasureSpec + return MeasureSpec.getSize(measure_spec) + + def setVideoWidth(self, video_width: int): + self._video_width = video_width + + def setVideoHeight(self, video_height: int): + self._video_height = video_height + + @property + def videoWidth(self) -> int: + return self._video_width + + @property + def videoHeight(self) -> int: + return self._video_height + + +class MediaController(FrameLayout): + """MediaController — 媒体控制器""" + + def __init__(self, context=None, target: Optional[VideoView] = None): + super().__init__(context) + self._target = target + self._anchor_view: Optional[View] = None + self._is_showing: bool = False + self._set_up_listener: Optional[Callable] = None + + def setMediaPlayer(self, player: "MediaController.MediaPlayerControl"): + pass + + def setAnchorView(self, view: View): + self._anchor_view = view + + def show(self, timeout: int = 3000): + self._is_showing = True + + def hide(self): + self._is_showing = False + + def isShowing(self) -> bool: + return self._is_showing + + def setEnabled(self, enabled: bool): + super().setEnabled(enabled) + + def setOnPrepareListener(self, listener: Optional[Callable]): + self._set_up_listener = listener + + class MediaPlayerControl: + def start(self): + pass + def pause(self): + pass + def getDuration(self) -> int: + return 0 + def getCurrentPosition(self) -> int: + return 0 + def seekTo(self, pos: int): + pass + def isPlaying(self) -> bool: + return False + def getBufferPercentage(self) -> int: + return 0 + def canPause(self) -> bool: + return False + def canSeekBackward(self) -> bool: + return False + def canSeekForward(self) -> bool: + return False + def getAudioSessionId(self) -> int: + return 0 + + +# ═══════════════════════════════════════════════════════════════ +# Toast +# ═══════════════════════════════════════════════════════════════ + +class Toast(Stub): + """Toast — 提示消息""" + + LENGTH_SHORT = 0 + LENGTH_LONG = 1 + + def __init__(self, context=None): + super().__init__() + if context is None: + context = android_context + self._context = context + self._duration = Toast.LENGTH_SHORT + self._gravity = Gravity.NO_GRAVITY + self._x_offset: int = 0 + self._y_offset: int = 0 + self._view: Optional[View] = None + self._text: str = "" + self._horizontal_margin: float = 0.0 + self._vertical_margin: float = 0.0 + self._next_view: Optional[View] = None + + @staticmethod + def makeText(context: Any, text: str, duration: int) -> "Toast": + toast = Toast(context) + toast._text = text + toast._duration = duration + return toast + + def show(self): + pass + + def cancel(self): + pass + + def setGravity(self, gravity: int, x_offset: int, y_offset: int): + self._gravity = gravity + self._x_offset = x_offset + self._y_offset = y_offset + + def setDuration(self, duration: int): + self._duration = duration + + def getDuration(self) -> int: + return self._duration + + def setView(self, view: View): + self._view = view + + def getView(self) -> Optional[View]: + return self._view + + def setMargin(self, horizontal_margin: float, vertical_margin: float): + self._horizontal_margin = horizontal_margin + self._vertical_margin = vertical_margin + + def getHorizontalMargin(self) -> float: + return self._horizontal_margin + + def getVerticalMargin(self) -> float: + return self._vertical_margin + + def setText(self, text: str): + self._text = text + + def setNextAnnouncementView(self, view: View): + self._next_view = view + + def getNextAnnouncementView(self) -> Optional[View]: + return self._next_view + + def isTouchable(self) -> bool: + return False + + +# ═══════════════════════════════════════════════════════════════ +# PopupMenu / PopupWindow +# ═══════════════════════════════════════════════════════════════ + +class PopupMenu(Stub): + """PopupMenu — 弹出菜单""" + + def __init__(self, context: Any, anchor: View, gravity: int = Gravity.NO_GRAVITY): + super().__init__() + self._context = context + self._anchor = anchor + self._gravity = gravity + self._menu: "PopupMenu.Menu" = PopupMenu.Menu() + self._on_menu_item_click_listener: Optional[Callable] = None + self._on_dismiss_listener: Optional[Callable] = None + + class Menu(Stub): + """PopupMenu.Menu — 弹出菜单项列表""" + + def __init__(self): + super().__init__() + self._items: List[Dict] = [] + + def add(self, title: str) -> Any: + item_id = len(self._items) + self._items.append({"id": item_id, "title": title, "enabled": True}) + return item_id + + def findItem(self, id_: int) -> Optional[Dict]: + for item in self._items: + if item["id"] == id_: + return item + return None + + def removeItem(self, id_: int): + for i, item in enumerate(self._items): + if item["id"] == id_: + self._items.pop(i) + break + + def size(self) -> int: + return len(self._items) + + def getItem(self, index: int) -> Optional[Dict]: + if 0 <= index < len(self._items): + return self._items[index] + return None + + def clear(self): + self._items.clear() + + def setOnMenuItemClickListener(self, listener: Optional[Callable]): + pass + + def getMenu(self) -> "PopupMenu.Menu": + return self._menu + + def inflate(self, menu_res_id: int): + pass + + def show(self): + pass + + def dismiss(self): + pass + + def setOnMenuItemClickListener(self, listener: Optional[Callable]): + self._on_menu_item_click_listener = listener + + def setOnDismissListener(self, listener: Optional[Callable]): + self._on_dismiss_listener = listener + + def getDragToOpenListener(self) -> Optional[Callable]: + return None + + def setForceShowIcon(self, force_show: bool): + pass + + +class PopupWindow(Stub): + """PopupWindow — 弹出窗口""" + + def __init__(self, content_view: Optional[View] = None, + width: int = ViewGroup.LayoutParams.WRAP_CONTENT, + height: int = ViewGroup.LayoutParams.WRAP_CONTENT, + focusable: bool = True): + super().__init__() + self._content_view = content_view + self._width = width + self._height = height + self._focusable = focusable + self._is_showing: bool = False + self._outside_touchable: bool = False + self._touchable: bool = True + self._background_drawable: Any = None + self._animation_style: int = -1 + self._elevation: float = 0.0 + self._input_method_mode: int = -1 + self._soft_input_mode: int = -1 + self._on_dismiss_listener: Optional[Callable] = None + self._window_layout_type: int = 1000 # TYPE_APPLICATION_PANEL + self._overlap_anchor: bool = True + self._clip_to_screen: bool = True + self._split_enabled: bool = False + self._width_mode: int = 0 + self._height_mode: int = 0 + + def showAsDropDown(self, anchor: View, x_off: int = 0, y_off: int = 0, + gravity: int = Gravity.NO_GRAVITY): + self._is_showing = True + + def showAtLocation(self, parent: View, gravity: int, x: int, y: int): + self._is_showing = True + + def dismiss(self): + self._is_showing = False + if self._on_dismiss_listener: + self._on_dismiss_listener() + + def isShowing(self) -> bool: + return self._is_showing + + def setContentView(self, content_view: View): + self._content_view = content_view + + def getContentView(self) -> Optional[View]: + return self._content_view + + def setWidth(self, width: int): + self._width = width + + def getWidth(self) -> int: + return self._width + + def setHeight(self, height: int): + self._height = height + + def getHeight(self) -> int: + return self._height + + def setFocusable(self, focusable: bool): + self._focusable = focusable + + def isFocusable(self) -> bool: + return self._focusable + + def setOutsideTouchable(self, touchable: bool): + self._outside_touchable = touchable + + def isOutsideTouchable(self) -> bool: + return self._outside_touchable + + def setTouchable(self, touchable: bool): + self._touchable = touchable + + def isTouchable(self) -> bool: + return self._touchable + + def setBackgroundDrawable(self, background: Any): + self._background_drawable = background + + def getBackground(self) -> Any: + return self._background_drawable + + def setAnimationStyle(self, anim_style: int): + self._animation_style = anim_style + + def getAnimationStyle(self) -> int: + return self._animation_style + + def setElevation(self, elevation: float): + self._elevation = elevation + + def getElevation(self) -> float: + return self._elevation + + def setOnDismissListener(self, listener: Optional[Callable]): + self._on_dismiss_listener = listener + + def setTouchInterceptor(self, interceptor: Optional[Callable]): + pass + + def setClippingEnabled(self, enabled: bool): + self._clip_to_screen = enabled + + def isClippingEnabled(self) -> bool: + return self._clip_to_screen + + def setSplitTouchEnabled(self, enabled: bool): + self._split_enabled = enabled + + def isSplitTouchEnabled(self) -> bool: + return self._split_enabled + + def setWindowLayoutType(self, layout_type: int): + self._window_layout_type = layout_type + + def getWindowLayoutType(self) -> int: + return self._window_layout_type + + def setSoftInputMode(self, mode: int): + self._soft_input_mode = mode + + def getSoftInputMode(self) -> int: + return self._soft_input_mode + + def setInputMethodMode(self, mode: int): + self._input_method_mode = mode + + def getInputMethodMode(self) -> int: + return self._input_method_mode + + INPUT_METHOD_FROM_FOCUSABLE = 0 + INPUT_METHOD_NEEDED = 1 + INPUT_METHOD_NOT_NEEDED = 2 + + +# ═══════════════════════════════════════════════════════════════ +# Toolbar +# ═══════════════════════════════════════════════════════════════ + +class Toolbar(ViewGroup): + """Toolbar — 工具栏""" + + def __init__(self, context=None): + super().__init__(context) + self._title: str = "" + self._subtitle: str = "" + self._navigation_icon: Any = None + self._navigation_content_description: str = "" + self._logo: Any = None + self._logo_description: str = "" + self._title_text_color: int = 0 + self._subtitle_text_color: int = 0 + self._collapse_icon: Any = None + self._menu: Any = None + self._on_menu_item_click_listener: Optional[Callable] = None + self._navigation_on_click_listener: Optional[Callable] = None + self._popup_theme: int = 0 + self._content_inset_start: int = 16 + self._content_inset_end: int = 16 + self._title_margin_start: int = 0 + + def setTitle(self, title: str): + self._title = title + + def getTitle(self) -> str: + return self._title + + def setSubtitle(self, subtitle: str): + self._subtitle = subtitle + + def getSubtitle(self) -> str: + return self._subtitle + + def setNavigationIcon(self, icon: Any): + self._navigation_icon = icon + + def getNavigationIcon(self) -> Any: + return self._navigation_icon + + def setNavigationContentDescription(self, description: str): + self._navigation_content_description = description + + def getNavigationContentDescription(self) -> str: + return self._navigation_content_description + + def setLogo(self, logo: Any): + self._logo = logo + + def getLogo(self) -> Any: + return self._logo + + def setLogoDescription(self, description: str): + self._logo_description = description + + def getLogoDescription(self) -> str: + return self._logo_description + + def setTitleTextColor(self, color: int): + self._title_text_color = color + + def setSubtitleTextColor(self, color: int): + self._subtitle_text_color = color + + def inflateMenu(self, menu_res_id: int): + pass + + def getMenu(self) -> Any: + return self._menu + + def setOnMenuItemClickListener(self, listener: Optional[Callable]): + self._on_menu_item_click_listener = listener + + def setNavigationOnClickListener(self, listener: Optional[Callable]): + self._navigation_on_click_listener = listener + + def setCollapseIcon(self, icon: Any): + self._collapse_icon = icon + + def getCollapseIcon(self) -> Any: + return self._collapse_icon + + def setPopupTheme(self, res_id: int): + self._popup_theme = res_id + + def getPopupTheme(self) -> int: + return self._popup_theme + + def setContentInsetsRelative(self, content_inset_start: int, content_inset_end: int): + self._content_inset_start = content_inset_start + self._content_inset_end = content_inset_end + + def getContentInsetStart(self) -> int: + return self._content_inset_start + + def getContentInsetEnd(self) -> int: + return self._content_inset_end + + def collapseActionView(self): + pass + + def dismissPopupMenus(self): + pass + + def isOverflowMenuShowing(self) -> bool: + return False + + def showOverflowMenu(self) -> bool: + return False + + def hideOverflowMenu(self) -> bool: + return False + + def getOverflowIcon(self) -> Any: + return None + + def setOverflowIcon(self, icon: Any): + pass + + +class ActionMenuView(LinearLayout): + """ActionMenuView — 操作菜单视图""" + pass + + +# ═══════════════════════════════════════════════════════════════ +# TabHost / TabWidget +# ═══════════════════════════════════════════════════════════════ + +class TabHost(FrameLayout): + """TabHost — 标签主机""" + + def __init__(self, context=None): + super().__init__(context) + self._tab_widget: Optional["TabWidget"] = None + self._tab_content: Optional[FrameLayout] = None + self._tabs: List["TabHost.TabSpec"] = [] + self._current_tab: int = 0 + self._on_tab_changed_listener: Optional[Callable] = None + self._local_activity_manager: Any = None + + class TabSpec(Stub): + """TabHost.TabSpec — 标签规格""" + + def __init__(self, tag: str): + super().__init__() + self._tag = tag + self._indicator: Any = None + self._content: Any = None + self._content_view: Optional[View] = None + + def setIndicator(self, indicator: Any) -> "TabHost.TabSpec": + self._indicator = indicator + return self + + def setContent(self, content: Any) -> "TabHost.TabSpec": + self._content = content + return self + + def setContent(self, view_id: int) -> "TabHost.TabSpec": + return self + + def setContent(self, view: View) -> "TabHost.TabSpec": + self._content_view = view + return self + + def getTag(self) -> str: + return self._tag + + def getIndicator(self) -> Any: + return self._indicator + + class OnTabChangeListener: + def onTabChanged(self, tab_id: str): + pass + + def setup(self): + pass + + def newTabSpec(self, tag: str) -> "TabHost.TabSpec": + spec = TabHost.TabSpec(tag) + self._tabs.append(spec) + return spec + + def addTab(self, tab_spec: "TabHost.TabSpec"): + if tab_spec not in self._tabs: + self._tabs.append(tab_spec) + + def setCurrentTab(self, index: int): + if 0 <= index < len(self._tabs): + self._current_tab = index + + def setCurrentTabByTag(self, tag: str): + for i, tab in enumerate(self._tabs): + if tab.getTag() == tag: + self._current_tab = i + break + + def getCurrentTab(self) -> int: + return self._current_tab + + def getCurrentTabTag(self) -> str: + if 0 <= self._current_tab < len(self._tabs): + return self._tabs[self._current_tab].getTag() + return "" + + def getTabWidget(self) -> "TabWidget": + return self._tab_widget + + def getTabContentView(self) -> FrameLayout: + return self._tab_content + + def setOnTabChangedListener(self, listener: Optional[OnTabChangeListener]): + self._on_tab_changed_listener = listener + + def clearAllTabs(self): + self._tabs.clear() + self._current_tab = 0 + + +class TabWidget(LinearLayout): + """TabWidget — 标签部件""" + + def __init__(self, context=None): + super().__init__(context) + self._strip: Any = None + self._left_strip: Any = None + self._right_strip: Any = None + self._selected_tab: int = -1 + self._draw_full_strip: bool = False + + def setStripEnabled(self, strip_enabled: bool): + self._draw_full_strip = strip_enabled + + def isStripEnabled(self) -> bool: + return self._draw_full_strip + + def setLeftStripDrawable(self, drawable: Any): + self._left_strip = drawable + + def setRightStripDrawable(self, drawable: Any): + self._right_strip = drawable + + def setDividerDrawable(self, drawable: Any): + pass + + def focusCurrentTab(self, index: int): + self._selected_tab = index + + def isEnabled(self) -> bool: + return True + + +# ═══════════════════════════════════════════════════════════════ +# ExpandableListView +# ═══════════════════════════════════════════════════════════════ + +class ExpandableListView(ListView): + """ExpandableListView — 可展开列表视图""" + + PACKED_POSITION_TYPE_GROUP = 0 + PACKED_POSITION_TYPE_CHILD = 1 + PACKED_POSITION_TYPE_NULL = 2 + PACKED_POSITION_VALUE_NULL = 0xFFFFFFFF + + def __init__(self, context=None): + super().__init__(context) + self._expandable_adapter: Optional["ExpandableListAdapter"] = None + self._on_group_collapse_listener: Optional[Callable] = None + self._on_group_expand_listener: Optional[Callable] = None + self._on_child_click_listener: Optional[Callable] = None + self._on_group_click_listener: Optional[Callable] = None + + def setAdapter(self, adapter: "ExpandableListAdapter"): + self._expandable_adapter = adapter + self._adapter = adapter + + def getExpandableListAdapter(self) -> Optional["ExpandableListAdapter"]: + return self._expandable_adapter + + def setOnGroupCollapseListener(self, listener: Optional[Callable]): + self._on_group_collapse_listener = listener + + def setOnGroupExpandListener(self, listener: Optional[Callable]): + self._on_group_expand_listener = listener + + def setOnChildClickListener(self, listener: Optional[Callable]): + self._on_child_click_listener = listener + + def setOnGroupClickListener(self, listener: Optional[Callable]): + self._on_group_click_listener = listener + + def expandGroup(self, group_pos: int, animate: bool = True) -> bool: + return True + + def collapseGroup(self, group_pos: int) -> bool: + return True + + def setOnItemClickListener(self, listener: Optional[Callable]): + self._on_item_click_listener = listener + + def getOnItemClickListener(self) -> Optional[Callable]: + return self._on_item_click_listener + + def setOnItemLongClickListener(self, listener: Optional[Callable]): + self._on_item_long_click_listener = listener + + def getOnItemLongClickListener(self) -> Optional[Callable]: + return self._on_item_long_click_listener + + def getPackedPositionType(self, packed_position: int) -> int: + if packed_position == ExpandableListView.PACKED_POSITION_VALUE_NULL: + return ExpandableListView.PACKED_POSITION_TYPE_NULL + return ExpandableListView.PACKED_POSITION_TYPE_GROUP + + def getPackedPositionGroup(self, packed_position: int) -> int: + return packed_position & 0xFFFF + + def getPackedPositionChild(self, packed_position: int) -> int: + return (packed_position >> 16) & 0xFFFF + + @staticmethod + def getPackedPositionForChild(group_position: int, child_position: int) -> int: + return (child_position << 16) | group_position + + @staticmethod + def getPackedPositionForGroup(group_position: int) -> int: + return group_position + + def isGroupExpanded(self, group_position: int) -> bool: + return False + + def setSelectedGroup(self, group_position: int): + pass + + def setSelectedChild(self, group_position: int, child_position: int, should_expand_group: bool): + pass + + def smoothScrollToPosition(self, position: int): + pass + + +# ═══════════════════════════════════════════════════════════════ +# ExpandableListAdapter +# ═══════════════════════════════════════════════════════════════ + +class ExpandableListAdapter(Stub): + """ExpandableListAdapter — 可扩展列表适配器接口""" + + def __init__(self): + super().__init__() + + def getGroupCount(self) -> int: + raise AndroidOnlyError("ExpandableListAdapter.getGroupCount: not implemented") + + def getChildrenCount(self, group_position: int) -> int: + raise AndroidOnlyError("ExpandableListAdapter.getChildrenCount: not implemented") + + def getGroup(self, group_position: int) -> Any: + raise AndroidOnlyError("ExpandableListAdapter.getGroup: not implemented") + + def getChild(self, group_position: int, child_position: int) -> Any: + raise AndroidOnlyError("ExpandableListAdapter.getChild: not implemented") + + def getGroupId(self, group_position: int) -> int: + raise AndroidOnlyError("ExpandableListAdapter.getGroupId: not implemented") + + def getChildId(self, group_position: int, child_position: int) -> int: + raise AndroidOnlyError("ExpandableListAdapter.getChildId: not implemented") + + def hasStableIds(self) -> bool: + return False + + def getGroupView(self, group_position: int, is_expanded: bool, + convert_view: Optional[Any], parent: Optional[Any]) -> Any: + raise AndroidOnlyError("ExpandableListAdapter.getGroupView: not implemented") + + def getChildView(self, group_position: int, child_position: int, + is_last_child: bool, convert_view: Optional[Any], + parent: Optional[Any]) -> Any: + raise AndroidOnlyError("ExpandableListAdapter.getChildView: not implemented") + + def isChildSelectable(self, group_position: int, child_position: int) -> bool: + return True + + def areAllItemsEnabled(self) -> bool: + return True + + def isEmpty(self) -> bool: + return self.getGroupCount() == 0 + + def onGroupCollapsed(self, group_position: int): + pass + + def onGroupExpanded(self, group_position: int): + pass + + def getCombinedGroupId(self, group_id: int) -> int: + return group_id + + def getCombinedChildId(self, group_id: int, child_id: int) -> int: + return (group_id << 32) | child_id + + +# ═══════════════════════════════════════════════════════════════ +# SimpleExpandableListAdapter +# ═══════════════════════════════════════════════════════════════ + +class SimpleExpandableListAdapter(ExpandableListAdapter, BaseAdapter): + """SimpleExpandableListAdapter — 简单的可展开列表适配器""" + + def __init__(self, context: Any, + group_data: List[Dict[str, Any]], + group_layout: int, + group_from: List[str], + group_to: List[int], + child_data: List[List[Dict[str, Any]]], + child_layout: int, + child_from: List[str], + child_to: List[int]): + super().__init__() + self._context = context + self._group_data = group_data + self._group_layout = group_layout + self._group_from = group_from + self._group_to = group_to + self._child_data = child_data + self._child_layout = child_layout + self._child_from = child_from + self._child_to = child_to + + def getGroupCount(self) -> int: + return len(self._group_data) + + def getChildrenCount(self, group_position: int) -> int: + if 0 <= group_position < len(self._child_data): + return len(self._child_data[group_position]) + return 0 + + def getGroup(self, group_position: int) -> Any: + if 0 <= group_position < len(self._group_data): + return self._group_data[group_position] + return None + + def getChild(self, group_position: int, child_position: int) -> Any: + if 0 <= group_position < len(self._child_data): + children = self._child_data[group_position] + if 0 <= child_position < len(children): + return children[child_position] + return None + + def getGroupId(self, group_position: int) -> int: + return group_position + + def getChildId(self, group_position: int, child_position: int) -> int: + return child_position + + def getGroupView(self, group_position: int, is_expanded: bool, + convert_view: Optional[Any], parent: Optional[Any]) -> Any: + if convert_view is not None: + view = convert_view + else: + view = TextView(self._context) + view.setText(str(self.getGroup(group_position))) + return view + + def getChildView(self, group_position: int, child_position: int, + is_last_child: bool, convert_view: Optional[Any], + parent: Optional[Any]) -> Any: + if convert_view is not None: + view = convert_view + else: + view = TextView(self._context) + child = self.getChild(group_position, child_position) + view.setText(str(child) if child else "") + return view + + def isChildSelectable(self, group_position: int, child_position: int) -> bool: + return True + + def getCount(self) -> int: + return self.getGroupCount() + + def getItem(self, position: int) -> Any: + return self.getGroup(position) + + def getItemId(self, position: int) -> int: + return position + + def getView(self, position: int, convert_view: Optional[Any], + parent: Optional[Any]) -> Any: + return self.getGroupView(position, False, convert_view, parent) + + +# ═══════════════════════════════════════════════════════════════ +# BaseExpandableListAdapter +# ═══════════════════════════════════════════════════════════════ + +class BaseExpandableListAdapter(ExpandableListAdapter, BaseAdapter): + """BaseExpandableListAdapter — 可展开列表适配器基类""" + + def __init__(self): + super().__init__() + + def getGroupCount(self) -> int: + return 0 + + def getChildrenCount(self, group_position: int) -> int: + return 0 + + def getGroup(self, group_position: int) -> Any: + return None + + def getChild(self, group_position: int, child_position: int) -> Any: + return None + + def getGroupId(self, group_position: int) -> int: + return group_position + + def getChildId(self, group_position: int, child_position: int) -> int: + return child_position + + def getGroupView(self, group_position: int, is_expanded: bool, + convert_view: Optional[Any], parent: Optional[Any]) -> Any: + if convert_view is not None: + view = convert_view + else: + view = TextView(android_context) + view.setText(f"Group {group_position}") + return view + + def getChildView(self, group_position: int, child_position: int, + is_last_child: bool, convert_view: Optional[Any], + parent: Optional[Any]) -> Any: + if convert_view is not None: + view = convert_view + else: + view = TextView(android_context) + view.setText(f"Child {group_position}:{child_position}") + return view + + def isChildSelectable(self, group_position: int, child_position: int) -> bool: + return True + + def areAllItemsEnabled(self) -> bool: + return True + + def onGroupCollapsed(self, group_position: int): + pass + + def onGroupExpanded(self, group_position: int): + pass + + def notifyDataSetChanged(self): + pass + + def notifyDataSetInvalidated(self): + pass + + def getCount(self) -> int: + return self.getGroupCount() + + def getItem(self, position: int) -> Any: + return self.getGroup(position) + + def getItemId(self, position: int) -> int: + return position + + def getView(self, position: int, convert_view: Optional[Any], + parent: Optional[Any]) -> Any: + return self.getGroupView(position, False, convert_view, parent) + + +# ═══════════════════════════════════════════════════════════════ +# SearchView +# ═══════════════════════════════════════════════════════════════ + +class SearchView(LinearLayout): + """SearchView — 搜索视图""" + + def __init__(self, context=None): + super().__init__(context) + self._query: str = "" + self._query_hint: Optional[str] = None + self._iconified: bool = True + self._iconified_by_default: bool = True + self._submit_button_enabled: bool = False + self._query_refinement_enabled: bool = False + self._searchable_info: Any = None + self._on_query_text_listener: Optional[Callable] = None + self._on_close_listener: Optional[Callable] = None + self._on_suggestion_listener: Optional[Callable] = None + self._on_query_text_focus_change_listener: Optional[Callable] = None + self._suggestion_adapter: Optional["CursorAdapter"] = None + self._max_width: int = sys.maxsize + self._on_search_click_listener: Optional[Callable] = None + + class OnQueryTextListener: + def onQueryTextSubmit(self, query: str) -> bool: + return False + + def onQueryTextChange(self, new_text: str) -> bool: + return False + + class OnCloseListener: + def onClose(self) -> bool: + return False + + class OnSuggestionListener: + def onSuggestionSelect(self, position: int) -> bool: + return False + + def onSuggestionClick(self, position: int) -> bool: + return False + + def setQuery(self, query: str, submit: bool = False): + self._query = query + if self._on_query_text_listener: + self._on_query_text_listener.onQueryTextChange(query) + if submit and self._on_query_text_listener: + self._on_query_text_listener.onQueryTextSubmit(query) + + def getQuery(self) -> str: + return self._query + + def setQueryHint(self, hint: Optional[str]): + self._query_hint = hint + + def getQueryHint(self) -> Optional[str]: + return self._query_hint + + def setIconified(self, iconified: bool): + self._iconified = iconified + + def isIconified(self) -> bool: + return self._iconified + + def setIconifiedByDefault(self, iconified: bool): + self._iconified_by_default = iconified + + def isIconifiedByDefault(self) -> bool: + return self._iconified_by_default + + def setSubmitButtonEnabled(self, enabled: bool): + self._submit_button_enabled = enabled + + def isSubmitButtonEnabled(self) -> bool: + return self._submit_button_enabled + + def setQueryRefinementEnabled(self, enable: bool): + self._query_refinement_enabled = enable + + def isQueryRefinementEnabled(self) -> bool: + return self._query_refinement_enabled + + def setOnQueryTextListener(self, listener: Optional["SearchView.OnQueryTextListener"]): + self._on_query_text_listener = listener + + def getOnQueryTextListener(self) -> Optional["SearchView.OnQueryTextListener"]: + return self._on_query_text_listener + + def setOnCloseListener(self, listener: Optional["SearchView.OnCloseListener"]): + self._on_close_listener = listener + + def setOnSuggestionListener(self, listener: Optional["SearchView.OnSuggestionListener"]): + self._on_suggestion_listener = listener + + def setOnSearchClickListener(self, listener: Optional[Callable]): + self._on_search_click_listener = listener + + def setSuggestionsAdapter(self, adapter: Optional["CursorAdapter"]): + self._suggestion_adapter = adapter + + def getSuggestionsAdapter(self) -> Optional["CursorAdapter"]: + return self._suggestion_adapter + + def setMaxWidth(self, max_width: int): + self._max_width = max_width + + def getMaxWidth(self) -> int: + return self._max_width + + def onActionViewExpanded(self): + self._iconified = False + + def onActionViewCollapsed(self): + self._iconified = True + + def onClose(self) -> bool: + if self._on_close_listener: + return self._on_close_listener.onClose() + self._iconified = self._iconified_by_default + return True + + def clearFocus(self): + pass + + +# ═══════════════════════════════════════════════════════════════ +# ZoomControls +# ═══════════════════════════════════════════════════════════════ + +class ZoomControls(LinearLayout): + """ZoomControls — 缩放控件""" + + def __init__(self, context=None): + super().__init__(context) + self._zoom_in_enabled: bool = True + self._zoom_out_enabled: bool = True + self._zoom_speed: int = 300 + self._on_zoom_in_listener: Optional[Callable] = None + self._on_zoom_out_listener: Optional[Callable] = None + + def show(self): + self.setVisibility(View.VISIBLE) + + def hide(self): + self.setVisibility(View.GONE) + + def setIsZoomInEnabled(self, is_enabled: bool): + self._zoom_in_enabled = is_enabled + + def setIsZoomOutEnabled(self, is_enabled: bool): + self._zoom_out_enabled = is_enabled + + def setOnZoomInClickListener(self, listener: Optional[Callable]): + self._on_zoom_in_listener = listener + + def setOnZoomOutClickListener(self, listener: Optional[Callable]): + self._on_zoom_out_listener = listener + + def setZoomSpeed(self, speed: int): + self._zoom_speed = speed + + def getZoomSpeed(self) -> int: + return self._zoom_speed + + def hasFocus(self) -> bool: + return False + + +# ═══════════════════════════════════════════════════════════════ +# DigitalClock +# ═══════════════════════════════════════════════════════════════ + +class DigitalClock(TextView): + """DigitalClock — 数字时钟（API 14+ 已弃用）""" + + def __init__(self, context=None): + super().__init__(context) + self._format: str = "%H:%M:%S" + self._update_interval: int = 1000 + self._running: bool = False + self._timer: Optional[Any] = None + + def start(self): + self._running = True + + def stop(self): + self._running = False + + def setFormat(self, fmt: str): + self._format = fmt + + def getFormat(self) -> str: + return self._format + + def onTimeChanged(self): + now = datetime.now().strftime(self._format) if hasattr(datetime, 'now') else "00:00:00" + self.setText(now) + + +# ═══════════════════════════════════════════════════════════════ +# AnalogClock +# ═══════════════════════════════════════════════════════════════ + +class AnalogClock(View): + """AnalogClock — 模拟时钟（API 14+ 已弃用）""" + + def __init__(self, context=None): + super().__init__(context) + self._dial: Optional[Any] = None + self._hand_hour: Optional[Any] = None + self._hand_minute: Optional[Any] = None + self._running: bool = False + self._update_interval: int = 1000 + + def start(self): + self._running = True + self.invalidate() + + def stop(self): + self._running = False + + def onDraw(self, canvas: Any): + super().onDraw(canvas) + + def setDialDrawable(self, drawable: Any): + self._dial = drawable + + def setHourDrawable(self, drawable: Any): + self._hand_hour = drawable + + def setMinuteDrawable(self, drawable: Any): + self._hand_minute = drawable + + +# ═══════════════════════════════════════════════════════════════ +# Chronometer +# ═══════════════════════════════════════════════════════════════ + +class Chronometer(TextView): + """Chronometer — 计时器""" + + def __init__(self, context=None): + super().__init__(context) + self._base: int = 0 + self._format: Optional[str] = None + self._running: bool = False + self._visible: bool = True + self._on_chronometer_tick_listener: Optional[Callable] = None + self._count_down: bool = False + self._elapsed: float = 0.0 + + def start(self): + self._running = True + + def stop(self): + self._running = False + + def setBase(self, base: int): + self._base = base + + def getBase(self) -> int: + return self._base + + def setFormat(self, fmt: str): + self._format = fmt + + def getFormat(self) -> Optional[str]: + return self._format + + def setOnChronometerTickListener(self, listener: Optional[Callable]): + self._on_chronometer_tick_listener = listener + + def getOnChronometerTickListener(self) -> Optional[Callable]: + return self._on_chronometer_tick_listener + + def isCountDown(self) -> bool: + return self._count_down + + def setCountDown(self, count_down: bool): + self._count_down = count_down + + def getElapsedRealtime(self) -> float: + return self._elapsed + + def setVisibility(self, visibility: int): + self._visible = (visibility == View.VISIBLE) + super().setVisibility(visibility) + + def onDraw(self, canvas: Any): + super().onDraw(canvas) + if self._running and self._on_chronometer_tick_listener: + try: + self._on_chronometer_tick_listener(self) + except Exception: + pass + + +# ═══════════════════════════════════════════════════════════════ +# __all__ +# ═══════════════════════════════════════════════════════════════ + +__all__ = [ + # TextView hierarchy + "TextView", "EditText", "Button", "ImageButton", "CheckBox", + "RadioButton", "ToggleButton", "Switch", + # ImageView + "ImageView", + # Progress + "ProgressBar", "SeekBar", "RatingBar", + # AdapterView hierarchy + "AdapterView", "ListView", "GridView", "ExpandableListView", + "Spinner", "AutoCompleteTextView", "MultiAutoCompleteTextView", + # RecyclerView + "RecyclerView", "RecyclerViewAdapter", "RecyclerViewViewHolder", + "RecyclerViewLayoutManager", "LinearLayoutManager", + "GridLayoutManager", "StaggeredGridLayoutManager", + # Layouts + "LinearLayout", "RelativeLayout", "FrameLayout", + "TableLayout", "TableRow", + # Scrolling + "ScrollView", "HorizontalScrollView", + # WebView + "WebView", "WebSettings", + # Adapters + "BaseAdapter", "ArrayAdapter", "SimpleAdapter", "CursorAdapter", + "ExpandableListAdapter", "SimpleExpandableListAdapter", + "BaseExpandableListAdapter", + # ViewAnimator + "ViewAnimator", "ViewFlipper", "ViewSwitcher", + "ImageSwitcher", "TextSwitcher", + "AdapterViewAnimator", "StackView", "AdapterViewFlipper", + # Date/Time + "DatePicker", "TimePicker", "CalendarView", "NumberPicker", + "DigitalClock", "AnalogClock", "Chronometer", + # Media + "VideoView", "MediaController", + # Toast/Popup + "Toast", "PopupMenu", "PopupWindow", + # Toolbar + "Toolbar", "ActionMenuView", + # Tabs + "TabHost", "TabWidget", + # Search + "SearchView", + # Zoom + "ZoomControls", +] \ No newline at end of file diff --git a/android_pyapi/java/__init__.py b/android_pyapi/java/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/android_pyapi/java/__pycache__/__init__.cpython-310.pyc b/android_pyapi/java/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1a1a495561866099d1fa14f0b8f49555a5923c74 GIT binary patch literal 155 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/java/__pycache__/io.cpython-310.pyc b/android_pyapi/java/__pycache__/io.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..902ec8872d602610e4b86ce4cdd8df9d80c65040 GIT binary patch literal 59302 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/java/__pycache__/lang.cpython-310.pyc b/android_pyapi/java/__pycache__/lang.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..18e3dd7caa0377a853e35aa9d87ebdd9fb6ea16a GIT binary patch literal 52365 zcmc(|349#KbtgPM7Y2iC0D>e)@qlAWc$-;bRO=55R!{3{*X! zhzVplB7Mb{Eys53wd0tK<%8?Q_9l+w^(Jw4V|#OYbNJhMJK4mEtjNrjt@bvAx0To9{cQ+uw|5}CL*ln1e2slA!q=9!m)8J; z9e6TiUxz2xc~7pvlb6{$@nom>^!iC)Y{6zifObVs5l= zLd;EG%q~2+*}er&ZV?=Y5x&*F4dL4)d_BUq+jk&*$C>2#4G6v5z7wH4%Qv6|HzNEB z`!0m2lpH~=nPh7 z=V!{Z<+)nf9<0m_9$BoNtj-PRr}5gbyf!~kdSqg%Jh*G{SWQ*trgjbrAFC~#a0`3pY*nq; zhv#M%_bXLZ7ZIBn8?xM-Jy9#yDzoLGYuv2P!EHy*)yF1I%#_{s{ijRi`C6qq=N67G z%rRl`BqLe5S&g6D=Hch24^`);+|03)RaJA-dlzeEH*;X7I#F}8`>G4fwry{ikntF!X}N<2CV{#g0Zh4Ngf?B)&v4|$&7Ge2KOqcKhH zC~8@JU3(U4)zO)%QxwA*o%sk~peubUlPm^}fc3da`a=T+Hp z9-2^dXi&$^?KD!+WZx}7)>p|n-+51M4yPcSx=c5}tz+{A3TSakEn;%wDkn4!P3 zSbTJ0Vn)ZP+mMGK*5KUAXDt3U{G_D0M5m=I1W!UA;xK}r+6f1>Hi*9xYsq}*H?^jA zA)tooTo31hrEa31^`ad@c5@XHQmv|n`22P_^pQ+F`_<#g_(^GZ5FUgDFY z3?kxMM!td$LoEry6k{tBEwdQvE@m45mO^Aoq;x5-lwehe`iCVprVP8oSp{VvLabt4 z20;&@(5Ja6*m{vNFwrP}mvV5H66X@<6UTIufQ;LV#S*)IvDmUqbLAWPHnYiD^&Y{m=f(p%7)4bN<{Q-V5GE)Ad67wV@l+(^&!NPErF5lsS%2% z_f;WKI<}N*s2loQ6y`$80|m(m36cUQZid(4ESxZWTl$ZbZy*G;A<2(bjk#J?3m0i- z0kk><$i$BgwKezXeXNjs=)8)~Av!@n3rLA=&5%Q-ItRkcC3DHnq^1Ep3VjSwnXY~{ zVwc;DLtZmlr3O576HbWCyBnE#EGrO#!#XaebBr;0T#1O3@B*ndK@m?vpXPFGLF`J) zku05P051heQ!OHg(8cI7@_U%iV~TKuN#lw@eD*R@iXhk_6#66)8o|#r1*KX`ViQ4R z8*ZgR#&O=1T9^}>5nAgsy2UUa$Dn_d;N#FIE(aJX=nG~Dg+6I7;XN1-tjGHJ-Qo>{WQu zVfWjs@!x5$vDf0i%O0@T;lJBnZ(oJ~9(#km5&wm^CDMuUUa-DF)dqCNBJ6@JgFj~k zPAzdJan4$@=CihS-m(%)mg=r0m#j0^9CV?jL@~9LgqxnCKO=4y(xUA=xDMOkLUPPa z4CUO6vjEMInnq==QiFDpa%#%$Dca@QL}jKp3w;e*xSK7OCZO>^_W)BWJyNVu!*e@| zcw2NjXmH)d$;!+Ove8L~JTBH|vdBmdipcBs62|->f}}vF6HdYEv$FE-wCa7n8a`~0 z3y~J9f(=Mg7x@D9FENvN9F=m;I-htvDNUGIO4#2+x=RCWi@0I$#n8x`>f>U?B)8-hH3~^ z@bFzT90@qP;W1fUyo}FK%59hSIf0gPyUM2-sOeTwS6pe zL$-2glzh7Lf7b_EVH2uI3O4@OG?%h)mJ-vZ-$Q3)#<3DRKUJ>XuPN>XUuA=2p&ti8 zg9I%Bs%d5~I_e{>0IfnkGLEX$%eDux%*3;B>KjAwn$s-6DO5q+?X7r}(KVo_Uf@y@A;V{7{Ijoqbz?vPK*de%4A`^;JPZ{S=|% z5i0wcK)x0pHspNTw%E&50U`8>k0fmLi;pBeieZ<2g8r2nQ^%3Mp1gAqH|(jU@AXVG!9P7T9q<+jhm_E0O9PnS%maqy0$Y{J~_k)*-+mkAxR z6KFH&J_W13E~xINw4q98&+(g^{6K5@;PIxxhb-x!v3;mOCUI~sz+(|Pi0I9+$=3%s zG$)K8VY+b8qd?eXAhCeEK)V6d$C*re)7k)HC`G6dSzc4-O96=o+Cm)(4Bd1H%hEEa zxfQycMl9Zpw}gx2t$G64iBTyfs?=+pCpz|g=KS_s` zsm{W2yS$NasSF*Y*w6$cOd_fVwW`DTIh)|*65UoVm&@l;@=fQ{xoj@2Lxq%RU?n6A zeb^sH@VmrL>8pztxLs1QqmNxkH5V>m#Nrb?nDi-TL-vz{0Z3kM2~E8X$pE1pe`D(H za2rY&_wHo7d9s=sK z%s)VVmU)Nqc2R=!sL>u#sY+BH%!htbCV`5=r*&Xzv?36bqVcAdQq+5w($ssGGH|m& zzim?w;AKUUqe?4Q(l#i$Fh1LEh6*ffwMD9JZW~N*waTgTP*#t|d+ajO(-Q5y*P&k% z3!U4}SGBi;uNUXE(X&fu;(<^jgdVgR@%UN%MC;3YsxLGxu<3x4dUn)!C72``Wz*=b zKSfA!y|t4n1`9q0ZS)zY65g;W3a~L@ghj*xeP=76x-SR-P|Hf7?OL_1<7^26bz5x`_mqxi`Ph~f|W9rVp!)NUhA5onY=;Ll5X5A=E^YS{u-nBZoSK^IsH6Rt_;!$jP>xaFG(-5 zYRMXU&>0wO^r&elIrf4zf{wF?8Q%fNO`R;Cc9Ru5uE0Xvzl~JVe(Qs>n$8lz!{^qo zCIBjQx@2+fmz}HDDwB)9$3$X*GiB7zf2_RQbsl?WX1?KPU+}8Xj~a_KRSWcu>fOe9 z+3G^AxwX=dO;l=sa%p-N+*srlH>db{G2s# zgf)7Mkqk1A9~h)?B}9il)Moi{ei~&q4AOqxk7Z0HgG{Wzl=^yEJz|X)^r{i8mU)A{ z#oh{YY@fZ&-j2Lh**olO@ZWF0&c4pe( z;QwlSuRV(YE%rWpKmNCtx7i2md(MIfjBkg(Xy0oeJPUp>z5}8A>{m(5HSiy@?-&2I z_LzMbZw}c<>{sLeI{T=74F4~)kJ}I6f2aMR{Sf|l*$>;V!T+#5Zod})*NZT@0m9^s zsspVP?ObfP6x;1yIDs_rtS8-+{n};jq<24%b*+o8o0#4mqkumH|_B8`x6%&Y~g*Fu`f;ofX zqjYMlHb_;K-4dGH!HPIig*j?Z?e7WoqlDV$6|NyN!amu;0-6I~w5#<C6b8mUFs>!s_ zr5$*QCjXiRV(&#Y(d?gm1S3k%mmrolS`O-oR1)x{9xFXew_uF+AWJp=8Og*Xp0@^Q zk1P1Naa9f$hD6ZvTkp0;wAK-sbE)${Q~zu9LQi}&)z|Rqg>(~+Zf2(X7&>DNs_rU( z9m>I}IkfHQgj0S2nK)$qdFxs+B{riTByCxUOMSW!AU!=>wYH%Lq#Ek4vBO(Vb5mza z)j6yix{S<32kNte?k6!31bjmCx}Wf>Y3r0BH|P=ssT=PP=nHptHwTcI5}R|9=o-53 z8OCB_B0vpANuNi9C2Ht!XRJpsZKMTxQo|!;qs$~rk? z5~5oZ32n{{qaeM?d8|@9Y4FH83zL(T$VvzHKIb8%%Mp!dfVj_JO-ySHs0I5StHbY3 zs1C0)9Z+9q)yGhz=rkRG>2;n?QlMeEp7!06u zGfmV+Q3G3cgj6xk;<7_$HQVS(yy>@*i3#bcBvT(5jy`052MFy;yuOq3s7qEqNjG`M zT8nkdBbZ}-Gy}pY+@5!uW=_Jg8syZ7h ztlDH9(c#I>0TJb_omRcuBO)(4)J{n18~Yp<%byU^^%Xms1D0hqw+-)lqd6Y{pGWd< z=93^wj>XBcDC`K8nhNH*HS3Cl*;aA(&(7BtuOU#;Qv6csh>#kr%gg{6%6z{S=A) zEFXM_&fn2tHGPQU%URu6*ubewukITXwrl`VMo|^g0A`~1Z;3`sm8*S-xQW#rQbk)Vamyg_D1MF> z#x?64dN=^3&ZCDLxsZ0#C$LJ{O%)Z^K~FBs%*;;IK<%s{!+N(om+{| zA0oL=)LulW`Pp54qGR_4D#^7*EK41GJxZ~6HE5lOCnsZ=Utd)o?_C@<>aueO5n+Mr z>%0btrisin_?5(A3?{n=P(dIzd^4KdxX5HFg=d^=Xn4l1(ww$AT|@);9RM*i4f%?% za=C3ajjFntWpAr`AvSk2`E{W&uxc7h$4e*6&MQcOStLt?t8Bv>3a{j$M3IK@3mwum z173*=5T&>e+!M6&xY)7CDcNX^)T4Q%3VIjEp1OBYsu>>HR-LiAme6gRD?dh0Q=voz zj<6_syv4r6AGAHgP`qJfq#!K0ka#~lH3%;uak7lm`IJxOP>BVv?;{ZwJ}sOO3@>N~ zuKp*Vc6boDRiOzvH}A#4oOKUy6ipOj32WdvO@#G!GUP>U1idzc-hhW52Ns;Znoe;M z`%~a?S_L4#g6%U?;)q85AA}S|Kr<$t9;^cu<<#zDeX&aoV1-8*7l{vHL(c2B`nwSz zKYhef+iIdG0wc8R<5)~a8KAZMleh%ASmT+bD60S3rUa}>%hdDB~Jy=-@f37v(RHv$p#}E0K7q!3baQ}fk%Em_70%#$WUS(%y2Y^COAFzl-}tNf}RfbVBJl0Yawa#%ou-{s_+ z*Q7ep3py{uvf=Ie&?rUp%M@N^A5h<f=!v7keqZNKb z;5rw^g-D8U*#?9y^RyrUitoVWAmW-NuH_p^p90+Pm%uaN7r%*Yn%V|Jc;SR2z3g?Y zB=&Z)1uzCPp7s;86tLMmys-46bia7%>rIo zxr~tvmj3`7|6|JS;EC|ipM*~K`Zgm69)!qx6kN#=izPZgnx=&G>Kk;L8lnBJsq$R; z^t{^r1WQf+23DM?W8H)Zd$wkSP%w#yvThrOrxUfB(&G&=GJSyngu`+8hpKM3%OVZ9 z61%MT%{5oLV$z==Y;wE7WX{@P)lCN>^icVcj(URT|I-A=uCM+*otVxplSMy?7rgme z)9LhU4k}`7RV@A#vlm$qluIHa!r0IKO9bIJ21xEE zJb*F5j*O!^iba@fuwQPrSbWL{WO{r)O@o7Q`jn=$~ zNbY_UwKnI~&|F&BM2ybeW1*dvu{dRm#qy)Y;`@k_3&efyqMz%WE%oP!!u$+Ni+beW z*wBr!Q=?=(>euLeh0br$;SfjtE}j2E=a1<837tQs^9eeCM&~c-e4NhnbiPYR=3hA9 zAp>tkqrUn9ogdN>yPcSc#a2sQPW8~C#ZdLp!6yBLT0@6sEw>Y@RIO6dE6UVHKHoxT zI~{g>J)6s}q;@j6i_Z0QZlEJW|F<$WU|S;$$~+Z04NKvifFlbZ+s$g1Tn1k=!JEm$ zpKs$6O!S%+F_~POggf!fOPfsPtt8aYWQPA3k_CBidYJG^_=P^~03-N0WIz7&Fqa9+ zj@{)h69gORR@WelNdHAW=>EG49^J#Pr;qR&szpR<4puRds6WTryB#U&J$l8~u!;Gx z@^8mp$|(VG&IeHN0QgZq7KHpHca#f=pZ7uZdLV+h9}7l@E!))v$TL2WJ`YGkWCV)g zcHW!=H>ozP=RtL&+lqN8u5sEq^(#O>NubZLbxh^?Q7u8Lm*XY9Y>17|9O8iF9d6GT zD4+JBnEDIi#)jIP8H(V28{fH|ju@9-N#6*ap#Oaxe#$Pso8B;{(V|j^aRG>)@ATIN)CozZ}2;|5fnI(Hrn@fL{*XfPW+Wa@+>| zo8XrNHsIe3zZ|Ur{~-KwtOop7!!Ji_z`q54IZy-st?=*HOEM7JhD8}T>;yaUW>gK#ghHT2X1$=ZDArzGU>5@mR>bb?b0wG?#Q zzM7cE&SPw#S0UHhyhRcXYm#%pI*0}pk%+iC*an>PLCiB`i>GAK!?Sp-zDQ?;PC#Q1 zBKWJI7TFfgr4I!zeJJ2vo|)mVeYi+FT1$z3iTQDmDn>q<{h)6@F4{VbJ*#Rd{X|AN zo*(7$rUqyN3(YZ$s!N0~Bt@l$NqxeO%qXgTc<(oeIZ?|)ugzJVFn9#Gn@WhF&4wAp z&#A%TpaDqc8%Kh8mc+9GJd>he&5Cb&KpZVtI}j&p@tWe&h`R-GnDobdL&JNG`EwA$ zVk`U-7iqk{Sb#H>(aJq5z)hW~%whOhs;N&Qh`AH1q7LyLX}h2S4r$(BJW)^=)anxT4y1FDsfEZZzG5j^* z?RM9yd$DXyEo#mDkCEh(*kh9YSm97#V<<43EW*AG^6EHYJV1Ef2%goZ9*ThsqsYDG z(;Doz7*7jTeN_O^k6i(@S2LqHXkE4H;Zkj4M#K9HAKvN!UPF9@R*jAI(iRlQ?_ymT z^kNkUSD$L@xu(-5X?We?dxXK;L5KGKnuXy12}#)_K!pFH-&bSEnqbQIlo)jE5z|b$iGE|ond}}wImYGw@c)`!S&lDigSeDVst#hYZ^RLWZ+So_EwaRL0 zC>S(@!(~MOY)whG0|M*Tv!a?ZTtRD%f>A7IZ1qziOZmC`?BGi3sv%WxLX^Cdyzv|u zKPQj57UQpgvTNOlaVB}8O4EsB6S))EY0Jr)EKm^RSYLw}Hj$A=@-f&TlqRAKJNr3t zt#^NNnci+LvGBI7$}|X8Q|6H+Z4o%=Bo?2pla(n<2i6YHmG@R^c_O8`bDBF+edZNP z6~WF_zs$mcStU9WBgS^7IZ<3ybaHu_fm}cyVr0!H>;0z18xur;`c=Xy5D{ldmE}CX zsS;UnVya^g8$`_1aj5jq$#$&6lZS8y2Il6*%c|=1H&zBD>;{8YT;d3New}P;LeJEX z40=+6q_?P236h+@YK`e?0~}{)Rb~vT>l;zUEXT%XR70slxKgkh;p))lp{e_E&^D%T zF^zWyR#hBwz$w1;ZmLn~5ghx0ad5*JTE)nOkHMK~x3=Oz^nx8n9`Y6q@$ z%FW`CuZ5YKYc+1elwmhk0ppY}r##5wPzvOdX()RIsH<2%<;yECRj3%OZl5CVXeb7C zyt`#p5)p%Ofr8lLtltq^p zy{F2gVX^CC-c<^;m#eLYSSnU^E_nkc+)WcTCJD)|P|I8!6p1yT#3C!6;E_U$V4?LA z=;&^s?+v0sPb`A^HXR`<;sxbfnjmLmE{lt(6;XDr$mv0ORfV~!e5gEG8wSpvx|XB5 z<_nY{$;xrQ+sApgkF#3vtM8QW^R-`0vkOW`!K`Yx04G&PqCl5xhz(H%68S>f@mXhD z^9kV@&^EZPnXFX(I;%@y#_@=(gLM}Rvv;x;Dep;}+%gZ!^z{UtB!Yrb?i_{p$gg=O zi<1{0B#7#*akVS^nk=x9=V?6O>J2?ISdhKdOOtI#(}pxRd(Sg^=wkBFPq~FiNZL)_ zfbBvzJgg3*N?hv(5f4JxFIZdAH@jHpqIW&ZO87fC=(@?d*(Qoszk-;(tOD99`Z3A0 z24gX@K8OPlA`}aItd~na92lm5zaLn_jj~yJ}?`HPC=J@_&vL?t)AAik}{jv{R-9plo zfemX*JAao}2R7PNDE4~l?}`exwzf5y;U*bTp(At1GxW{U;fPk%=q%FVG@4qX zLvmMdqmMPK-br6eJ39N%=aIshfrlIS&9^(5Y=bqNzYbW$X%&|r2Jy6vH`v&<<=l&> z72TxG!Jlpjx53|z_p`F$ijYhAg+7!Y{5Zb}=ZaRsZB16f?IA1ScG-l#5-Z_$IrjHQ zwGwI@9Jgg*vz6H12EfC1s4f&^hOCr}hWTwv%={3WKk-C9xx~d0c!aB6*&e4x*^WY? z@zynh!r3mgt{sAL9R%Pz@!&C2;+lPXu$sV7$AEif==>y zUAh;wF^QQbWG@P}To2AzAk-K+D;@lCmRFl=q`WIK4!xf_kGIO6tmBNIeZk9qxuzh= zn`??y4{q4y3BYws`QX?;+ z+2H5=tTo*<+6)lof9UtS_*W4KnYW}-uV~&nPdH-U(v`m=+t$yZ4&r9bWy<=K%vo$( z9a1?h3|l_(Z)avCOZ5)=;>=m(5}#qV%hX}iPqoU4BKEV)NytLev!}U;YN6hRH;2|W z=@jZI=J#$o@1gTF9ihMX(#MGptwWHJ>Ur`w9YRzE5@y4+U7%8k^lvHn*`gCbT*l8W z1iumFje=iKtV8@`Qk;2|@C$u>5&mvGzM=@<*d)R?g+%zKK!kfI>2&ESJ{&VC(|b5( zQcmiB@o7B~$g3fcH>++SRk@7DswCcg`LYZxs7SrYWSCUa@+ZSMq&3rHV*4D57uiI{ z&5K}^lhv0YvwxjUM$KQ(hrtlnEw3(9cwZt&BTn@^mvj{<=|X~q>WLc zI!$MoPD?vBd*UDYd3){BQbw#KXLj^&`Z@RL>R5?*yR!KCQ)Vp;%&U->Q2w}n-n|;_ zA58!Wxm-~I{dWQq0p!)siX_lSP{S=H&|foakwBfg3@?!gdY<{pNqMI@bKC zqC@(Y3^hsf-guKfDja%=M<6RG5L*utS@~ZCuFej4Vq^uDO*Jl;f^5JnEt0mD4R1p1 z6=lP^CfTq)BpcTM=(0g%!79jtt5gq=xJa_EKonfoV=%E~Q-nqMSqcyNbB@AUxh%j` z8!Y`Wie0k=+co^DJ7DJ1ODJe28iE1z6>OQGg>x|hr-jfU*4{XeCfa4ljPJAQ*dAsL zMIO5f(wFO9e1DmOLw$(24I>lvZ|IAY5kH5BACja$3{SmVau)$XU!*=?L_V;XiaEBF z50?o_4`>qR6B!1DYIBv z*T(g9vWhN;wPRdA*N%U#oy+6D+a408%hTW6v2w1U&wocuFZ^ z;QPIE;8%O+z_0PnfnV#L13zGIvNyvrw$2{3ug3p+Ilzd=4(S7oHsAmw9*WebSJaJT zV35YqLtu*6DK0*m`j^k$|J>!v-@9jO`UCfW<>bG7?6#>-|JldDvwQ9kc3F9n{97iC z_M$P|)Ew?1!d~{t7t*`nK5wcl!h=8`(j#8fxJE2IP5l5DscNokv*o{tC^bSSuzx*> z;4TuMSl7Dc6`#>YbWCC~ir=M4IQ}{sf2o>YKf^tVShj{~7_8!2TT5f338qOn0rN=G z*^Ga#?%Imy8Si-(&tHb;ZFqh?o}6!>uGuwm*if^=+!R4G{IU{0qX%a^lt$DW=r5Rh`I#@yws0Ku7m?s<0~8g z#8)rq+7Uq^-j?;F))APPT71{aMyvS&RArv5vEka3nLvyk$_})nZF&wUV4Ul6keCbC1S45LbxxKlI0B&4R@u z%|$ZD{j7U+)~!YxY`OTL%(0}P6T9AG`B>f zP|~?D4fsn)rGA-?Cymd7%Js94563NV)_js2!wSCfT_)10SXC4Ni$*`R3lG!C8u8|88wu*lTd@dKd- zYpRu2%1i}#>V>~@9G0Bw)2VBxgIaExX>xqA|uD%*IT+(HT4 z7kQ0f%NmnyJ@c$8J+Rb(&2cgju7HG^D=gD$>X@7(ImL9gG8OJ9hZ!{d*3%ot&NB|L~E+WBbRBBZL?eYOt+}q!!!ir;xYX zd*tx3gU1g(xW9OC?7+dXgU4Uv_KxkpXHV!+gBezMyo`}Wc}OU9$OUVWLq zU#BCJx*ul&&eCaVh9xH$L`}#RqDC!H&%;tyVyisnVlj8xiC=hUQm5>5!d@mAW0_M4 zztD%2#gFs5aDHt4@S6V%`k~efW!J^{2GI*QLNB~l^`byiQ2X%t-Vib;4M~OF2yC0Hi4x>@2=X`aa=ptd zN(&7F=~g7h|Bx9|L0AsWUr~(z33JlJ1P?_s{rOug^rn_lTz!=_^EEnOrxQ$shK05I z&y4+TIviH(c~M~>fj|}s90+8Q&m=RUhX#RsWm(LYc{7UR+zHQ*DvKeBnNJD7(8rg= zKaa=FlDM3~?R$DUly~#BkGGX``p_U)S=!;38~WhS!!Nh=!H<2Au+(7hAD+ogeR$Rd zzp>PG!*47#J)Whe;8|*VVX5Jre|c{QWS_SKa+OHfen{9&st<^|IK5;6Cl^oRg!uA- zmcr6GfV9i9iE|ra8@3T{z(FD_-asfAb!wBczHM5|+f3r`*Je=08B9i@-qUO$*6-zk%CWibyBK z3(}oE*!nP&*fVxy!j{lsfB7Q&NE5SVANdDlr~V5fgHr#fvYRcSSSIy{F~BIh|B1jv zcK4W~z68SC?c~9IxL#Zg@joC8k>Y-JHbzIt6lm${qKe}&y|J!T7aH+bSelsn zbMrIRsS2(n#D&-|0ID=&E?Mt0WecKT4C;InRQ1Qv8g#MAUcenz|A%G#CX&>9n_wMQ z5l}v@>H;oVd(6UPO%HLPOvxUusw9|`hSgjyL`HxCF)eGpN@DmL91P~gtRd9VQlOC` zX9-EB5d2aFg1=GKpx+1dEdr8FaDU1=Yb7l^n7Pa%bek$`Auj#;>POD(+tZe6vt{AA zwyR?BFa2BnJ^&7RyEdg{aaspES%JV)NFC|Sc&4e3qkDi#sEpnP1sePo%kxG$arvIb z3#*u~4CVd)^ir&h#%VI_GR5K==C4hNrqWE5Dgyq{>Lv+}bk1iKrjp|uo-4DRq{a3}mCg+=yu_;R=#&y5`J zf#1mC0{k*(g7m%c%l*0V_rWiB=)%7Wez`{%{(ku7E?xLn!!PqF@UMYi=2GBa3%{&9 zhJOHlnNxv(9sF`J1pMpa=hYApVmP6o!8L2>3U_FIPptzZrhH zE&~2R_~pt7_^*avu8n|y3;et|g86TSUoMY;e;fR~K7!A;i*B(4!t-vm3iYqVETJnNrEGKf?OUO^; z-A=&LeN^sX*D(Cp2oS^Fyi??i=HiJwa5EOn#fiptWvWtx;_#ebJim;L-pAJJ_D@>g-V0 zkdj&y_!u!GuzP&ip-T4SL!cX#4q59&(2eJY%z?-7nqUk967zlB(dW8l#Pq<`HX)5%ax2ag>d#Z?HZI`b-^Dtj&0;H-mssH%cQ5q$m5K8XBvRhjF; z=X>;K3i%gIsn$FSBww($sqe7*zDK92H}+SY`zB6J9JFyfaAmSmR!4BK>JcD!2|sKh z#FolUjqMms+!9IkPlWeb5OBQUtC2D%qi4JP zxh`~C5k>zmv5BK4v=GaunZY=bc!WrVS|>=*61MsQ0f;HogZMvNL0r`c(PKYv@BwdZ zF8xZ`l=?;sz;b@u2?7#s-_TvIbQY^2zX-=yt6RZYgNVs^I4j{p>V*~nc(UyAN^M3i zc$tm|@?=aWuA{8qbH?#$-V1T6NiqPs+2^Rm_vnl=kaiAX#ms5Ypis#|1u_y8{}Wp zTOpNWq&e@@Cr|!!7)K{)CAVQ@LX;j8AL4zRgO)|JRV>vfm=Ut`~;t2 zF{3uL%JIed@>#$VOGG+ZZ_vuT*p^^ailw+Rh+br}ucFGO8qVFv z#eKEKw*#2U;LZ9~L6IVktk7m@fd>Z_@|jEjIKMF?$jN)!}8iqxlUU>ycp8#RFTmX*G20jY279B=pU+G?gr z(ZuBhl&6V@n9`awaee(3vojz1eN41n2AI(Bv>Qf!wa zDTbhdp#H;2LN!2`rt&XQ;>0U40Sl}4lZ71vvKH4Nr^YG?7+flsaZ;%IA4D}yNq`c4 zFAg?1wt$Q8rf~4Whk&J!@fzv}4UD8IT}xC|HxL)#e@@_kc_rYeA!yM)?2odBco<7P zR6~tPLSWf4{EwAZU++{6j)aNT!@Cwx9L1f=WpnIm(JhP`FlG5K<6Lnh=w7G&A%}Czv%SS zp#WAtq(hFZd0Uc&PSfEbKdOxmPu5Xgbb9FY(&?kq(o#cRY7=V2ISr4o)Nmz3cQV)3 zXrYPqbFaAhaUXf}FYm>3J6dxb!}4w)mi7R63BS;XU19`3=UpgsoXw}4wK?}fOGO*} za%BVjIrz=&OFR5#_9YL$vHWzvZ)RXR;Ww6_F8Gb*ryG7_`RRe*Sbhrd8_Q2G{KoRr z2fwlWtb*TIe){1zmY>z|8_Ulc_>JXfE&RsvGXTG_{H%lDSbo;SZ!AAo!EY=-8{jvV zpN;Sv%g-kGjpb)E{KoP#2*0uXTn)dm{A_{WSbny`FPDdkMJTH;5T!-P-V25^s`}9` z3!C9gL)9Lh!Pz^*xbo%X;9tM_{eyq=fzLnpi=X`NSDt?UvmczQJkx*5JioU|%LvsOJcN7^x%qBZ26BeZ&-@(zQLHGSz)xiX{Hvd@Io9L3X*K1+CF+HDtjOxzNn8elHu=g?1{ z#h+S-2XZc1RmFn13h|%!LF5GlCiY>`NBR8^{Ya>pA&-yJFn9(Mj{LG?bKZbtzvNez z&RJ4N6f={vOk{~-1_r|`zQQvwv2!7**~;7(2<1tj=QRl)EdvG)%UL#ziPK+fhB0wE zQbXh(q>RuwP8uNXJgRE3wX_+9{}S_-*>T;(OuUlJOD9@nK8Vb}+>|*JM`{OYG{JHT zR4eK{n9-1HQj-zxba^bU5!4pI`8C3M2CsXKfV3+pLy9*H#C3tK$oe<@BIquMv@6LP zvt_YaZ$s9<*_1WXt{`jNBRX~C4Y8STN9O;@&stbe;HYaZ9t%xJFAjV4;v2#+B9T|aN#jhJ{v znYXHw>yY{HH)p=GN=f6cllWSB88ZJybLOlTJoi8JBaP-RS0kkPuh%a#%={+YreQ6* zR`YENYA2HaAptyt4Cui8W#@XI!mf}x)r_`mP;^Cl0WQZ##z!1D8y8n2$@q9%$O`}Og3^!<0O8a@iJT$+6p65|FO+@YHaP7(d)0j#6YgQWTf#){z#J_r% zRGoGXH?!!_S1}+qN~pvT#Yx#lV;<#eDPN4`Nd;6c<{Td(+kMl z18$zT2EN0q)jc%Y05ofOJ-}*39xm*q>v2*m5D_yL5mC3&3HLsj<*4ZHtDO2zM!_nC%uTZ@+sE# zS$NFYKbge194qerfBVrkAn>{^8CI5nOz4C5NQ~fjiN?XO9e}-2t;XYee=rc`+32Mj zJI@&QW`)~L?P*mR%;g_Z8TuSjIaW_{j-Z1yf{yca6FOz=@U&B6j>y1oOcPo7jcK9{ zeq)-*!Ea0x?eH7ZL>~Uta&8W~4z~WL{i`uL;g|Ds@Vu+sJ>4^2fZL0uDBaVma1};3 zs$-2>!|EtBRL7!&%bOy_NFmuMe*S_*y;QPa8`zU$mG2@2<^i5X8muX;U_K&-hTPr~ z?1`9mJdOnSS7va5;SW$jdH^_ZOh6Aul9Z5V=z~Vl$asPPt2Tqqdk$I*dQJ^NwU2KHWoG|%+x_f+i1Nx*Mt5@1 z!eYmQS86{&OHDw1j2WMU1Ec<@>AxyQN);+HwOm`gcfvVIOR9xx(>m;04^(rCNE@>o zvq{ve>Ci0FP@bleC8tU$Lbx5N>g^tcsZz^Qh~U&B=Se7ccnh*Puix8$x>7?Z>)^EE zg+{uOI!u=logpkCmktjWpGHrXMJ;PGWgo*8xrrI-5=ni+tT#rdl*8V?B--o@Yw|1{ zgj0`{7ulMV6F8JwJrw3bf=LG^PL8N5=)AVr286^mpTj0(T(78UxFJDE6s7=@KbF7= zp$3Iz8Z&2ifsj1`j2T??hTCFvP5t- zB+u1qEf8#!JjYKe9CR7O&q~mLD_DA-ZfvqT%=r%!?{ST z3xt@J)q!*|NeH)1j^p9Qj2h&w1C2WXp{rp%3ObMQH#bw9!xSX$GQwQxsWKw%iSjJY zckblD!)Vood9ZMFjhld)oAutDKtPSq@d;Gc6mDd%pq-9w*zdJty+@HXa3{}Yd9O8#=N0idI`A}T)Xi$Nu_SVeBwOaQd=d9A z=(`1^G1O6Fe3J18>5E&j%!utQ1w}9Ea6Jzi>hwwgrWs@YM1}#gk@eB-`hJK2RgVb^ zUa@eA+I57>8Tc&v0-)wSsA?f=ryQ zepE!R7{=AG=ySFegf8wW^9kohLeYH6KxvF#1|-N~Y0@%A#FVP31p1A zAtp^Q-RxqeJYyF}Ss$-Oe7(!75B*%d1#mDpiWv>+69|qRJ$U#iPZj9mDFsD8D2El8 zklxNHtW-Gb91)RIv*+n+qf?{v7@gB}Zb1Q6oj%rzdJ~Z8}$a!6gX1NL4S}@Dz0*r5h}Jc%II{w zO{97bl$lopc)h+l7*FbYJygXOs}OmyB~dzo>-57Di1G?rvxv(VjQW=fE*pe6=GEi6 zhmGJZ-LOJO4T zwX{rW@We@-rSnB3ZYJ~;xYtnt*S92x03#;SB0gZ&1;L)fdODs=#d^@4T?0>R;Ca$( zfI*xP!p%CfFnJzl4FJo;8jMgHh+XGcaUJHVX;5p zC@S=V0xna;g9yd5to%41g40Ox_Ew>JUf-Vve}Ej~l-zMc>pX?Bz9xig z&h`}2Y`3)Cq``hYt1<{VtFo2|?_81R=(4P#+%1Tmc? zf*6q-#m`%)F-^9Td`t3`0Xk5Vq^9mgs-}v;@S!|Yu9YhWu$+0+R3kb`gyPt^0+_v$ zEM>`R0IJ@}#@QbOvQy{BMR$8@vjD6Xk*dBv+zgG0N~T96oiv2s7@D&$$+}=zIHcr_ z4UyEuEp6bP&n05}KH~KaI!%P~IXrvRR0hsk#jSKUpXIkg7053zMNxTxVxRHm;DjFirRk)BJ_-ZXlhjoCY} zP%QpD%(6XAQi~}YCbTB7od`>zf5H^7J5oTCq$Pc;FR@U=bV$=f9-BEv$W7F94-zf4 zDqu+nzIFc=>;(M5|^SD;yWPs>u1=Px$h(QXT2nGu$98AjKiW_#|NKN>?niD+Q zkbnUR`gEYFC52qwG!DJAFEn7HJ{!{-&m)^R6PG99Y3|3!pnMwF(6aZK5B+{`(*2lo z(L|zg-_ao?Q~yBcXHX%{H1It{JV~gsK5$*Q4Q3`B+yo|&)hfO$WOXx;ABvo38|X=6 zg!NNQ{w_LC(IKPKH%SRP>{{x*j35oF_tD3;P^<(+oLZ|_)I%Ny#?BUas9xc~%XF>{ zKl7ELMh=>HKG}!$El5_vFZ2Pd#0Y+BA3%dhC?*%!C!@;Erjc^+Ez~zj5^qd^DKz&q8 zyJs`adp1*VWB7Qd=yP3QM*Zq4fT{Nc$X7cx0knZ-(d8iwA>(tL!aS>=NWVk1(*6lpnt3IH^U z3Boy^4nkNz?ZaB*!wMycfMffy2K`;G(-=+h>Uk+6s9z@eSe2ME#mru8fw7}l42F|X zC*DUCc)JpI$&hM>8{#6+kxWCU36$+uvle{S(`!M|KjW&IrbEs~zMl|94ts6rJ&!=6 zT~^9UdezW4sHmlDnaRv4A8uAt&a+4)rwZ%yB_3k%3v}XeK@A*HmDx%SrpylzpB&mT zr~yANf|FkZ9RFzwR(YPbOj?$0em-6)!3(Fg7Eeq#5?kPBfR95s z10fRh<0Jjrkf2xtnifgRHC@8H#32K7(TbWH?|mz{seP;2U9TgqB#yB(G_xJ^r!qB z8G6wiX+pe0j*PzG=g82D=J>KJ=g8>K_&G8(v|A=%Vd5)QRhbrYsE2UeBtqY3i0kp? z=whsWSaf9GRZm27df2l#7rFKXi%tEREwS0PVN^ViJ&)+%o=?fzCm;ZW9&L(PgNOI9 zPHSQYhvukFgf~cME1hk0xPe7oO=k<8?R0W<+UT^?A*)q8=#VD$ZL8PN$3d4|rzQ8M z$XWk#peyH!dFZeDk1RqjQ_<$9H?5PE%Bmun>eWVmvNBPvM48cSiXB0b6oq;e8(guC z6st9k=G@#}vsHUxrp%p+31=QoI#I}&p56El8(Ol^TS$A~JpcRJ3%d&`d~=1t!nVW{ zg}eJ!C7$TJsqcZlTl;R!y{50N@Y=#?;)(8j;b3>Bu%&QQp{Foh$iU4MvV~+J*`NIX E0O5KNX8-^I literal 0 HcmV?d00001 diff --git a/android_pyapi/java/__pycache__/math.cpython-310.pyc b/android_pyapi/java/__pycache__/math.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5233e35a54e1638ead263186312c1759e86b4247 GIT binary patch literal 21044 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/java/__pycache__/nio.cpython-310.pyc b/android_pyapi/java/__pycache__/nio.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d8dbd65f1d867f87d87823026abe00d7d7792942 GIT binary patch literal 15790 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 G^Zx@ecAPl? literal 0 HcmV?d00001 diff --git a/android_pyapi/java/__pycache__/nio_file.cpython-310.pyc b/android_pyapi/java/__pycache__/nio_file.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0b75e6124a01c6865200ef693543722defae3946 GIT binary patch literal 26930 zcmcJ24RBo7b>8mVw?9~dzybtG@JA#_Q4}GOpr}9Vhmr|`pah9r(gY+*J5pAQeGlN0 zi(Tlx2ZBIBTM`x9Noy;%lQ@YZ52<$Cu%5I@YftLbZksf1CX+TzowSp@dYWn7A2Vs2 zbl6T3O+4!No%`O~eftCYr(MpwxPR~7bI(2J+;h)8_p!clV>X80(O-S?;vYR1i+!7k z=AVhgF+9!{BNnq_g_sq$jB0$rC>ZgWm9WfeV!Hl>3#meCAzer#owCx^Orb~q zW(ynSZ*O5E{${Fu3;l(hUuU2&Xm7H5?9^Pm61$ct49&-^?0fOT=4WEo2CMh&nAK~W z$lrqWMyn6$K1pvyy5Gtnos;x1(gW5Y(u0!ThV&+D2`wHK*-to=ysN9t~*?zIjebpWY-NR3+eA$6Z^0IqwGzTY~C^g&7QNBWR8 zhV&R}-;2~?>j9)5u+ymBkMt4iL8Kp)+6Rz+$a)y*hb29V^dr`zNIxp+`;h*S^%&BR zN&0@IAGe-B`Uy!NMEXhVDAGsmgJ}N{(ob1WBmK0Lk0JeG>lo6DcJ$ z)sJPLD_t&)+HMg>0hk0IhqQ0o3LnH2ZJ(2*Nw%5<7 zKz+`3ma49<=numim=@%Ob?VCNKT%P38Sk!4yUH#tc$-@?P}#MWw}GIXF1h6kNc5g( zWZG7jD`nfuNa}fe#mh=;@-oKa^+=qfCI%K)&IpFQ!D)Zen)0%zDz!^~dG^erU2Cn| zl((J0k5>VzwK937;DPNynDqrB+jm)h~YK)$$*B2WF zI~oOO>STSXW;F`8omKVA70XtqE6xHD(V?jQt&=Y(CWG-qdZ_UXE1mq};MKho+kJhyuh*s($!QrxiO;3`Ay zMppi2!pjtkwbFuJEPB~uaiMN4RT=Ls7GGZ~RdvbDn0f%UC3yeo!&b>H9bR&5b$Ge1 zE*&1PS*l*K4lS;XFIEnZ9R_nUU0hr#Ax-`}4E`(50q0|jE7I>hgo(>bCT7MZrz_~{ zepCavBlwe72N5=4(Xk`UWAOn-9t=`#EwVrUoLvY)WSF0b&0$%y5^whu5}$~fv4RQo zB-I{N%9n$8_+AoE!hf6*MAqUeJmKMQ6z;>lpaf`*#q-Q#Ib$d_Io>9YSq2#^5jmw&HE{+b`SIYS4$w^i!-Nh$S94 z1=3q4wk0l@X+v&6X~A^u#VhMf7mKAMnJ%X8*y7#mx5(m$@Mr>H>W(e$TfapXKN_~k z)E!$SU9U507C#=g$kZKM+`oQ{EIt~x$kZKMym$Q;S^VL!MW*i9BKdBeQM34X*dkMR zY;kn`7Fj$Qw#Zc17M-0a4VgV&NLWU}v=W7+WfoFa60Dw5IX0DMkYGSkzQtI6G~L2A zUS{G=daVr@Sg)eEZW)+5hP+#pf47nhQVckQw+PZLDpC2-jjdxh z&rOb>@RH}xO<~ef<7dxK=1+J7Gv{8&Phc7w7)ec_BC2Hd-(r69JoKf>Qhrj0Z%lQc}d4hjBVvFFvgvZ%}Aed}D<>AD$PIugqT%x!GUJ{CwEqKX~ znyo|a%bz)U=G3V(=Zm1i=Q~p&-?#Aik{wgXoUUL5l6^ZWt;6jsp2wr*FjIGI@vik- zWbwtYMW(v9NU4Ce?mkwJa&$W{sI#o~5d>a(@}msgw*C{yJ(ZZ14i552NJ!oNz-hCFf z>Ro4HSnoCq+w?xOuwCyj3p+$H+6l6INOmY?Lx!sZ4xSJ3?Honm#;(P#$8W^qu{A>t zxW>iAMRP4aA73-xi=T^qI(9YgCaE>8#fm96y%xKel6XdRrg(m|N6E4)8cL#AcRX{E z+a~j3y;4(;paU;il$_oocPFPRv;5Z-BtnnBtWtb>Z_c9l-M^d8GJb)6d*s%F4 zcti+iA%KVCSt?T-*;uGOmAM)OKgK!o2|Nx}YG{A4i}8!bHK^3;6=a}q3LiC#z%!{m z-;4`1O_W8o%G)q+yWDK#QRQREaM*5dd^IP%Hx)(zU?rkj0N9HNx(5JP<7+_X#n>f7 zZ6Fd|!%Yyu4X{iNQ3@MUY|=E0#3U4J;!0g$Ah-z;wF#7^9 zb%iz{38(-$j7S4Wm30jQHZA&bfU#NB@lvH)`9fU@Xg*Y)sp@sN6|6MCI*0sE5-2VK z8O~a701%5J;BeAdjo{oKMBv6;V#~OmxDkuuNT!Zx(b&qAW}SL<3ESW~=Cz=w&#jO9 zT7a_7&(KGPz06o$IJ7YIupNT~k@a^i=!Inw0v= zVSWpuIpJiJ&!SAYE(2Yu7wpQgG4ZStK{6*Jfk#HW50Q`#gVAEw=8u+R6uQKoO-6$y zm5^(I2)A+(-1OO{6PUd|m=mxXxIc%=KF1KsOnh}fCZ@SgnZN}=4{Rcw znnVa}!cDm5#pK1*8h~CiI9;EXsZh&!5lU+d< z?3yL9&a>bw%`Sq}uH)^dkqrkk;1@^ejWZCk9tXwUGIq&^%0UjqE`pY>o0JHQ-2g2` zb9J7U5=k!$n_P{izp~xRCRt>IzLqQQg3pNr;o2#FhUH4JGh3#1DsLv9Mdr%}?hXl7b5*%(N&;y?-u&B{>x#a(fJ zy{s5bL>Fj5w0a%o{{W8&j4YO|j6pWURO^+(7p!d~)0lPtwI1kSUFgfp=r zV5a7|Slviz0lbst(l?B&3Csu>?mRRFGv;Pi?u|oLgR&M+#a>35S&bMdk z{|Z$cEjxyx4f(oISlq_Jh$Qyux?nQt=Gkgu%9ho!Z)?t?id3=*Ea)7BoGYv{2 z{jdffAqj3Yu~-<@*aB2TPAms6Yjq+o<_#WZQ2T^&(x}wcPvHg4UH(FY`a=T1 zvGxUGyHVB#LWmRciz~a5pmReJEH8^C`Gh@J!l6mWo;RYLqAqr@C<=l(1-ckRsXoJRFo$!^?K(A_Rlk89Pi!+2^9<9Eb!j1}WUW^=XtiE0Rh_3132L|L zMV`s(iaV*+PBKA5f5a}djH5OL4Owrpg7P*^h~PYf=eC|U3qyM=K5FDwb8@=mpFoY^ zSOG@zoPPjurdC}M`E%1(Zqm#CxmC*M(G(8MaJ*5OtJunE164r}!ug;2FC51g5cnVl z`H@*5aR*$jKEpSt5GX3B9cd_C z8#wr2g<|o~@V2lJ#7D5#)+M8NwV1KwkV4Jl1-;0M9$sfsF}TcNg~1wwHyOOm;NuLa z0jM8i@M#7=!QgWYKF{E17*I=B*BSf*gPROQG5bZv#0uUJf=@B;2m@+-)U?H@nZd3- zlg=bEsf>v*k;x#I$|UhGk?BEfgT!=MiZyatTPvf5$d9t(7#@dv=D>(#Q|&k2hD@N@ zn!7Ev0mYHY;foXsi_i$x483a@P2?lZah};E zH#q{!o0Ku>K*qcX(tq8cnL!KjxR_+HW&e59_u>n!tkrXL-mckK7S+>##Rdte@y3?e z>Q2fUXAI)CNzMdSv2o-++)LS4T&Tt^>aE_wB)sHYMS-y_)ax;~J}R<#jbM&^|gE1cV%NHpwpw9&yDXIjt{ib? z#0cTofE5CUxH``5wa^m=X&~uCcp-^Cefg51y0EFSR5mPZgemwDVSI#?sS8qVXto^& zR0oY5r7}gqmf-I*LujGFw45%F1_aJ}7SQN@&R`Q9eqkG`h^`4X`56YUAQ+9SUtxTX zK}#Rp{Z9vI*~pGW&Nq1)kkZ2%k=}>^KJ3joh=7B(;;`loKq-h-jjM5OKjuc6>H)+* zEXm|>%ycU688GRk@m^c2q|`LXK=KnixzUTVvRtiLH?FKz$gEuNqIh0znfh zXJkXVT<8r>!0A>C4%8RX$tKP?2Xi2{dL)WvTIK>zh>Gnraeb&=c=5xq-b=qW+VE1~ zZYaTCf5|CVDnN*V4I%Qd)HBp2&W<%%YjPLs0(P8!7P;ij#lfig~Z5U8_nAs^Q~fTxf)|0GMG_eic$)+c>m|%K-1^>- zb51C#@r&kA%(q@9SGH>F<;x<7mg#gSx)A7GRMs?A`pa{U;MU8`73Y)#Vf>KVZ;d5t6smvt=Lz=8&5W!y+7gg}%^;miYf*-x$d62L43BIE0vW2e z@$0#g03BI1fcGNyG>RkQQ#gw20~Z~Ci2=#ykfX*C_}eHiVO5|gm7x2yS;+<#m3A@@ z)cBP-w5-(znO)!Ee5|crSBTVi*gtny>Q(~?^~Z>N3HwU9mEZ@V!MV~+2ty@=VHd?q z2t!-N?-z*23Duu4Xb}fJmw7*comIoWMVSfu4$FU_F8@b|F8jkKPeLHrRz2)keAe4K z*0tI_7}bAgP=|+!b_1K>IuOHK4K*Hb$rBF z>~H`NBBGcoK2@`@>Gk?8938J42GMfn6sNPoc7_IMeSWn zh`Fx!yzDe^+LvB=Sg)5Zlo7uDh1k0|8hR_fOhw`S?V4^z+&V7TIPM5!fxad3#0b!; z7gQD?Ukr45wc>7E{VxRY;wkgyg&iBkcOUBqJ;8UB1%7R`iXB3BFi- zlc*a;4dV@-0`kmY3m4fpQs3=0b6jjYAyZy$TSiElBKinTIK8^-PRqpapxR$2ZGIDx z)z(`vW3u7W)}U7BV7*xU1zyuTk*;e3sq?RKh+3QOi)WI#tk7&58w4wXD77IQh(VVt z0f^mH)OXvo;b7QeZ*^mD#eEAFFT^yT4(J10|Jd)(343%>)c--=PlWi`*+RsSfk6A1 zp7nM=RC&9p#fEqx(C?sGQLVWy>R})^@*}(Q=j=lejK7lsRhXad+)1?=Ron0p@V@$e zlxkcw?F4WwV-YK!t#Fmgr&mASiL-x}=-@f%>JZI}{_Us+KeMmk#{rP?NP;4Fu#Cs5 z;!|*)erT|hfD7RbffZR)!GxEdtI72u&0ycfi_IcOeSnN6lpaCSOUnzk^DZEh8PD*L zP2A7|==>V(+dolps3CM$Vu;b7Vbc_6oUELwv5aKo7m%xZAK4(yZTJ%r!$buu(Y`Bo zH1!*dy~p5hF=(N_UqIg9CTwyfHz;;0sA7=h(vzD z0KQkv%ajEuBa05rY+c2V`b(5*Jx2iQCVIY1_(b&R!TR<@Eq8vH*5O23uU3CCY<{5G z<~PQ&w$_OZ(rsYyd_Ve*Te@U-H!GSf{(HgHDcl&2QUVzRdAfrraso{>%?p+FCD${T zaAm4#N=fqyCt0yyX8Xie2k&kQa;c;etkoc_20?Jf{tgNoI*tK1AwvwNWt2sJA!$5} z>_8OVSt$?vyFntoYAarCLo)!-SomE;)K?jFBM~oMao}fDvA!A%+&>Y=EzB{$sB8No zYUhJjB>ig$P@Lr&LfYy9 zd1e(=uI_Zd6Q$kh9u1^cHJ*ib#-4{qZ+AQktv`eoyV9X-yMLY75pg&qQ`l&FY<}tnFIlF)@^6KWYY!WZXDRC5`u6~Nx?IPF{44HnhwW=l3EG#!4xB<^D|l0K zmfFYH`x$gVx{&QZMWHXov0+FFpL8VWkWYHiM?lWaUKWT8m(Y@rxLnvlJcYP$3*u?S z<>C(F8N_F-UTfpqP~{3elIpYiC6$#_&Ki)^21yNCnME%AeL z)9?jFn{H(1z(aK&)=^z`K8rwm*1&^S-0gVfTMO7V;{?vn;rX0gy=N_{cGIEay2-2H zjKdQeF?!x0SMSWn-1PMf{P)cp(2Vr%963GF9PHP#E3h_S#lo?gayOt?T$SQ(-9p|+ zQ_I}7cktdJjXQX5??WKoI~%q44t?+I8|i}&msq34ljo-I2g{3`>LdbK2Y()aym-Bd z?L_zbC1n2rI8Iaw?UUvp5%)+)CBUuq{|hP{P=Q4V%KvG#mr!OR8*pDLDSa=I9Ly{kg?)mz@{|VDz$>+%&TBMuvJ>O;j@+TQG;xyO#~S| z>c)U^*o51MYJv7I8Mh2}4?w}Dg%&|=*xHL~Ed%#bmR+@7`%gLcLDV!rcGyYBa}9Fq zrAgTt(-k8l$4lX{n6n>=)r>wC^G6ATK1OA%V4nF8hhZ=%h;W!W3CJke)P4fB2QfGs z2&mDS@%nVXQ*-+JD(@3eIps2F!SqkLe|NdyRD`~W&4&x>5&d}QJN~BK`Fdre{ z2NChf*PuWK`SQL@&NUkZ$%}Rtg!c8+4NNQX#^c<0375Pc!RxK8xEpz%DK2^3{suHD z<9L_#Tc$j#2Sc)>I;0gST$JIlCJ-r}Cc%hUDPqe>qCsl8G8k@(Inira7;#;OSAt+x z#&=O<2l6Qs2I|Dc#8q<*%OZz@ftmh|gp;GDm%@qBT;&Sn`qCW!%K48F>}U!fLBV&K z7U$5tH^@tV)(nz$e)x$XX*|f$pX~U>Gc2iK<&LRG82m9H^Wt+IEzW&<{A`eI4G{+< z`HYc^r#?u5L*eJ|lYF#l_h}spF=53&#j8+)37I%}K@l!Y%cJ-MtKB7wL(|@D2@SK% z)i=;a>s)PW01#0A%1#1IBJKsKtJ^q+V7fS_uwH~g@s1Eam73c*1e~|)bOQv7hLKrSXRP|tOuG(tg`mkxB7mSbv{5|8Zk}%M%fsb0 zd^U?diT4CO4jQZS6)a~gEQ@rCRziNiO#vL7s$8SfO+qZNuOJ&{OA$nJl;LPGKvCo9Ctw`ykf`GvT~ohmf*E9P&pf|Qr{`70Wy^=!I}M6{ zuufm<)@g4A-`ujxOVaI;uvpWz3j@y5i zbmyJus;}ZquPn^gtCcdp6ZTZtyDyHS#a+7>H7m;C*Wu<(HkXxTEbzCLiTHN_T!Zv6 z#yY{3sW{J8EX%Hq10wOI*kWjpA!0-qMW8`7xi>0%C~nDl|DLNIPcJEOtoRWALL)Hp zmG5A6#Fw!W6&wdLa7|!9qMt|c=eFT#Yfi5B=iH(a7q_0AFrsPB=rMC%|&sJck z0$@i%U^~=`0834Rq(;oPoG?R{^=N zf8bLLzGRA4i2zNq34uO{L^IGXE+upW!x zAAu_jxX;vrR{G#K_b^MmQV#VR+!hC0i!R~l6zjozoV{-)9EemYR8x_~C(0U#5#z~*ZV zT8Oqs%WrY36UuF=Y2h6&QOCJ#YFS3P-kfPz>YOuLZia-OyUd!d+lCs>wNUjFi0F^^ z(3Eh^c&C>iKH`^a&cms|0?(WHh;$sgha)gAEyMn!Z6SK4rn+OOS%`rLIcTk6!$e>O zyZy(Q-NKl?tT0}!9$#^7XF1@?oRNy}`yg1VnyW-ej^q{se=-6*h$zDg1D{H~(ZwhrW`2@8Odxy0>fd{Lwfou@XBeM>kn<#LX)&SJIVLd~=tj9L^tnbh?L z3SHB7)`Ec!!}QZOP^r>=pvSunv^N-Nhe2*{9i+O<*$^i|x=OXq3qBiBvapC@+;293 zm09tP7L5uKP$^V7C$el_7Et|9(xfe#E9glFQ5mj9z93LL*Aj9gZ@ZO5trTkb`YX&B z2IerimTWdM2Bb)bGZ5p$t-~8lgBX`*z4&q)xpR$-u3YO&f*;5D^=c*Vug;h-We4u} zjMA(+0%Sr0d=#DFZWO6nFIOSycu9F5bx1ItKEQ)EPDwxmuVs5ZG%)c~!M5r^O6o1t z{5U724-L>DH%KcdY)X4SSe5Tr`yfWis1w)eSTN5!O zIGhs>!byuZ{%VtN3-<5rfPM8bK>0)C{<9(O_h~6CxYKmmVFm>I!no=R=K)?+_|wF; zL>(4VVbyCa68Zb1jCH`Yx1p)KcZhM?u1ttne#}nr?eCJC>P5zkh6U@CRPyP*)&7Qa zowkpBQub(E4*eS!iIuywVC7=@NqFLi{-b95J#uO#o7nhX1abjYPNIShARC8e9+twU zFINBo;!qmy|Mb^?M4{3rQtHpqTGQ@Sjx)Z9yq_Zy@WgN;<#PkQRhy=QN%`!Bx{YeV z=J$WIJ$BG^cyTYWF3W+$*oSBG_0O{tE@p5TrO38V}Wnr6z+tv{K^UV+g?zY(6(ntH=!}%g1Czly-3`2P`!vik19@*cq6VBZ{9_JK-Hn?{HZu4pqnqvy1*mN}w zfrzhC@u+hR9~pv%nZd^gQfnD;L(a&!`d@DvSz2%K371B_OuCSM5gjTl-f-o{ceD9z zFZE+c1#XT?vjvB&ew?q1zpgOIyUc4@!|{Rbn)Nq1bUAjx(0Sg+GYz;Gf46}IR*T3a zP8_i%lQ)A1k-%>UQvJXR-s7*}LtNN^gbde?>xPB1UOil%>$b?EyW3}QD>d5W0A;`g z9(gSoC)Ha`h=#tvD@@X04e4B1gQf(^z-eCa`DJ#G2m6;mOKL7|>l;ItzJm*EtHanQ z!SaQVG1O~^>t)w=4*?1Ie+rs7vSr}8MOB}*C+Kfdb7$bZ^Hl(#Z3=P~(!s5iXoUzE zgq9B#19bxd^+g(<&hX~2_H%riQxxr1{S@-Ph8M+hk_k;=!HW@sB8uDlz>cWV2WDPo z`L_s$NdK1pK9BysfkxC%BN7?>^SZUVoLfgA)LU~G)R0}LKwfCJ~4 zdXmA{`NlEE3kj=?Dgc?M@0%rH35;AIA{FnEG2jIW zb(H~^J@s)0pI{&&;nR$Lmci#3{3HY7S`h(FlMqs%9CH313Y{+jcz%^58#ns!Y`~Mn zlg4BA>L-oAd`#peeu#(fC(%xd?KQQ}{0tuEv5aZa($Ufp%x_rj8P=Z)d%ta7q4>h%+?<*pr@m_cj*)C1}lWK z?q!Zb5yk&mLEh9(0cNZhQ^IQ_{Kv2U^}%m4HN=FV&aq>t(7hk;}$D cmNRm_xdXYr-2Hemc&i70&0IFuJGANl0+oyYWB>pF literal 0 HcmV?d00001 diff --git a/android_pyapi/java/__pycache__/security.cpython-310.pyc b/android_pyapi/java/__pycache__/security.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..83345d4c86799c31be5318711b6f3a54e85858a6 GIT binary patch literal 42901 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
$OBT)!;wO)^7^i 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 literal 0 HcmV?d00001 diff --git a/android_pyapi/java/__pycache__/util.cpython-310.pyc b/android_pyapi/java/__pycache__/util.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..12977927a598877dc1ca3506984ab6995428820f GIT binary patch literal 125169 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 I)Sl)456VEte*gdg literal 0 HcmV?d00001 diff --git a/android_pyapi/java/__pycache__/util_concurrent.cpython-310.pyc b/android_pyapi/java/__pycache__/util_concurrent.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c37022e20b44213cd0c8f06765702c09d1629250 GIT binary patch literal 74607 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 e!EaM}Re2n_u0ZZ}R@=XaH9L literal 0 HcmV?d00001 diff --git a/android_pyapi/java/__pycache__/util_regex.cpython-310.pyc b/android_pyapi/java/__pycache__/util_regex.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8f0f3c119d1d3c24441588cc3ed5af1679743066 GIT binary patch literal 10046 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 Ru2swx=ZZ7N4~ovL^S?H#?z#W~ literal 0 HcmV?d00001 diff --git a/android_pyapi/java/__pycache__/util_zip.cpython-310.pyc b/android_pyapi/java/__pycache__/util_zip.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cce469bb9ea4029d79e9ee2c8e73ff669c34cdcc GIT binary patch literal 22263 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 mtPWMPRl7P?9UIg=+SNBvO89p&`=zjqeL+8!_ literal 0 HcmV?d00001 diff --git a/android_pyapi/java/crypto.py b/android_pyapi/java/crypto.py new file mode 100644 index 0000000..fe80f49 --- /dev/null +++ b/android_pyapi/java/crypto.py @@ -0,0 +1,628 @@ +""" +Java crypto standard library APIs implemented in Python. +javax.crypto package - Cipher, KeyGenerator, Mac, SecretKey, etc. +""" + +from .._core import Stub, AndroidOnlyError +from .lang import RuntimeException +import os as _os + +# Try to import cryptography library +try: + from cryptography.hazmat.primitives.ciphers import Cipher as _Cipher + from cryptography.hazmat.primitives.ciphers import algorithms as _algorithms + from cryptography.hazmat.primitives.ciphers import modes as _modes + from cryptography.hazmat.primitives import hashes as _hashes + from cryptography.hazmat.primitives.asymmetric import rsa as _rsa + from cryptography.hazmat.primitives.asymmetric import padding as _padding + from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC as _PBKDF2 + from cryptography.hazmat.backends import default_backend as _crypto_backend + HAS_CRYPTOGRAPHY = True +except ImportError: + HAS_CRYPTOGRAPHY = False + +from .security import ( + GeneralSecurityException, InvalidKeyException, + NoSuchAlgorithmException, NoSuchProviderException, + Key, SecretKeySpec, AlgorithmParameters, AlgorithmParametersSpi, + AlgorithmParameterGenerator, AlgorithmParameterGeneratorSpi, + Provider, SecureRandom, +) + +IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {}) +AEADBadTagException = type("AEADBadTagException", (GeneralSecurityException,), {}) +BadPaddingException = type("BadPaddingException", (GeneralSecurityException,), {}) +IllegalBlockSizeException = type("IllegalBlockSizeException", (GeneralSecurityException,), {}) +NoSuchPaddingException = type("NoSuchPaddingException", (GeneralSecurityException,), {}) +ShortBufferException = type("ShortBufferException", (GeneralSecurityException,), {}) +ExemptionMechanismException = type("ExemptionMechanismException", (GeneralSecurityException,), {}) + +__all__ = [ + "Cipher", "CipherSpi", + "KeyGenerator", "KeyGeneratorSpi", + "SecretKey", "SecretKeyFactory", "SecretKeyFactorySpi", + "Mac", "MacSpi", + "IvParameterSpec", "PBEParameterSpec", "GCMParameterSpec", + "OAEPParameterSpec", "PSource", "MGF1ParameterSpec", + "DHParameterSpec", "DSAParameterSpec", + "ECParameterSpec", "ECGenParameterSpec", "ECPoint", + "ECField", "ECFieldF2m", "ECFieldFp", "EllipticCurve", + "AlgorithmParameters", "AlgorithmParameterGenerator", + "AlgorithmParametersSpi", + "AEADBadTagException", "BadPaddingException", + "IllegalBlockSizeException", "NoSuchPaddingException", + "ShortBufferException", + "ExemptionMechanism", "ExemptionMechanismException", + "ExemptionMechanismSpi", +] + + +# ============================================================ +# SecretKey +# ============================================================ + +class SecretKey(Key): + def __init__(self, key_bytes=None, algorithm=""): + super().__init__() + self._key = key_bytes or b"" + self._algorithm = algorithm + + def getAlgorithm(self): + return self._algorithm + + def getFormat(self): + return "RAW" + + def getEncoded(self): + return self._key + + +# ============================================================ +# Cipher +# ============================================================ + +class Cipher(Stub): + ENCRYPT_MODE = 1 + DECRYPT_MODE = 2 + WRAP_MODE = 3 + UNWRAP_MODE = 4 + PUBLIC_KEY = 1 + PRIVATE_KEY = 2 + SECRET_KEY = 3 + + def __init__(self, transformation): + super().__init__() + self._transformation = transformation + self._opmode = 0 + self._key = None + self._iv = None + self._provider = Provider("AndroidOpenSSL", 1.0, "Android OpenSSL provider") + + @staticmethod + def getInstance(transformation, provider=None): + return Cipher(transformation) + + def init(self, opmode, key_or_cert, params=None, random=None): + self._opmode = opmode + self._key = key_or_cert + if isinstance(params, IvParameterSpec): + self._iv = params.getIV() + elif isinstance(params, GCMParameterSpec): + self._iv = params.getIV() + + def doFinal(self, input_data=None): + if input_data is None: + return b"" + if HAS_CRYPTOGRAPHY and self._key is not None: + try: + algo = self._transformation.split("/")[0].upper() + key_bytes = self._key.getEncoded() if hasattr(self._key, "getEncoded") else bytes(self._key) + iv = self._iv or b"\x00" * 16 + if algo == "AES": + if len(iv) == 12: + mode = _modes.GCM(iv) + else: + mode = _modes.CBC(iv) + cipher = _Cipher(_algorithms.AES(key_bytes), mode, backend=_crypto_backend()) + elif algo == "DES": + cipher = _Cipher(_algorithms.TripleDES(key_bytes), _modes.CBC(iv), backend=_crypto_backend()) + else: + return self._basic_cipher(input_data) + if self._opmode == Cipher.ENCRYPT_MODE: + encryptor = cipher.encryptor() + result = encryptor.update(input_data) + encryptor.finalize() + return result + else: + decryptor = cipher.decryptor() + result = decryptor.update(input_data) + decryptor.finalize() + return result + except Exception: + return self._basic_cipher(input_data) + else: + return self._basic_cipher(input_data) + + def _basic_cipher(self, data): + if self._opmode == Cipher.ENCRYPT_MODE: + if self._key is not None: + key_bytes = self._key.getEncoded() if hasattr(self._key, "getEncoded") else bytes(self._key) + return bytes([(b ^ key_bytes[i % len(key_bytes)]) & 0xFF for i, b in enumerate(data)]) + return data + else: + if self._key is not None: + key_bytes = self._key.getEncoded() if hasattr(self._key, "getEncoded") else bytes(self._key) + return bytes([(b ^ key_bytes[i % len(key_bytes)]) & 0xFF for i, b in enumerate(data)]) + return data + + def update(self, input_data): + return self._basic_cipher(input_data) + + def getBlockSize(self): + algo = self._transformation.split("/")[0].upper() + if algo == "AES": + return 16 + if algo == "DES" or algo == "DESede": + return 8 + return 1 + + def getOutputSize(self, input_len): + bs = self.getBlockSize() + if bs > 1: + return input_len + bs - (input_len % bs) + return input_len + + def getIV(self): + return self._iv + + def getParameters(self): + if self._iv: + return AlgorithmParameters(self._transformation.split("/")[0]) + return None + + def getAlgorithm(self): + return self._transformation + + def getProvider(self): + return self._provider + + def getExemptionMechanism(self): + return None + + def unwrap(self, wrapped_key, wrapped_key_algorithm, wrapped_key_type): + return SecretKey(wrapped_key, wrapped_key_algorithm) + + def wrap(self, key): + key_bytes = key.getEncoded() if hasattr(key, "getEncoded") else b"" + return self.doFinal(key_bytes) + + @staticmethod + def maxAllowedKeyLength(transformation): + return 2147483647 + + +class CipherSpi(Stub): + pass + + +# ============================================================ +# KeyGenerator +# ============================================================ + +class KeyGenerator(Stub): + def __init__(self, algorithm): + super().__init__() + self._algorithm = algorithm + self._key_size = 128 + self._secure_random = None + + @staticmethod + def getInstance(algorithm, provider=None): + return KeyGenerator(algorithm) + + def init(self, size_or_random, random=None): + if isinstance(size_or_random, int): + self._key_size = size_or_random + self._secure_random = random + else: + self._secure_random = size_or_random + + def generateKey(self): + key_bytes = _os.urandom(self._key_size // 8) + return SecretKey(key_bytes, self._algorithm) + + def getAlgorithm(self): + return self._algorithm + + def getProvider(self): + return Provider("AndroidOpenSSL", 1.0, "Android OpenSSL provider") + + +class KeyGeneratorSpi(Stub): + pass + + +# ============================================================ +# SecretKeyFactory +# ============================================================ + +class SecretKeyFactory(Stub): + def __init__(self, algorithm): + super().__init__() + self._algorithm = algorithm + + @staticmethod + def getInstance(algorithm, provider=None): + return SecretKeyFactory(algorithm) + + def generateSecret(self, key_spec): + if isinstance(key_spec, SecretKeySpec): + return SecretKey(key_spec.getEncoded(), self._algorithm) + return SecretKey(b"", self._algorithm) + + def getKeySpec(self, secret_key, key_spec_cls): + return SecretKeySpec(secret_key.getEncoded(), self._algorithm) + + def translateKey(self, key): + return key + + def getAlgorithm(self): + return self._algorithm + + +class SecretKeyFactorySpi(Stub): + pass + + +# ============================================================ +# Mac +# ============================================================ + +class Mac(Stub): + def __init__(self, algorithm): + super().__init__() + self._algorithm = algorithm + self._key = None + self._state = "UNINITIALIZED" + self._data = b"" + + @staticmethod + def getInstance(algorithm, provider=None): + return Mac(algorithm) + + def init(self, key, params=None): + self._key = key + self._state = "INITIALIZED" + self._data = b"" + + def update(self, input_data, offset=0, length=-1): + if length < 0: + self._data += bytes(input_data) + else: + self._data += bytes(input_data[offset:offset+length]) + + def doFinal(self, input_data=None): + if input_data is not None: + self._data += bytes(input_data) + if HAS_CRYPTOGRAPHY and self._key is not None: + try: + key_bytes = self._key.getEncoded() if hasattr(self._key, "getEncoded") else bytes(self._key) + algo = self._algorithm.lower().replace("-", "") + if "sha256" in algo or "sha-256" in self._algorithm: + h = _hashlib.sha256(key_bytes + self._data) + elif "sha1" in algo or "sha-1" in self._algorithm: + h = _hashlib.sha1(key_bytes + self._data) + elif "md5" in algo: + h = _hashlib.md5(key_bytes + self._data) + else: + h = _hashlib.sha256(key_bytes + self._data) + result = h.digest() + self._data = b"" + return result + except Exception: + pass + import hashlib as _hashlib + key_bytes = self._key.getEncoded() if self._key and hasattr(self._key, "getEncoded") else b"key" + h = _hashlib.sha256(key_bytes + self._data) + result = h.digest() + self._data = b"" + return result + + def reset(self): + self._data = b"" + + def getAlgorithm(self): + return self._algorithm + + def getMacLength(self): + return 32 + + def getProvider(self): + return Provider("AndroidOpenSSL", 1.0, "Android OpenSSL provider") + + +class MacSpi(Stub): + pass + + +# ============================================================ +# Parameter specs +# ============================================================ + +class IvParameterSpec(Stub): + def __init__(self, iv): + super().__init__() + self._iv = bytes(iv) + + def getIV(self): + return self._iv + + +class PBEParameterSpec(Stub): + def __init__(self, salt, iteration_count): + super().__init__() + self._salt = bytes(salt) + self._iteration_count = iteration_count + + def getSalt(self): + return self._salt + + def getIterationCount(self): + return self._iteration_count + + +class GCMParameterSpec(Stub): + def __init__(self, t_len, src): + super().__init__() + self._t_len = t_len + self._iv = bytes(src) + + def getTLen(self): + return self._t_len + + def getIV(self): + return self._iv + + +class OAEPParameterSpec(Stub): + def __init__(self, md_name, mgf_name, mgf_spec, p_src): + super().__init__() + self._md_name = md_name + self._mgf_name = mgf_name + self._mgf_spec = mgf_spec + self._p_src = p_src + + def getDigestAlgorithm(self): + return self._md_name + + def getMGFAlgorithm(self): + return self._mgf_name + + def getMGFParameters(self): + return self._mgf_spec + + def getPSource(self): + return self._p_src + + +class PSource(Stub): + class PSpecified(Stub): + DEFAULT = None + + def __init__(self, p): + super().__init__() + self._p = p + + def getValue(self): + return self._p + + def __init__(self, p_src_id): + super().__init__() + self._p_src_id = p_src_id + + def getAlgorithm(self): + return self._p_src_id + + +PSource.PSpecified.DEFAULT = PSource.PSpecified(b"") + + +class MGF1ParameterSpec(Stub): + SHA1 = None + SHA256 = None + SHA384 = None + SHA512 = None + + def __init__(self, md_name): + super().__init__() + self._md_name = md_name + + def getDigestAlgorithm(self): + return self._md_name + + def toString(self): + return f"MGF1 {self._md_name}" + + +MGF1ParameterSpec.SHA1 = MGF1ParameterSpec("SHA-1") +MGF1ParameterSpec.SHA256 = MGF1ParameterSpec("SHA-256") +MGF1ParameterSpec.SHA384 = MGF1ParameterSpec("SHA-384") +MGF1ParameterSpec.SHA512 = MGF1ParameterSpec("SHA-512") + + +# ============================================================ +# DH / DSA / EC parameter specs (stubs) +# ============================================================ + +class DHParameterSpec(Stub): + def __init__(self, p, g, l=0): + super().__init__() + self._p = p + self._g = g + self._l = l + + def getP(self): + return self._p + + def getG(self): + return self._g + + def getL(self): + return self._l + + +class DSAParameterSpec(Stub): + def __init__(self, p, q, g): + super().__init__() + self._p = p + self._q = q + self._g = g + + def getP(self): + return self._p + + def getQ(self): + return self._q + + def getG(self): + return self._g + + +class ECPoint(Stub): + def __init__(self, affine_x, affine_y): + super().__init__() + self._affine_x = affine_x + self._affine_y = affine_y + + def getAffineX(self): + return self._affine_x + + def getAffineY(self): + return self._affine_y + + def equals(self, other): + if isinstance(other, ECPoint): + return self._affine_x == other._affine_x and self._affine_y == other._affine_y + return False + + def hashCode(self): + return hash((self._affine_x, self._affine_y)) + + +class ECField(Stub): + def getFieldSize(self): + raise NotImplementedError + + +class ECFieldFp(ECField): + def __init__(self, p): + super().__init__() + self._p = p + + def getP(self): + return self._p + + def getFieldSize(self): + return self._p.bit_length() + + +class ECFieldF2m(ECField): + def __init__(self, m, ks=None): + super().__init__() + self._m = m + self._ks = ks + + def getM(self): + return self._m + + def getMidTermsOfReductionPolynomial(self): + return self._ks + + def getFieldSize(self): + return self._m + + +class EllipticCurve(Stub): + def __init__(self, field, a, b, seed=None): + super().__init__() + self._field = field + self._a = a + self._b = b + self._seed = seed + + def getField(self): + return self._field + + def getA(self): + return self._a + + def getB(self): + return self._b + + def getSeed(self): + return self._seed + + +class ECParameterSpec(Stub): + def __init__(self, curve, generator, order, cofactor, seed=None): + super().__init__() + self._curve = curve + self._generator = generator + self._order = order + self._cofactor = cofactor + + def getCurve(self): + return self._curve + + def getGenerator(self): + return self._generator + + def getOrder(self): + return self._order + + def getCofactor(self): + return self._cofactor + + +class ECGenParameterSpec(Stub): + def __init__(self, name): + super().__init__() + self._name = name + + def getName(self): + return self._name + + +# ============================================================ +# ExemptionMechanism +# ============================================================ + +class ExemptionMechanism(Stub): + def __init__(self, name): + super().__init__() + self._name = name + self._state = False + + @staticmethod + def getInstance(name, provider=None): + return ExemptionMechanism(name) + + def init(self, key): + self._state = False + + def isCryptoAllowed(self, key): + return True + + def genExemptionBlob(self, data=None): + return b"" + + def getName(self): + return self._name + + def getOutputSize(self, input_len): + return input_len + + def storeMechanism(self, mechanism): + pass + + +class ExemptionMechanismSpi(Stub): + pass \ No newline at end of file diff --git a/android_pyapi/java/io.py b/android_pyapi/java/io.py new file mode 100644 index 0000000..c757108 --- /dev/null +++ b/android_pyapi/java/io.py @@ -0,0 +1,1933 @@ +""" +Java I/O standard library APIs implemented in Python. +java.io package - File, streams, readers, writers, and exceptions. +""" + +from .._core import Stub, AndroidOnlyError +import io as _pyio +import os as _os +import sys as _sys +import errno as _errno +import stat as _stat +import threading as _threading +from datetime import datetime as _datetime +from collections import OrderedDict as _OrderedDict +from pathlib import Path as _PathLibPath + +__all__ = [ + "Serializable", "Externalizable", "ObjectStreamField", "ObjectStreamConstants", + "FileFilter", "FilenameFilter", "File", "FileDescriptor", + "FileInputStream", "FileOutputStream", + "BufferedInputStream", "BufferedOutputStream", + "BufferedReader", "BufferedWriter", + "InputStreamReader", "OutputStreamWriter", + "FileReader", "FileWriter", "PrintWriter", + "ByteArrayInputStream", "ByteArrayOutputStream", + "StringReader", "StringWriter", + "DataInputStream", "DataOutputStream", + "ObjectInputStream", "ObjectOutputStream", + "FilterInputStream", "FilterOutputStream", + "PipedInputStream", "PipedOutputStream", + "PushbackInputStream", "SequenceInputStream", + "RandomAccessFile", + "Closeable", "Flushable", + "IOError", "IOException", "FileNotFoundException", + "EOFException", "CharConversionException", + "ObjectStreamException", "SyncFailedException", + "UTFDataFormatException", "WriteAbortedException", + "UnsupportedEncodingException", +] + + +# ============================================================ +# Marker / mixin interfaces +# ============================================================ + +class Closeable(Stub): + def close(self): + raise NotImplementedError + +class Flushable(Stub): + def flush(self): + raise NotImplementedError + +class Serializable(Stub): + pass + +class Externalizable(Stub): + pass + +class ObjectStreamConstants: + STREAM_MAGIC = 0xACED + STREAM_VERSION = 5 + TC_BASE = 0x70 + TC_NULL = 0x70 + TC_REFERENCE = 0x71 + TC_CLASS = 0x72 + TC_OBJECT = 0x73 + TC_STRING = 0x74 + TC_ARRAY = 0x75 + TC_ENUM = 0x7E + TC_CLASSDESC = 0x72 + TC_PROXYCLASSDESC = 0x7D + TC_BLOCKDATA = 0x77 + TC_ENDBLOCKDATA = 0x78 + TC_RESET = 0x79 + TC_EXCEPTION = 0x7A + TC_LONGSTRING = 0x7C + baseWireHandle = 0x7E0000 + +class ObjectStreamField(Stub): + def __init__(self, name, typ): + self._name = name + self._type = typ + + def getName(self): + return self._name + + def getType(self): + return self._type + + def toString(self): + return f"{self._type} {self._name}" + + +# ============================================================ +# FileFilter / FilenameFilter +# ============================================================ + +class FileFilter(Stub): + def accept(self, pathname): + raise NotImplementedError + +class FilenameFilter(Stub): + def accept(self, dir, name): + raise NotImplementedError + + +# ============================================================ +# FileDescriptor +# ============================================================ + +class FileDescriptor(Stub): + _valid_fd = -1 + + def __init__(self, fd=None): + super().__init__() + if fd is not None: + self._valid_fd = fd + + def valid(self): + return self._valid_fd >= 0 + + def sync(self): + if self._valid_fd >= 0: + try: + _os.fsync(self._valid_fd) + except OSError: + pass + + def hashCode(self): + return self._valid_fd + + @staticmethod + def _from_fileno(fd): + return FileDescriptor(fd) + + +# ============================================================ +# Exception classes +# ============================================================ + +class IOException(Exception): + def __init__(self, message=None, cause=None): + super().__init__(message) + self._cause = cause + + def getCause(self): + return self._cause + +class FileNotFoundException(IOException): + pass + +class EOFException(IOException): + pass + +class CharConversionException(IOException): + pass + +class ObjectStreamException(IOException): + pass + +class SyncFailedException(IOException): + pass + +class UTFDataFormatException(IOException): + pass + +class WriteAbortedException(ObjectStreamException): + def __init__(self, message=None, cause=None): + super().__init__(message) + self.detail = cause + +class UnsupportedEncodingException(IOException): + pass + +class IOError(Exception): + def __init__(self, message=None, cause=None): + super().__init__(message) + self._cause = cause + + def getCause(self): + return self._cause + + +# ============================================================ +# File +# ============================================================ + +class File(Stub): + separator = _os.sep + separatorChar = _os.sep + pathSeparator = _os.pathsep + pathSeparatorChar = _os.pathsep + + def __init__(self, *args): + super().__init__() + if len(args) == 1: + path = args[0] + if isinstance(path, File): + self._path = path._path + else: + self._path = str(path) + elif len(args) == 2: + parent, child = args + if parent is None: + self._path = str(child) + else: + parent_str = parent._path if isinstance(parent, File) else str(parent) + child_str = str(child) + if child_str.startswith(self.separator): + self._path = child_str + else: + self._path = _os.path.join(parent_str, child_str) + else: + self._path = "" + self._path = self._path or "" + + def _resolve(self): + return _os.path.realpath(self._path) if self._path else "" + + def exists(self): + return _os.path.exists(self._path) + + def isFile(self): + return _os.path.isfile(self._path) + + def isDirectory(self): + return _os.path.isdir(self._path) + + def getName(self): + return _os.path.basename(self._path) + + def getPath(self): + return self._path + + def getAbsolutePath(self): + return _os.path.abspath(self._path) + + def getCanonicalPath(self): + return _os.path.realpath(self._path) + + def getParent(self): + p = _os.path.dirname(self._path) + return p if p else None + + def getParentFile(self): + p = self.getParent() + return File(p) if p else None + + def length(self): + try: + return _os.path.getsize(self._path) + except OSError: + return 0 + + def lastModified(self): + try: + return int(_os.path.getmtime(self._path) * 1000) + except OSError: + return 0 + + def createNewFile(self): + try: + f = _os.open(self._path, _os.O_CREAT | _os.O_EXCL, 0o644) + _os.close(f) + return True + except OSError: + return False + + def delete(self): + try: + if self.isDirectory(): + _os.rmdir(self._path) + else: + _os.remove(self._path) + return True + except OSError: + return False + + def mkdir(self): + try: + _os.mkdir(self._path) + return True + except OSError: + return False + + def mkdirs(self): + try: + _os.makedirs(self._path, exist_ok=True) + return True + except OSError: + return False + + def renameTo(self, dest): + try: + dest_path = dest._path if isinstance(dest, File) else str(dest) + _os.rename(self._path, dest_path) + return True + except OSError: + return False + + def list(self): + try: + return _os.listdir(self._path) + except OSError: + return None + + def listFiles(self, filter=None): + try: + names = _os.listdir(self._path) + files = [File(self._path, n) for n in names] + if filter: + return [f for f in files if filter.accept(f)] + return files + except OSError: + return None + + @staticmethod + def listRoots(): + if _sys.platform == "win32": + import string + return [File(d + ":\\") for d in string.ascii_uppercase if _os.path.exists(d + ":\\")] + return [File("/")] + + def canRead(self): + return _os.access(self._path, _os.R_OK) + + def canWrite(self): + return _os.access(self._path, _os.W_OK) + + def canExecute(self): + return _os.access(self._path, _os.X_OK) + + def setReadable(self, readable, ownerOnly=True): + try: + if readable: + if ownerOnly: + _os.chmod(self._path, _stat.S_IRUSR | (_stat.S_IRGRP if _os.stat(self._path).st_gid else 0)) + else: + _os.chmod(self._path, _stat.S_IRUSR | _stat.S_IRGRP | _stat.S_IROTH) + else: + mode = _os.stat(self._path).st_mode + if ownerOnly: + mode &= ~_stat.S_IRUSR + else: + mode &= ~(_stat.S_IRUSR | _stat.S_IRGRP | _stat.S_IROTH) + _os.chmod(self._path, mode) + return True + except OSError: + return False + + def setWritable(self, writable, ownerOnly=True): + try: + if writable: + if ownerOnly: + _os.chmod(self._path, _stat.S_IWUSR) + else: + _os.chmod(self._path, _stat.S_IWUSR | _stat.S_IWGRP | _stat.S_IWOTH) + else: + mode = _os.stat(self._path).st_mode + if ownerOnly: + mode &= ~_stat.S_IWUSR + else: + mode &= ~(_stat.S_IWUSR | _stat.S_IWGRP | _stat.S_IWOTH) + _os.chmod(self._path, mode) + return True + except OSError: + return False + + def setExecutable(self, executable, ownerOnly=True): + try: + if executable: + if ownerOnly: + _os.chmod(self._path, _stat.S_IXUSR) + else: + _os.chmod(self._path, _stat.S_IXUSR | _stat.S_IXGRP | _stat.S_IXOTH) + else: + mode = _os.stat(self._path).st_mode + if ownerOnly: + mode &= ~_stat.S_IXUSR + else: + mode &= ~(_stat.S_IXUSR | _stat.S_IXGRP | _stat.S_IXOTH) + _os.chmod(self._path, mode) + return True + except OSError: + return False + + def isHidden(self): + return _os.path.basename(self._path).startswith(".") + + def toURL(self): + from urllib.parse import quote + return f"file:{quote(self.getAbsolutePath())}" + + def toURI(self): + return self.toURL() + + def getTotalSpace(self): + try: + st = _os.statvfs(self._path) + return st.f_frsize * st.f_blocks + except OSError: + return 0 + + def getFreeSpace(self): + try: + st = _os.statvfs(self._path) + return st.f_frsize * st.f_bfree + except OSError: + return 0 + + def getUsableSpace(self): + try: + st = _os.statvfs(self._path) + return st.f_frsize * st.f_bavail + except OSError: + return 0 + + def compareTo(self, other): + if isinstance(other, File): + return self._path.__cmp__(other._path) + return -1 + + def equals(self, other): + if isinstance(other, File): + return self._path == other._path + return False + + def hashCode(self): + return hash(self._path) & 0x7FFFFFFF + + def toString(self): + return self._path + + def toPath(self): + return _PathLibPath(self._path) + + def __str__(self): + return self._path + + def __repr__(self): + return f"File({self._path!r})" + + +# ============================================================ +# FileInputStream +# ============================================================ + +class FileInputStream(Closeable): + def __init__(self, file): + super().__init__() + if isinstance(file, File): + path = file.getPath() + else: + path = str(file) + self._path = path + self._fd = None + self._channel = None + self._closed = False + try: + self._fd = _os.open(path, _os.O_RDONLY) + except OSError as e: + raise FileNotFoundException(str(e)) + + def read(self, b=None, off=None, length=None): + if self._closed: + raise IOException("Stream closed") + if b is None: + data = _os.read(self._fd, 1) + return data[0] if data else -1 + if isinstance(b, (bytes, bytearray)): + if off is None: + off = 0 + if length is None: + length = len(b) - off + data = _os.read(self._fd, length) + if not data: + return -1 + n = len(data) + if isinstance(b, bytearray): + b[off:off+n] = data + else: + ba = bytearray(b) + ba[off:off+n] = data + b[:] = bytes(ba) + return n + return -1 + + def skip(self, n): + try: + pos = _os.lseek(self._fd, 0, _os.SEEK_CUR) + end = _os.lseek(self._fd, 0, _os.SEEK_END) + _os.lseek(self._fd, pos, _os.SEEK_SET) + actual = min(n, end - pos) + _os.lseek(self._fd, actual, _os.SEEK_CUR) + return actual + except OSError: + return 0 + + def available(self): + if self._closed: + return 0 + try: + pos = _os.lseek(self._fd, 0, _os.SEEK_CUR) + end = _os.lseek(self._fd, 0, _os.SEEK_END) + _os.lseek(self._fd, pos, _os.SEEK_SET) + return end - pos + except OSError: + return 0 + + def close(self): + if not self._closed: + self._closed = True + if self._fd is not None: + _os.close(self._fd) + self._fd = None + + def getFD(self): + if self._closed: + raise IOException("Stream closed") + return FileDescriptor(self._fd) + + def getChannel(self): + if self._closed: + raise IOException("Stream closed") + if self._channel is None: + import io as _pyio_mod + self._channel = _pyio_mod.FileIO(self._fd, closefd=False) + return self._channel + + def __del__(self): + self.close() + + +# ============================================================ +# FileOutputStream +# ============================================================ + +class FileOutputStream(Closeable, Flushable): + def __init__(self, file, append=False): + super().__init__() + if isinstance(file, File): + path = file.getPath() + elif isinstance(file, FileDescriptor): + self._fd = file._valid_fd + self._path = None + self._closed = False + self._channel = None + return + else: + path = str(file) + self._path = path + self._closed = False + self._channel = None + try: + flags = _os.O_WRONLY | _os.O_CREAT + if append: + flags |= _os.O_APPEND + else: + flags |= _os.O_TRUNC + self._fd = _os.open(path, flags, 0o644) + except OSError as e: + raise FileNotFoundException(str(e)) + + def write(self, b=None, off=None, length=None): + if self._closed: + raise IOException("Stream closed") + if b is None: + return + if isinstance(b, int): + _os.write(self._fd, bytes([b])) + elif isinstance(b, (bytes, bytearray)): + if off is None: + data = bytes(b) + else: + data = bytes(b[off:off+length if length else (len(b)-off)]) + _os.write(self._fd, data) + else: + if off is None: + data = bytes(b) + else: + data = bytes(b[off:off+length if length else (len(b)-off)]) + _os.write(self._fd, data) + + def close(self): + if not self._closed: + self._closed = True + if self._fd is not None: + _os.close(self._fd) + self._fd = None + + def getFD(self): + if self._closed: + raise IOException("Stream closed") + return FileDescriptor(self._fd) + + def getChannel(self): + if self._closed: + raise IOException("Stream closed") + if self._channel is None: + import io as _pyio_mod + self._channel = _pyio_mod.FileIO(self._fd, closefd=False, mode='ab') + return self._channel + + def flush(self): + if self._fd is not None: + try: + _os.fsync(self._fd) + except OSError: + pass + + def __del__(self): + self.close() + + +# ============================================================ +# FilterInputStream / FilterOutputStream (abstract wrappers) +# ============================================================ + +class FilterInputStream(Closeable): + def __init__(self, inp): + super().__init__() + self._in = inp + + def read(self, *args): + return self._in.read(*args) + + def skip(self, n): + return self._in.skip(n) + + def available(self): + return self._in.available() + + def close(self): + self._in.close() + + def mark(self, readlimit): + pass + + def reset(self): + raise IOException("mark/reset not supported") + + def markSupported(self): + return False + + +class FilterOutputStream(Closeable, Flushable): + def __init__(self, out): + super().__init__() + self._out = out + + def write(self, *args): + self._out.write(*args) + + def close(self): + self._out.close() + + def flush(self): + self._out.flush() + + +# ============================================================ +# BufferedInputStream +# ============================================================ + +class BufferedInputStream(FilterInputStream): + def __init__(self, inp, size=8192): + super().__init__(inp) + self._buffer = bytearray() + self._buf_size = size + self._pos = 0 + self._count = 0 + + def read(self, b=None, off=None, length=None): + if b is None: + if self._pos >= self._count: + self._fill() + if self._pos >= self._count: + return -1 + val = self._buffer[self._pos] + self._pos += 1 + return val + if off is None: + off = 0 + if length is None: + length = len(b) + total = 0 + while total < length: + if self._pos >= self._count: + if not self._fill(): + break + chunk = min(length - total, self._count - self._pos) + if isinstance(b, bytearray): + b[off+total:off+total+chunk] = self._buffer[self._pos:self._pos+chunk] + else: + ba = bytearray(b) + ba[off+total:off+total+chunk] = self._buffer[self._pos:self._pos+chunk] + b[:] = bytes(ba) + self._pos += chunk + total += chunk + return total if total > 0 else -1 + + def _fill(self): + data = self._in.read(bytearray(self._buf_size), 0, self._buf_size) + if data is None or data == -1: + return False + n = data if isinstance(data, int) else len(data) + self._buffer = bytearray(self._in._buffer if hasattr(self._in, '_buffer') else data) if n > 0 else bytearray() + self._pos = 0 + self._count = n + return n > 0 + + +# ============================================================ +# BufferedOutputStream +# ============================================================ + +class BufferedOutputStream(FilterOutputStream): + def __init__(self, out, size=8192): + super().__init__(out) + self._buf = bytearray() + self._buf_size = size + + def write(self, b=None, off=None, length=None): + if b is None: + return + if isinstance(b, int): + self._buf.append(b & 0xFF) + else: + if off is not None and length is not None: + data = b[off:off+length] + else: + data = b + self._buf.extend(data) + if len(self._buf) >= self._buf_size: + self.flush() + + def flush(self): + if self._buf: + self._out.write(bytes(self._buf)) + self._buf.clear() + self._out.flush() + + +# ============================================================ +# InputStreamReader +# ============================================================ + +class InputStreamReader(Closeable): + def __init__(self, inp, charset=None): + super().__init__() + self._in = inp + self._charset = charset or "utf-8" + self._buffer = None + + def read(self, cbuf=None, off=None, length=None): + if cbuf is None: + data = self._in.read() + if data is None or data == -1: + return -1 + return data & 0xFF + if off is None: + off = 0 + if length is None: + length = len(cbuf) + raw = self._in.read(bytearray(length), 0, length) + if raw is None or raw == -1: + return -1 + n = len(raw) if isinstance(raw, (bytes, bytearray)) else raw + if isinstance(raw, int): + return raw + decoded = raw.decode(self._charset, errors='replace') + for i, ch in enumerate(decoded): + if off + i < len(cbuf): + cbuf[off + i] = ch + return len(decoded) + + def getEncoding(self): + return self._charset + + def close(self): + self._in.close() + + +# ============================================================ +# OutputStreamWriter +# ============================================================ + +class OutputStreamWriter(Closeable, Flushable): + def __init__(self, out, charset=None): + super().__init__() + self._out = out + self._charset = charset or "utf-8" + + def write(self, s, off=None, length=None): + if isinstance(s, str): + if off is not None and length is not None: + s = s[off:off+length] + self._out.write(s.encode(self._charset)) + elif isinstance(s, (list, tuple)): + chars = "".join(s) + if off is not None and length is not None: + chars = chars[off:off+length] + self._out.write(chars.encode(self._charset)) + + def flush(self): + self._out.flush() + + def close(self): + self._out.close() + + def getEncoding(self): + return self._charset + + +# ============================================================ +# FileReader +# ============================================================ + +class FileReader(InputStreamReader): + def __init__(self, file): + if isinstance(file, File): + path = file.getPath() + else: + path = str(file) + inp = FileInputStream(path) + super().__init__(inp, "utf-8") + self._file_path = path + + +# ============================================================ +# FileWriter +# ============================================================ + +class FileWriter(OutputStreamWriter): + def __init__(self, file, append=False): + if isinstance(file, File): + path = file.getPath() + append = append + else: + path = str(file) + out = FileOutputStream(path, append) + super().__init__(out, "utf-8") + self._file_path = path + + +# ============================================================ +# BufferedReader +# ============================================================ + +class BufferedReader(Closeable): + def __init__(self, reader, size=8192): + super().__init__() + self._reader = reader + self._buf_size = size + self._buffer = "" + self._pos = 0 + self._closed = False + + def read(self, cbuf=None, off=None, length=None): + if self._closed: + raise IOException("Stream closed") + if cbuf is None: + if self._pos >= len(self._buffer): + self._fill() + if self._pos >= len(self._buffer): + return -1 + ch = ord(self._buffer[self._pos]) + self._pos += 1 + return ch + if off is None: + off = 0 + if length is None: + length = len(cbuf) + total = 0 + while total < length: + if self._pos >= len(self._buffer): + if not self._fill(): + break + chunk = min(length - total, len(self._buffer) - self._pos) + for i in range(chunk): + cbuf[off + total + i] = self._buffer[self._pos + i] + self._pos += chunk + total += chunk + return total if total > 0 else -1 + + def _fill(self): + if hasattr(self._reader, '_in'): + raw = self._reader._in.read(bytearray(self._buf_size), 0, self._buf_size) + if raw is None or raw == -1: + return False + data = bytes(raw) if isinstance(raw, int) else bytes(raw) + self._buffer = data.decode(self._reader.getEncoding() if hasattr(self._reader, 'getEncoding') else "utf-8", errors='replace') + else: + raw = [] + for _ in range(self._buf_size): + ch = self._reader.read() + if ch == -1: + break + raw.append(chr(ch)) + self._buffer = "".join(raw) + self._pos = 0 + return len(self._buffer) > 0 + + def readLine(self): + if self._closed: + raise IOException("Stream closed") + result = [] + while True: + if self._pos >= len(self._buffer): + if not self._fill(): + break + while self._pos < len(self._buffer): + ch = self._buffer[self._pos] + self._pos += 1 + if ch == "\n": + return "".join(result) + if ch == "\r": + if self._pos < len(self._buffer) and self._buffer[self._pos] == "\n": + self._pos += 1 + return "".join(result) + result.append(ch) + return "".join(result) if result else None + + def ready(self): + return self._pos < len(self._buffer) + + def mark(self, readAheadLimit): + self._mark_pos = self._pos + self._mark_buffer = self._buffer + + def reset(self): + if hasattr(self, '_mark_pos'): + self._pos = self._mark_pos + self._buffer = self._mark_buffer + else: + raise IOException("Mark not set") + + def markSupported(self): + return True + + def skip(self, n): + skipped = 0 + while skipped < n: + if self._pos >= len(self._buffer): + if not self._fill(): + break + chunk = min(n - skipped, len(self._buffer) - self._pos) + self._pos += chunk + skipped += chunk + return skipped + + def close(self): + self._closed = True + self._reader.close() + + def lines(self): + line = self.readLine() + while line is not None: + yield line + line = self.readLine() + + +# ============================================================ +# BufferedWriter +# ============================================================ + +class BufferedWriter(Closeable, Flushable): + def __init__(self, writer, size=8192): + super().__init__() + self._writer = writer + self._buf_size = size + self._buffer = [] + + def write(self, s, off=None, length=None): + if isinstance(s, str): + if off is not None and length is not None: + s = s[off:off+length] + self._buffer.append(s) + elif isinstance(s, (list, tuple)): + chars = "".join(s) + if off is not None and length is not None: + chars = chars[off:off+length] + self._buffer.append(chars) + elif isinstance(s, int): + self._buffer.append(chr(s)) + if sum(len(x) for x in self._buffer) >= self._buf_size: + self.flush() + + def newLine(self): + self._buffer.append("\n") + + def flush(self): + if self._buffer: + data = "".join(self._buffer) + self._writer.write(data) + self._buffer.clear() + self._writer.flush() + + def close(self): + self.flush() + self._writer.close() + + +# ============================================================ +# PrintWriter +# ============================================================ + +class PrintWriter(Closeable, Flushable): + def __init__(self, out, autoFlush=False): + super().__init__() + if isinstance(out, _pyio.TextIOBase): + self._out = out + else: + self._out = out + self._auto_flush = autoFlush + self._error = False + + def _write_str(self, s): + s = str(s) + if hasattr(self._out, 'write'): + self._out.write(s) + else: + self._out.write(s.encode('utf-8')) + + def print_bool(self, b): + self._write_str(str(b)) + if self._auto_flush: + self.flush() + + def print_char(self, c): + self._write_str(str(c)) + if self._auto_flush: + self.flush() + + def print_char_array(self, c): + self._write_str("".join(c)) + if self._auto_flush: + self.flush() + + def print_double(self, d): + self._write_str(str(d)) + if self._auto_flush: + self.flush() + + def print_float(self, f): + self._write_str(str(f)) + if self._auto_flush: + self.flush() + + def print_int(self, i): + self._write_str(str(i)) + if self._auto_flush: + self.flush() + + def print_long(self, l): + self._write_str(str(l)) + if self._auto_flush: + self.flush() + + def print_obj(self, obj): + self._write_str(str(obj)) + if self._auto_flush: + self.flush() + + def print_str(self, s): + self._write_str(str(s) if s is not None else "null") + if self._auto_flush: + self.flush() + + print = print_str + print_boolean = print_bool + + def println(self, s=None): + if s is None: + self._write_str("\n") + else: + self._write_str(str(s) + "\n") + if self._auto_flush: + self.flush() + + def println_bool(self, b): + self._write_str(str(b) + "\n") + if self._auto_flush: + self.flush() + + def println_char(self, c): + self._write_str(str(c) + "\n") + if self._auto_flush: + self.flush() + + def println_char_array(self, c): + self._write_str("".join(c) + "\n") + if self._auto_flush: + self.flush() + + def println_double(self, d): + self._write_str(str(d) + "\n") + if self._auto_flush: + self.flush() + + def println_float(self, f): + self._write_str(str(f) + "\n") + if self._auto_flush: + self.flush() + + def println_int(self, i): + self._write_str(str(i) + "\n") + if self._auto_flush: + self.flush() + + def println_long(self, l): + self._write_str(str(l) + "\n") + if self._auto_flush: + self.flush() + + def println_obj(self, obj): + self._write_str(str(obj) + "\n") + if self._auto_flush: + self.flush() + + def write(self, s, off=None, length=None): + if isinstance(s, str): + if off is not None and length is not None: + s = s[off:off+length] + self._write_str(s) + else: + self._write_str(str(s)) + + def format(self, fmt, *args): + s = str(fmt) % args if args else str(fmt) + self._write_str(s) + return self + + def printf(self, fmt, *args): + return self.format(fmt, *args) + + def flush(self): + if hasattr(self._out, 'flush'): + self._out.flush() + + def close(self): + self.flush() + if hasattr(self._out, 'close'): + self._out.close() + + def checkError(self): + return self._error + + def setError(self): + self._error = True + + +# ============================================================ +# ByteArrayInputStream +# ============================================================ + +class ByteArrayInputStream(Closeable): + def __init__(self, buf): + super().__init__() + self._buf = bytes(buf) + self._pos = 0 + self._count = len(self._buf) + self._mark = 0 + self._closed = False + + def read(self, b=None, off=None, length=None): + if self._closed: + raise IOException("Stream closed") + if b is None: + if self._pos >= self._count: + return -1 + val = self._buf[self._pos] & 0xFF + self._pos += 1 + return val + if off is None: + off = 0 + if length is None: + length = len(b) + avail = self._count - self._pos + if avail <= 0: + return -1 + n = min(length, avail) + if isinstance(b, bytearray): + b[off:off+n] = self._buf[self._pos:self._pos+n] + else: + ba = bytearray(b) + ba[off:off+n] = self._buf[self._pos:self._pos+n] + b[:] = bytes(ba) + self._pos += n + return n + + def skip(self, n): + if self._closed: + return 0 + avail = self._count - self._pos + actual = min(n, avail) + self._pos += actual + return actual + + def available(self): + if self._closed: + return 0 + return self._count - self._pos + + def close(self): + self._closed = True + + def mark(self, readAheadLimit): + self._mark = self._pos + + def reset(self): + self._pos = self._mark + + +# ============================================================ +# ByteArrayOutputStream +# ============================================================ + +class ByteArrayOutputStream(Closeable, Flushable): + def __init__(self, size=32): + super().__init__() + self._buf = bytearray() + self._closed = False + + def write(self, b=None, off=None, length=None): + if self._closed: + raise IOException("Stream closed") + if b is None: + return + if isinstance(b, int): + self._buf.append(b & 0xFF) + elif isinstance(b, (bytes, bytearray)): + if off is not None and length is not None: + self._buf.extend(b[off:off+length]) + else: + self._buf.extend(b) + + def toByteArray(self): + return bytes(self._buf) + + def size(self): + return len(self._buf) + + def toString(self, charset=None): + if charset: + return bytes(self._buf).decode(charset, errors='replace') + return bytes(self._buf).decode('utf-8', errors='replace') + + def reset(self): + self._buf.clear() + + def close(self): + self._closed = True + + def flush(self): + pass + + +# ============================================================ +# StringReader +# ============================================================ + +class StringReader(Closeable): + def __init__(self, s): + super().__init__() + self._str = s + self._pos = 0 + self._length = len(s) + self._mark = 0 + self._closed = False + + def read(self, cbuf=None, off=None, length=None): + if self._closed: + raise IOException("Stream closed") + if cbuf is None: + if self._pos >= self._length: + return -1 + val = ord(self._str[self._pos]) + self._pos += 1 + return val + if off is None: + off = 0 + if length is None: + length = len(cbuf) + avail = self._length - self._pos + if avail <= 0: + return -1 + n = min(length, avail) + for i in range(n): + cbuf[off + i] = self._str[self._pos + i] + self._pos += n + return n + + def skip(self, n): + avail = self._length - self._pos + actual = min(n, avail) + self._pos += actual + return max(actual, 0) + + def ready(self): + return self._pos < self._length + + def mark(self, readAheadLimit): + self._mark = self._pos + + def reset(self): + self._pos = self._mark + + def markSupported(self): + return True + + def close(self): + self._closed = True + + +# ============================================================ +# StringWriter +# ============================================================ + +class StringWriter(Closeable, Flushable): + def __init__(self): + super().__init__() + self._buffer = [] + self._closed = False + + def write(self, s, off=None, length=None): + if self._closed: + raise IOException("Stream closed") + if isinstance(s, str): + if off is not None and length is not None: + s = s[off:off+length] + self._buffer.append(s) + elif isinstance(s, int): + self._buffer.append(chr(s)) + elif isinstance(s, (list, tuple)): + chars = "".join(s) + if off is not None and length is not None: + chars = chars[off:off+length] + self._buffer.append(chars) + + def flush(self): + pass + + def close(self): + self._closed = True + + def toString(self): + return "".join(self._buffer) + + def getBuffer(self): + return "".join(self._buffer) + + +# ============================================================ +# DataInputStream +# ============================================================ + +class DataInputStream(Closeable): + def __init__(self, inp): + super().__init__() + self._in = inp + + def read(self, b=None): + if b is None: + return self._in.read() + return self._in.read(b) + + def readBoolean(self): + v = self._in.read() + if v == -1: + raise EOFException() + return bool(v) + + def readByte(self): + v = self._in.read() + if v == -1: + raise EOFException() + return (v & 0xFF) if v <= 127 else (v - 256) + + def readChar(self): + hi = self._in.read() + lo = self._in.read() + if hi == -1 or lo == -1: + raise EOFException() + return chr((hi << 8) | lo) + + def readDouble(self): + return _struct.unpack(">d", self._read_bytes(8))[0] + + def readFloat(self): + return _struct.unpack(">f", self._read_bytes(4))[0] + + def readFully(self, b, off=0, length=None): + if length is None: + length = len(b) + total = 0 + while total < length: + n = self._in.read(b, off + total, length - total) + if n == -1: + raise EOFException() + total += n + + def readInt(self): + return _struct.unpack(">i", self._read_bytes(4))[0] + + def readLong(self): + return _struct.unpack(">q", self._read_bytes(8))[0] + + def readShort(self): + v = _struct.unpack(">h", self._read_bytes(2))[0] + return v + + def readUTF(self): + length = self.readUnsignedShort() + data = self._read_bytes(length) + return data.decode("utf-8") + + def readUnsignedByte(self): + v = self._in.read() + if v == -1: + raise EOFException() + return v & 0xFF + + def readUnsignedShort(self): + hi = self._in.read() + lo = self._in.read() + if hi == -1 or lo == -1: + raise EOFException() + return ((hi & 0xFF) << 8) | (lo & 0xFF) + + def skipBytes(self, n): + return self._in.skip(n) + + def _read_bytes(self, n): + buf = bytearray(n) + total = 0 + while total < n: + r = self._in.read(buf, total, n - total) + if r == -1: + raise EOFException() + total += r + return bytes(buf) + + def close(self): + self._in.close() + + +# ============================================================ +# DataOutputStream +# ============================================================ + +import struct as _struct + +class DataOutputStream(Closeable, Flushable): + def __init__(self, out): + super().__init__() + self._out = out + self._written = 0 + + def write(self, b=None, off=None, length=None): + if b is not None: + self._out.write(b, off, length) + self._written += length if length else (len(b) if isinstance(b, (bytes, bytearray)) else 1) + + def writeBoolean(self, v): + self._out.write(int(v)) + + def writeByte(self, v): + self._out.write(v & 0xFF) + + def writeBytes(self, s): + for ch in str(s): + self._out.write(ord(ch) & 0xFF) + + def writeChar(self, v): + self._out.write((v >> 8) & 0xFF) + self._out.write(v & 0xFF) + + def writeChars(self, s): + for ch in str(s): + self.writeChar(ord(ch)) + + def writeDouble(self, v): + self._write_struct(">d", v) + + def writeFloat(self, v): + self._write_struct(">f", v) + + def writeInt(self, v): + self._write_struct(">i", v) + + def writeLong(self, v): + self._write_struct(">q", v) + + def writeShort(self, v): + self._write_struct(">h", v) + + def writeUTF(self, s): + encoded = str(s).encode("utf-8") + self.writeShort(len(encoded)) + for b in encoded: + self._out.write(b) + + def size(self): + return self._written + + def _write_struct(self, fmt, v): + data = _struct.pack(fmt, v) + for b in data: + self._out.write(b) + + def flush(self): + self._out.flush() + + def close(self): + self._out.close() + + +# ============================================================ +# ObjectInputStream / ObjectOutputStream (stub) +# ============================================================ + +class ObjectInputStream(Closeable): + def __init__(self, inp): + super().__init__() + self._in = inp + + def readObject(self): + raise AndroidOnlyError("ObjectInputStream.readObject()") + + def readInt(self): + return DataInputStream(self._in).readInt() + + def close(self): + self._in.close() + + +class ObjectOutputStream(Closeable, Flushable): + def __init__(self, out): + super().__init__() + self._out = out + + def writeObject(self, obj): + raise AndroidOnlyError("ObjectOutputStream.writeObject()") + + def writeInt(self, v): + DataOutputStream(self._out).writeInt(v) + + def flush(self): + self._out.flush() + + def close(self): + self._out.close() + + +# ============================================================ +# PipedInputStream / PipedOutputStream +# ============================================================ + +class PipedInputStream(Closeable): + def __init__(self, src=None, pipe_size=1024): + super().__init__() + self._buffer = bytearray() + self._pipe_size = pipe_size + self._closed = False + self._lock = _threading.RLock() + self._data_available = _threading.Condition(self._lock) + if src: + src.connect(self) + + def connect(self, src): + src._sink = self + + def receive(self, b): + with self._lock: + self._buffer.append(b & 0xFF) + self._data_available.notify() + + def read(self, b=None, off=None, length=None): + with self._lock: + while len(self._buffer) == 0 and not self._closed: + self._data_available.wait(timeout=1) + if self._closed and len(self._buffer) == 0: + return -1 + if b is None: + if len(self._buffer) == 0: + return -1 + return self._buffer.pop(0) + if off is None: + off = 0 + if length is None: + length = len(b) + n = min(length, len(self._buffer)) + for i in range(n): + if isinstance(b, bytearray): + b[off + i] = self._buffer.pop(0) + else: + b[off + i] = self._buffer.pop(0) + return n + + def close(self): + with self._lock: + self._closed = True + self._data_available.notify_all() + + +class PipedOutputStream(Closeable): + def __init__(self, sink=None): + super().__init__() + self._sink = sink + + def connect(self, sink): + self._sink = sink + + def write(self, b, off=None, length=None): + if self._sink is None: + raise IOException("Pipe not connected") + if isinstance(b, int): + self._sink.receive(b) + else: + if off is not None and length is not None: + for i in range(off, off + length): + self._sink.receive(b[i]) + else: + for byte in b: + self._sink.receive(byte) + + def flush(self): + pass + + def close(self): + if self._sink: + self._sink.close() + + +# ============================================================ +# PushbackInputStream +# ============================================================ + +class PushbackInputStream(FilterInputStream): + def __init__(self, inp, size=1): + super().__init__(inp) + self._pushback_buf = bytearray() + self._max_size = size + + def read(self, b=None, off=None, length=None): + if b is None: + if self._pushback_buf: + return self._pushback_buf.pop(0) + return self._in.read() + if off is None: + off = 0 + if length is None: + length = len(b) + total = 0 + while self._pushback_buf and total < length: + if isinstance(b, bytearray): + b[off + total] = self._pushback_buf.pop(0) + else: + ba = bytearray(b) + ba[off + total] = self._pushback_buf.pop(0) + b[:] = bytes(ba) + total += 1 + if total < length: + n = self._in.read(b, off + total, length - total) + if n > 0: + total += n + return total if total > 0 else -1 + + def unread(self, b): + if isinstance(b, int): + if len(self._pushback_buf) >= self._max_size: + raise IOException("Pushback buffer overflow") + self._pushback_buf.append(b & 0xFF) + else: + for byte_val in b: + self.unread(byte_val) + + def close(self): + self._pushback_buf.clear() + self._in.close() + + +# ============================================================ +# SequenceInputStream +# ============================================================ + +class SequenceInputStream(Closeable): + def __init__(self, streams): + super().__init__() + if hasattr(streams, 'hasMoreElements'): + self._streams = [] + while streams.hasMoreElements(): + self._streams.append(streams.nextElement()) + else: + self._streams = list(streams) + self._current_idx = 0 + + def _current(self): + if self._current_idx < len(self._streams): + return self._streams[self._current_idx] + return None + + def read(self, b=None, off=None, length=None): + while self._current(): + inp = self._current() + if b is None: + result = inp.read() + else: + result = inp.read(b, off, length) + if result != -1: + return result + self._current_idx += 1 + return -1 + + def close(self): + for s in self._streams: + s.close() + + +# ============================================================ +# RandomAccessFile +# ============================================================ + +class RandomAccessFile(Closeable, Flushable): + def __init__(self, file, mode="r"): + super().__init__() + if isinstance(file, File): + path = file.getPath() + else: + path = str(file) + self._path = path + self._mode = mode + self._closed = False + py_modes = {"r": "rb", "rw": "r+b", "rws": "r+b", "rwd": "r+b"} + py_mode = py_modes.get(mode, "r+b") + try: + if "w" in mode and mode != "r": + self._file = open(path, py_mode) + else: + self._file = open(path, py_mode) + except FileNotFoundError as e: + if "w" in mode: + self._file = open(path, "w+b") + else: + raise FileNotFoundException(str(e)) + + def seek(self, pos): + self._file.seek(pos) + + def getFilePointer(self): + return self._file.tell() + + def length(self): + pos = self._file.tell() + self._file.seek(0, 2) + end = self._file.tell() + self._file.seek(pos) + return end + + def read(self, b=None, off=None, length=None): + if b is None: + data = self._file.read(1) + return data[0] if data else -1 + if off is None: + off = 0 + if length is None: + length = len(b) + data = self._file.read(length) + if not data: + return -1 + n = len(data) + if isinstance(b, bytearray): + b[off:off+n] = data + else: + ba = bytearray(b) + ba[off:off+n] = data + b[:] = bytes(ba) + return n + + def readBoolean(self): + v = self.read() + if v == -1: + raise EOFException() + return bool(v) + + def readByte(self): + v = self.read() + if v == -1: + raise EOFException() + return (v & 0xFF) if v <= 127 else (v - 256) + + def readChar(self): + hi = self.read() + lo = self.read() + if hi == -1 or lo == -1: + raise EOFException() + return chr((hi << 8) | lo) + + def readDouble(self): + data = self._read_bytes(8) + return _struct.unpack(">d", data)[0] + + def readFloat(self): + data = self._read_bytes(4) + return _struct.unpack(">f", data)[0] + + def readInt(self): + data = self._read_bytes(4) + return _struct.unpack(">i", data)[0] + + def readLine(self): + result = [] + while True: + ch = self.read() + if ch == -1: + break + if ch == 0x0A: + break + if ch == 0x0D: + next_ch = self.read() + if next_ch != 0x0A: + self.seek(self.getFilePointer() - 1) + break + result.append(chr(ch)) + return "".join(result) if result else None + + def readLong(self): + data = self._read_bytes(8) + return _struct.unpack(">q", data)[0] + + def readShort(self): + data = self._read_bytes(2) + return _struct.unpack(">h", data)[0] + + def readUnsignedByte(self): + v = self.read() + if v == -1: + raise EOFException() + return v & 0xFF + + def readUnsignedShort(self): + hi = self.read() + lo = self.read() + if hi == -1 or lo == -1: + raise EOFException() + return ((hi & 0xFF) << 8) | (lo & 0xFF) + + def readUTF(self): + length = self.readUnsignedShort() + data = self._read_bytes(length) + return data.decode("utf-8") + + def write(self, b=None, off=None, length=None): + if b is None: + return + if isinstance(b, int): + self._file.write(bytes([b & 0xFF])) + else: + if off is not None and length is not None: + self._file.write(bytes(b[off:off+length])) + else: + self._file.write(bytes(b)) + + def writeBoolean(self, v): + self.write(int(v)) + + def writeByte(self, v): + self.write(v & 0xFF) + + def writeBytes(self, s): + for ch in str(s): + self.write(ord(ch) & 0xFF) + + def writeChar(self, v): + self.write((v >> 8) & 0xFF) + self.write(v & 0xFF) + + def writeChars(self, s): + for ch in str(s): + self.writeChar(ord(ch)) + + def writeDouble(self, v): + data = _struct.pack(">d", v) + self._file.write(data) + + def writeFloat(self, v): + data = _struct.pack(">f", v) + self._file.write(data) + + def writeInt(self, v): + data = _struct.pack(">i", v) + self._file.write(data) + + def writeLong(self, v): + data = _struct.pack(">q", v) + self._file.write(data) + + def writeShort(self, v): + data = _struct.pack(">h", v) + self._file.write(data) + + def writeUTF(self, s): + encoded = str(s).encode("utf-8") + self.writeShort(len(encoded)) + self._file.write(encoded) + + def _read_bytes(self, n): + data = self._file.read(n) + if len(data) < n: + raise EOFException() + return data + + def setLength(self, new_length): + pos = self.getFilePointer() + self._file.truncate(new_length) + if pos > new_length: + self.seek(new_length) + + def close(self): + if not self._closed: + self._closed = True + self._file.close() + + def getChannel(self): + return self._file + + def flush(self): + self._file.flush() + + def __del__(self): + self.close() \ No newline at end of file diff --git a/android_pyapi/java/lang.py b/android_pyapi/java/lang.py new file mode 100644 index 0000000..59d746e --- /dev/null +++ b/android_pyapi/java/lang.py @@ -0,0 +1,1452 @@ +""" +Java lang standard library APIs implemented in Python. +java.lang package - String, Integer, Math, Thread, System, Object, etc. +""" + +from .._core import Stub, AndroidOnlyError +import re as _re +import math as _py_math +import sys as _sys +import os as _os +import time as _time +import threading as _threading +import inspect as _inspect +import math +import random +import time +from datetime import datetime as _datetime + +__all__ = [ + "Object", "Throwable", "Exception", "RuntimeException", "Error", + "String", "Integer", "Long", "Short", "Byte", "Float", "Double", + "Boolean", "Character", "Math", "StrictMath", "System", + "Thread", "ThreadLocal", "StringBuilder", "StringBuffer", + "Class", "Void", "VoidType", + "Stub", "Comparable", "CharSequence", "Iterable", "Appendable", + "Readable", "AutoCloseable", "Cloneable", "Runnable", + "StackTraceElement", "Number", "SuppressWarnings", "Deprecated", + "Override", "FunctionalInterface", +] + + +# ============================================================ +# Interfaces +# ============================================================ + +class Comparable(Stub): + def compareTo(self, other): + raise NotImplementedError + +class Iterable(Stub): + def iterator(self): + raise NotImplementedError + +class AutoCloseable(Stub): + def close(self): + raise NotImplementedError + +class Cloneable(Stub): + def clone(self): + return self.__class__() + +class CharSequence(Stub): + def length(self): + raise NotImplementedError + def charAt(self, index): + raise NotImplementedError + def subSequence(self, start, end): + raise NotImplementedError + def toString(self): + raise NotImplementedError + +class Appendable(Stub): + def append(self, c): + raise NotImplementedError + +class Readable(Stub): + def read(self, cb): + raise NotImplementedError + +class Runnable(Stub): + def run(self): + pass + + +# ============================================================ +# Throwable hierarchy +# ============================================================ + +class Throwable(Exception, Stub): + def __init__(self, message=None, cause=None): + super().__init__(message or "") + self._detail_message = str(message) if message else None + self._cause = cause + self._stack_trace = [] + self._suppressed = [] + self._fill_in_stack() + + def _fill_in_stack(self): + import traceback + stack = traceback.extract_stack() + self._stack_trace = [ + StackTraceElement( + frame.filename, frame.name, frame.filename, frame.lineno, False + ) + for frame in stack[:-1] + ] + + def getMessage(self): + return self._detail_message + + def getLocalizedMessage(self): + return self._detail_message + + def getCause(self): + return self._cause + + def initCause(self, cause): + self._cause = cause + return self + + def toString(self): + msg = self._detail_message or "" + return f"{self.__class__.__name__}: {msg}" if msg else self.__class__.__name__ + + def printStackTrace(self, file=None): + import traceback + if file is None: + file = _sys.stderr + traceback.print_exc(file=file) + + def fillInStackTrace(self): + self._fill_in_stack() + return self + + def getStackTrace(self): + return self._stack_trace + + def setStackTrace(self, stack_trace): + self._stack_trace = stack_trace + + def addSuppressed(self, exception): + self._suppressed.append(exception) + + def getSuppressed(self): + return self._suppressed + + def __str__(self): + return self.toString() + + +class Exception(Throwable): + pass + +class RuntimeException(Exception): + pass + +class Error(Throwable): + pass + + +# ============================================================ +# StackTraceElement +# ============================================================ + +class StackTraceElement(Stub): + def __init__(self, declaring_class, method_name, file_name, line_number, native_method): + super().__init__() + self._class = declaring_class + self._method = method_name + self._file = file_name + self._line = line_number + self._native = native_method + + def getClassName(self): + return self._class + + def getMethodName(self): + return self._method + + def getFileName(self): + return self._file + + def getLineNumber(self): + return self._line + + def isNativeMethod(self): + return self._native + + def toString(self): + return f"{self._class}.{self._method}({self._file}:{self._line})" + + +# ============================================================ +# Object +# ============================================================ + +class Object(Stub): + def __init__(self): + super().__init__() + + def getClass(self): + return self.__class__ + + def hashCode(self): + return hash(self) & 0x7FFFFFFF + + def equals(self, other): + return self is other + + def toString(self): + return f"{self.__class__.__name__}@{hex(id(self))}" + + def notify(self): + pass + + def notifyAll(self): + pass + + def wait(self, timeout=None): + pass + + def clone(self): + return self.__class__() + + def finalize(self): + pass + + +# ============================================================ +# String +# ============================================================ + +class String(CharSequence): + def __init__(self, value=None): + super().__init__() + if value is None: + self._str = "" + elif isinstance(value, bytes): + self._str = value.decode("utf-8", errors="replace") + else: + self._str = str(value) + + def charAt(self, index): + return self._str[index] + + def codePointAt(self, index): + return ord(self._str[index]) + + def codePointBefore(self, index): + return ord(self._str[index - 1]) if index > 0 else -1 + + def codePointCount(self, beginIndex, endIndex): + return endIndex - beginIndex + + def compareTo(self, other): + if isinstance(other, String): + return (self._str > other._str) - (self._str < other._str) + return -1 + + def compareToIgnoreCase(self, other): + if isinstance(other, String): + return (self._str.lower() > other._str.lower()) - (self._str.lower() < other._str.lower()) + return -1 + + def concat(self, s): + return String(self._str + str(s)) + + def contains(self, s): + return str(s) in self._str + + def contentEquals(self, cs): + return self._str == str(cs) + + def endsWith(self, suffix): + return self._str.endswith(suffix) + + def equals(self, other): + if isinstance(other, String): + return self._str == other._str + return False + + def equalsIgnoreCase(self, other): + if isinstance(other, String): + return self._str.lower() == other._str.lower() + return False + + def getBytes(self, charset="UTF-8"): + return self._str.encode(charset, errors="replace") + + def hashCode(self): + h = 0 + for c in self._str: + h = (31 * h + ord(c)) & 0xFFFFFFFF + return h if h < 0x80000000 else h - 0x100000000 + return h & 0x7FFFFFFF + + def indexOf(self, ch, fromIndex=0): + if isinstance(ch, int): + ch = chr(ch) + return self._str.index(str(ch), fromIndex) if str(ch) in self._str[fromIndex:] else -1 + + def intern(self): + return self + + def isEmpty(self): + return len(self._str) == 0 + + def lastIndexOf(self, ch, fromIndex=None): + if isinstance(ch, int): + ch = chr(ch) + if fromIndex is None: + fromIndex = len(self._str) - 1 + search_in = self._str[:fromIndex + 1] + return search_in.rfind(str(ch)) if str(ch) in search_in else -1 + + def length(self): + return len(self._str) + + def matches(self, regex): + return bool(_re.fullmatch(regex, self._str)) + + def offsetByCodePoints(self, index, codePointOffset): + return index + codePointOffset + + def regionMatches(self, ignoreCase, toffset, other, ooffset, length): + if ignoreCase: + return self._str[toffset:toffset+length].lower() == other._str[ooffset:ooffset+length].lower() + return self._str[toffset:toffset+length] == other._str[ooffset:ooffset+length] + + def replace(self, oldChar, newChar): + if isinstance(oldChar, int): + oldChar = chr(oldChar) + if isinstance(newChar, int): + newChar = chr(newChar) + return String(self._str.replace(oldChar, newChar)) + + def replaceAll(self, regex, replacement): + return String(_re.sub(regex, replacement, self._str)) + + def replaceFirst(self, regex, replacement): + return String(_re.sub(regex, replacement, self._str, count=1)) + + def split(self, regex, limit=0): + if limit <= 0: + parts = _re.split(regex, self._str) + if limit == 0: + while parts and parts[-1] == "": + parts.pop() + else: + parts = _re.split(regex, self._str, maxsplit=limit - 1) + while len(parts) < limit: + parts.append("") + return [String(p) for p in parts] + + def startsWith(self, prefix): + return self._str.startswith(prefix) + + def substring(self, beginIndex, endIndex=None): + if endIndex is None: + return String(self._str[beginIndex:]) + return String(self._str[beginIndex:endIndex]) + + def toCharArray(self): + return list(self._str) + + def toLowerCase(self): + return String(self._str.lower()) + + def toUpperCase(self): + return String(self._str.upper()) + + def trim(self): + return String(self._str.strip()) + + @staticmethod + def valueOf(obj): + return String(str(obj)) + + @staticmethod + def copyValueOf(data, offset=0, count=None): + if count is None: + return String("".join(data)) + return String("".join(data[offset:offset+count])) + + @staticmethod + def format(fmt, *args): + return String(str(fmt) % args if args else str(fmt)) + + @staticmethod + def join(delimiter, *elements): + if hasattr(elements[0], '__iter__') and not isinstance(elements[0], (str, bytes)): + elements = elements[0] + return String(str(delimiter).join(str(s) for s in elements)) + + def toString(self): + return self._str + + def __str__(self): + return self._str + + def __repr__(self): + return f"String({self._str!r})" + + def __len__(self): + return len(self._str) + + def __getitem__(self, idx): + return self._str[idx] + + def __add__(self, other): + return String(self._str + str(other)) + + def __eq__(self, other): + if isinstance(other, String): + return self._str == other._str + return NotImplemented + + +# ============================================================ +# Number +# ============================================================ + +class Number(Stub): + def intValue(self): + raise NotImplementedError + def longValue(self): + raise NotImplementedError + def floatValue(self): + raise NotImplementedError + def doubleValue(self): + raise NotImplementedError + def byteValue(self): + return self.intValue() & 0xFF + def shortValue(self): + return self.intValue() & 0xFFFF + + +# ============================================================ +# Integer +# ============================================================ + +class Integer(Number, Comparable): + MAX_VALUE = 2147483647 + MIN_VALUE = -2147483648 + SIZE = 32 + BYTES = 4 + TYPE = int + + def __init__(self, value=0): + super().__init__() + if isinstance(value, str): + self._value = Integer.parseInt(value) + else: + self._value = int(value) + + @staticmethod + def parseInt(s, radix=10): + if isinstance(s, String): + s = str(s) + if radix == 10: + return int(str(s)) + return int(str(s), radix) + + @staticmethod + def toString(i, radix=10): + if radix == 10: + return String(str(i)) + if radix == 2: + return String(bin(i)[2:]) + if radix == 8: + return String(oct(i)[2:]) + if radix == 16: + return String(hex(i)[2:]) + return String(str(i)) + + @staticmethod + def toBinaryString(i): + if i >= 0: + return String(bin(i)[2:]) + return String(bin(i & 0xFFFFFFFF)[2:]) + + @staticmethod + def toHexString(i): + if i >= 0: + return String(hex(i)[2:]) + return String(hex(i & 0xFFFFFFFF)[2:]) + + @staticmethod + def toOctalString(i): + if i >= 0: + return String(oct(i)[2:]) + return String(oct(i & 0xFFFFFFFF)[2:]) + + @staticmethod + def valueOf(i, radix=10): + if isinstance(i, str): + return Integer(Integer.parseInt(i, radix)) + return Integer(i) + + def intValue(self): + return self._value + + def compareTo(self, other): + if isinstance(other, Integer): + return (self._value > other._value) - (self._value < other._value) + return -1 + + def equals(self, other): + if isinstance(other, Integer): + return self._value == other._value + return False + + def byteValue(self): + return self._value & 0xFF + + def shortValue(self): + return self._value & 0xFFFF + + def longValue(self): + return self._value + + def floatValue(self): + return float(self._value) + + def doubleValue(self): + return float(self._value) + + @staticmethod + def bitCount(i): + return bin(i & 0xFFFFFFFF).count("1") + + @staticmethod + def highestOneBit(i): + if i == 0: + return 0 + return 1 << (i.bit_length() - 1) + + @staticmethod + def lowestOneBit(i): + return i & -i + + @staticmethod + def numberOfLeadingZeros(i): + if i == 0: + return 32 + return 32 - i.bit_length() + + @staticmethod + def numberOfTrailingZeros(i): + if i == 0: + return 32 + return (i & -i).bit_length() - 1 + + @staticmethod + def reverse(i): + v = i & 0xFFFFFFFF + result = 0 + for _ in range(32): + result = (result << 1) | (v & 1) + v >>= 1 + return result + + @staticmethod + def reverseBytes(i): + v = i & 0xFFFFFFFF + return ((v >> 24) & 0xFF) | ((v >> 8) & 0xFF00) | ((v << 8) & 0xFF0000) | ((v << 24) & 0xFF000000) + + @staticmethod + def rotateLeft(i, distance): + v = i & 0xFFFFFFFF + d = distance & 31 + return ((v << d) | (v >> (32 - d))) & 0xFFFFFFFF + + @staticmethod + def rotateRight(i, distance): + v = i & 0xFFFFFFFF + d = distance & 31 + return ((v >> d) | (v << (32 - d))) & 0xFFFFFFFF + + @staticmethod + def signum(i): + if i > 0: + return 1 + if i < 0: + return -1 + return 0 + + @staticmethod + def decode(nm): + if nm.startswith("0x") or nm.startswith("0X"): + return Integer(int(nm, 16)) + if nm.startswith("0") and len(nm) > 1: + return Integer(int(nm, 8)) + if nm.startswith("#"): + return Integer(int(nm[1:], 16)) + return Integer(int(nm)) + + @staticmethod + def getInteger(nm, val=None): + env_val = _os.environ.get(nm) + if env_val is not None: + return Integer(int(env_val)) + return Integer(val) if val is not None else None + + def toString(self): + return String(str(self._value)) + + def __str__(self): + return str(self._value) + + def __int__(self): + return self._value + + +# ============================================================ +# Long +# ============================================================ + +class Long(Number, Comparable): + MAX_VALUE = 9223372036854775807 + MIN_VALUE = -9223372036854775808 + SIZE = 64 + BYTES = 8 + TYPE = int + + def __init__(self, value=0): + super().__init__() + if isinstance(value, str): + self._value = Long.parseLong(value) + else: + self._value = int(value) + + @staticmethod + def parseLong(s, radix=10): + if isinstance(s, String): + s = str(s) + if radix == 10: + return int(str(s)) + return int(str(s), radix) + + @staticmethod + def toString(i, radix=10): + if radix == 10: + return String(str(i)) + return String(str(i)) + + @staticmethod + def toBinaryString(i): + if i >= 0: + return String(bin(i)[2:]) + return String(bin(i & 0xFFFFFFFFFFFFFFFF)[2:]) + + @staticmethod + def toHexString(i): + if i >= 0: + return String(hex(i)[2:]) + return String(hex(i & 0xFFFFFFFFFFFFFFFF)[2:]) + + @staticmethod + def toOctalString(i): + if i >= 0: + return String(oct(i)[2:]) + return String(oct(i & 0xFFFFFFFFFFFFFFFF)[2:]) + + @staticmethod + def valueOf(i, radix=10): + if isinstance(i, str): + return Long(Long.parseLong(i, radix)) + return Long(i) + + def longValue(self): + return self._value + + def intValue(self): + return int(self._value) + + def floatValue(self): + return float(self._value) + + def doubleValue(self): + return float(self._value) + + def compareTo(self, other): + if isinstance(other, Long): + return (self._value > other._value) - (self._value < other._value) + return -1 + + def equals(self, other): + if isinstance(other, Long): + return self._value == other._value + return False + + def toString(self): + return String(str(self._value)) + + def __str__(self): + return str(self._value) + + +# ============================================================ +# Short, Byte +# ============================================================ + +class Short(Number, Comparable): + MAX_VALUE = 32767 + MIN_VALUE = -32768 + SIZE = 16 + BYTES = 2 + TYPE = int + + def __init__(self, value=0): + super().__init__() + if isinstance(value, str): + self._value = Short.parseShort(value) + else: + self._value = int(value) & 0xFFFF + + @staticmethod + def parseShort(s, radix=10): + return int(str(s), radix) + + @staticmethod + def valueOf(i, radix=10): + if isinstance(i, str): + return Short(Short.parseShort(i, radix)) + return Short(i) + + def shortValue(self): + return self._value + + def intValue(self): + return self._value + + def longValue(self): + return self._value + + def floatValue(self): + return float(self._value) + + def doubleValue(self): + return float(self._value) + + def compareTo(self, other): + if isinstance(other, Short): + return (self._value > other._value) - (self._value < other._value) + return -1 + + def equals(self, other): + if isinstance(other, Short): + return self._value == other._value + return False + + def toString(self): + return String(str(self._value)) + + +class Byte(Number, Comparable): + MAX_VALUE = 127 + MIN_VALUE = -128 + SIZE = 8 + BYTES = 1 + TYPE = int + + def __init__(self, value=0): + super().__init__() + if isinstance(value, str): + self._value = Byte.parseByte(value) + else: + self._value = int(value) & 0xFF + if self._value > 127: + self._value -= 256 + + @staticmethod + def parseByte(s, radix=10): + return int(str(s), radix) + + @staticmethod + def valueOf(i, radix=10): + if isinstance(i, str): + return Byte(Byte.parseByte(i, radix)) + return Byte(i) + + def byteValue(self): + return self._value + + def intValue(self): + return self._value + + def longValue(self): + return self._value + + def compareTo(self, other): + if isinstance(other, Byte): + return (self._value > other._value) - (self._value < other._value) + return -1 + + def equals(self, other): + if isinstance(other, Byte): + return self._value == other._value + return False + + def toString(self): + return String(str(self._value)) + + +# ============================================================ +# Float +# ============================================================ + +class Float(Number, Comparable): + MAX_VALUE = 3.4028235e38 + MIN_VALUE = 1.4e-45 + MIN_NORMAL = 1.17549435e-38 + MAX_EXPONENT = 127 + MIN_EXPONENT = -126 + SIZE = 32 + BYTES = 4 + TYPE = float + NaN = float("nan") + POSITIVE_INFINITY = float("inf") + NEGATIVE_INFINITY = float("-inf") + + def __init__(self, value=0.0): + super().__init__() + if isinstance(value, str): + self._value = Float.parseFloat(value) + else: + self._value = float(value) + + @staticmethod + def parseFloat(s): + if isinstance(s, String): + s = str(s) + s = str(s).strip() + if s == "NaN": + return float("nan") + if s == "Infinity" or s == "Inf": + return float("inf") + if s == "-Infinity" or s == "-Inf": + return float("-inf") + return float(s) + + @staticmethod + def toString(f): + return String(str(f)) + + @staticmethod + def valueOf(f): + if isinstance(f, str): + return Float(Float.parseFloat(f)) + return Float(f) + + def floatValue(self): + return self._value + + def intValue(self): + return int(self._value) + + def longValue(self): + return int(self._value) + + def doubleValue(self): + return float(self._value) + + def compareTo(self, other): + if isinstance(other, Float): + a, b = self._value, other._value + if _py_math.isnan(a) and _py_math.isnan(b): + return 0 + if _py_math.isnan(a): + return 1 + if _py_math.isnan(b): + return -1 + return (a > b) - (a < b) + return -1 + + def isNaN(self): + return _py_math.isnan(self._value) + + def isInfinite(self): + return _py_math.isinf(self._value) + + def equals(self, other): + if isinstance(other, Float): + if _py_math.isnan(self._value) and _py_math.isnan(other._value): + return True + return self._value == other._value + return False + + def hashCode(self): + return _struct.pack(">f", self._value) + + def toString(self): + return String(str(self._value)) + + def __str__(self): + return str(self._value) + +import struct as _struct + + +# ============================================================ +# Double +# ============================================================ + +class Double(Number, Comparable): + MAX_VALUE = 1.7976931348623157e308 + MIN_VALUE = 4.9e-324 + MIN_NORMAL = 2.2250738585072014e-308 + MAX_EXPONENT = 1023 + MIN_EXPONENT = -1022 + SIZE = 64 + BYTES = 8 + TYPE = float + NaN = float("nan") + POSITIVE_INFINITY = float("inf") + NEGATIVE_INFINITY = float("-inf") + + def __init__(self, value=0.0): + super().__init__() + if isinstance(value, str): + self._value = Double.parseDouble(value) + else: + self._value = float(value) + + @staticmethod + def parseDouble(s): + if isinstance(s, String): + s = str(s) + s = str(s).strip() + if s == "NaN": + return float("nan") + if s == "Infinity" or s == "Inf": + return float("inf") + if s == "-Infinity" or s == "-Inf": + return float("-inf") + return float(s) + + @staticmethod + def toString(d): + return String(str(d)) + + @staticmethod + def valueOf(d): + if isinstance(d, str): + return Double(Double.parseDouble(d)) + return Double(d) + + def doubleValue(self): + return self._value + + def intValue(self): + return int(self._value) + + def longValue(self): + return int(self._value) + + def floatValue(self): + return float(self._value) + + def compareTo(self, other): + if isinstance(other, Double): + a, b = self._value, other._value + if _py_math.isnan(a) and _py_math.isnan(b): + return 0 + if _py_math.isnan(a): + return 1 + if _py_math.isnan(b): + return -1 + return (a > b) - (a < b) + return -1 + + def isNaN(self): + return _py_math.isnan(self._value) + + def isInfinite(self): + return _py_math.isinf(self._value) + + def equals(self, other): + if isinstance(other, Double): + if _py_math.isnan(self._value) and _py_math.isnan(other._value): + return True + return self._value == other._value + return False + + def toString(self): + return String(str(self._value)) + + def __str__(self): + return str(self._value) + + +# ============================================================ +# Boolean +# ============================================================ + +class Boolean(Stub): + TRUE = "true" + FALSE = "false" + TYPE = bool + + def __init__(self, value=False): + super().__init__() + if isinstance(value, str): + self._value = Boolean.parseBoolean(value) + elif isinstance(value, bool): + self._value = value + else: + self._value = bool(value) + + @staticmethod + def parseBoolean(s): + return str(s).lower() == "true" + + @staticmethod + def toString(b): + return String(str(b).lower()) + + @staticmethod + def valueOf(b): + if isinstance(b, str): + return Boolean(Boolean.parseBoolean(b)) + return Boolean(b) + + def booleanValue(self): + return self._value + + @staticmethod + def logicalAnd(a, b): + return a and b + + @staticmethod + def logicalOr(a, b): + return a or b + + @staticmethod + def logicalXor(a, b): + return a ^ b + + def compareTo(self, other): + if isinstance(other, Boolean): + return (self._value > other._value) - (self._value < other._value) + return -1 + + def equals(self, other): + if isinstance(other, Boolean): + return self._value == other._value + return False + + def toString(self): + return String("true" if self._value else "false") + + def __str__(self): + return "true" if self._value else "false" + + def __bool__(self): + return self._value + + +# ============================================================ +# Character +# ============================================================ + +class Character(Stub): + MAX_VALUE = 65535 + MIN_VALUE = 0 + SIZE = 16 + BYTES = 2 + TYPE = str + + def __init__(self, value=""): + super().__init__() + if isinstance(value, int): + self._value = chr(value) + else: + self._value = str(value)[0] if value else "" + + def charValue(self): + return self._value + + @staticmethod + def isDigit(ch): + return str(ch).isdigit() + + @staticmethod + def isLetter(ch): + return str(ch).isalpha() + + @staticmethod + def isLetterOrDigit(ch): + return str(ch).isalnum() + + @staticmethod + def isLowerCase(ch): + return str(ch).islower() + + @staticmethod + def isUpperCase(ch): + return str(ch).isupper() + + @staticmethod + def isWhitespace(ch): + return str(ch).isspace() + + @staticmethod + def isSpaceChar(ch): + return str(ch) in " \t\n\r\f\u000B" + + @staticmethod + def isISOControl(ch): + c = ord(ch) if isinstance(ch, str) else ch + return c < 0x20 or c == 0x7F + + @staticmethod + def isJavaIdentifierPart(ch): + c = str(ch) + return c.isalnum() or c == "_" or c == "$" + + @staticmethod + def isJavaIdentifierStart(ch): + c = str(ch) + return c.isalpha() or c == "_" or c == "$" + + @staticmethod + def isJavaLetter(ch): + return Character.isJavaIdentifierStart(ch) + + @staticmethod + def isJavaLetterOrDigit(ch): + return Character.isJavaIdentifierPart(ch) + + @staticmethod + def toLowerCase(ch): + return str(ch).lower() + + @staticmethod + def toUpperCase(ch): + return str(ch).upper() + + @staticmethod + def toTitleCase(ch): + return str(ch).upper() + + @staticmethod + def getNumericValue(ch): + s = str(ch) + if s.isdigit(): + return int(s) + if "a" <= s <= "z": + return ord(s) - ord("a") + 10 + if "A" <= s <= "Z": + return ord(s) - ord("A") + 10 + return -1 + + @staticmethod + def digit(ch, radix): + val = Character.getNumericValue(ch) + return val if val < radix else -1 + + @staticmethod + def forDigit(digit, radix): + if digit >= radix: + return "\0" + return str(digit) if digit < 10 else chr(ord("a") + digit - 10) + + @staticmethod + def getType(ch): + return 0 + + @staticmethod + def getDirectionality(ch): + return 0 + + @staticmethod + def getName(ch): + return f"CHARACTER {ord(ch)}" + + @staticmethod + def charCount(codePoint): + return 1 if codePoint < 0x10000 else 2 + + @staticmethod + def isBmpCodePoint(cp): + return cp <= 0xFFFF + + @staticmethod + def isHighSurrogate(ch): + c = ord(ch) if isinstance(ch, str) else ch + return 0xD800 <= c <= 0xDBFF + + @staticmethod + def isLowSurrogate(ch): + c = ord(ch) if isinstance(ch, str) else ch + return 0xDC00 <= c <= 0xDFFF + + @staticmethod + def isSupplementaryCodePoint(cp): + return 0x10000 + + +class Math: + """java.lang.Math — 数学运算""" + E = 2.718281828459045 + PI = 3.141592653589793 + + @staticmethod + def abs(a): return abs(a) + @staticmethod + def ceil(a): return int(math.ceil(a)) + @staticmethod + def floor(a): return int(math.floor(a)) + @staticmethod + def round(a): return round(a) + @staticmethod + def min(a, b): return a if a < b else b + @staticmethod + def max(a, b): return a if a > b else b + @staticmethod + def sqrt(a): return math.sqrt(a) + @staticmethod + def cbrt(a): return math.cbrt(a) + @staticmethod + def pow(a, b): return math.pow(a, b) + @staticmethod + def exp(a): return math.exp(a) + @staticmethod + def log(a): return math.log(a) + @staticmethod + def log10(a): return math.log10(a) + @staticmethod + def sin(a): return math.sin(a) + @staticmethod + def cos(a): return math.cos(a) + @staticmethod + def tan(a): return math.tan(a) + @staticmethod + def asin(a): return math.asin(a) + @staticmethod + def acos(a): return math.acos(a) + @staticmethod + def atan(a): return math.atan(a) + @staticmethod + def atan2(y, x): return math.atan2(y, x) + @staticmethod + def toDegrees(r): return math.degrees(r) + @staticmethod + def toRadians(d): return math.radians(d) + @staticmethod + def hypot(x, y): return math.hypot(x, y) + @staticmethod + def sinh(x): return math.sinh(x) + @staticmethod + def cosh(x): return math.cosh(x) + @staticmethod + def tanh(x): return math.tanh(x) + @staticmethod + def signum(x): return 0.0 if x == 0 else (1.0 if x > 0 else -1.0) + @staticmethod + def random(): return random.random() + @staticmethod + def addExact(x, y): + result = x + y + if (x > 0 and y > 0 and result < 0) or (x < 0 and y < 0 and result > 0): + raise ArithmeticError("integer overflow") + return result + @staticmethod + def copySign(m, s): return abs(m) * (1 if s >= 0 else -1) + @staticmethod + def floorDiv(x, y): return x // y if (x ^ y) >= 0 else -(abs(x) // abs(y)) + @staticmethod + def floorMod(x, y): return x - Math.floorDiv(x, y) * y + + +class StrictMath(Math): + """java.lang.StrictMath""" + pass + + +class System: + """java.lang.System""" + @staticmethod + def currentTimeMillis(): return int(time.time() * 1000) + @staticmethod + def nanoTime(): return time.perf_counter_ns() + @staticmethod + def arraycopy(src, srcPos, dest, destPos, length): + if isinstance(src, (list, bytearray)): + dest[destPos:destPos+length] = src[srcPos:srcPos+length] + else: + raise TypeError("Unsupported type for arraycopy") + @staticmethod + def identityHashCode(obj): return id(obj) & 0x7FFFFFFF + @staticmethod + def gc(): pass + @staticmethod + def exit(status): raise SystemExit(status) + @staticmethod + def getProperty(key, default=None): + import os + return os.environ.get(key, default) + @staticmethod + def setProperty(key, value): + import os + os.environ[key] = value + return value + @staticmethod + def lineSeparator(): return _os.linesep + in_ = _sys.stdin + out = _sys.stdout + err = _sys.stderr + + +class Thread(Runnable): + """java.lang.Thread""" + MIN_PRIORITY = 1 + NORM_PRIORITY = 5 + MAX_PRIORITY = 10 + + def __init__(self, target=None, name=None): + super().__init__() + self._target = target + self._name = name or f"Thread-{id(self)}" + self._alive = False + self._daemon = False + self._interrupted = False + + def start(self): + self._alive = True + if self._target: + _threading.Thread(target=self.run, daemon=self._daemon).start() + + def run(self): + if self._target: + self._target() + + def interrupt(self): + self._interrupted = True + + def isInterrupted(self): + return self._interrupted + + def isAlive(self): + return self._alive + + def getName(self): return self._name + def setName(self, n): self._name = n + def setDaemon(self, d): self._daemon = d + def isDaemon(self): return self._daemon + + @staticmethod + def currentThread(): + return Thread(name="main") + @staticmethod + def sleep(millis): + import time + time.sleep(millis / 1000.0) + @staticmethod + def yield_(): + import time + time.sleep(0) + + +class ThreadLocal(Stub): + """java.lang.ThreadLocal""" + def __init__(self): + super().__init__() + self._data = {} + + def get(self): + tid = _threading.get_ident() + return self._data.get(tid, None) + def set(self, value): + self._data[_threading.get_ident()] = value + def remove(self): + self._data.pop(_threading.get_ident(), None) + + +class StringBuilder(Stub): + """java.lang.StringBuilder — 可变字符序列""" + def __init__(self, s=""): + super().__init__() + self._buf = list(str(s)) + + def append(self, obj): + if isinstance(obj, bool): + self._buf.append("true" if obj else "false") + else: + self._buf.append(str(obj)) + return self + + def insert(self, offset, obj): + self._buf[offset:offset] = list(str(obj)) + return self + + def delete(self, start, end): + del self._buf[start:end] + return self + + def deleteCharAt(self, index): + del self._buf[index] + return self + + def replace(self, start, end, s): + self._buf[start:end] = list(s) + return self + + def reverse(self): + self._buf.reverse() + return self + + def toString(self): return "".join(self._buf) + def length(self): return len(self._buf) + def capacity(self): return len(self._buf) + 16 + def charAt(self, i): return self._buf[i] + def setCharAt(self, i, c): self._buf[i] = c + def substring(self, s, e=None): + return "".join(self._buf[s:e]) + def indexOf(self, s, f=0): + return self.toString().find(s, f) + def lastIndexOf(self, s, f=None): + return self.toString().rfind(s) + + +class StringBuffer(StringBuilder): + """java.lang.StringBuffer — 线程安全的可变字符序列""" + pass + + +class Class(Stub): + """java.lang.Class""" + def __init__(self, cls): + super().__init__() + self._cls = cls + def getName(self): return self._cls.__name__ + def getSimpleName(self): return self._cls.__name__ + def getCanonicalName(self): return self._cls.__name__ + def isInterface(self): return isinstance(self._cls, type) + def isArray(self): return self._cls is list + def isPrimitive(self): return self._cls in (int, float, bool, str, bytes) + def getSuperclass(self): return Class(self._cls.__base__) if self._cls.__base__ else None + def cast(self, obj): return obj + + +class Void(Stub): + """java.lang.Void""" + TYPE = None + + +class VoidType(Stub): + """java.lang.Void (inner type)""" + pass + + +# 注解类 +class SuppressWarnings(Stub): + pass +class Deprecated(Stub): + pass +class Override(Stub): + pass +class FunctionalInterface(Stub): + pass \ No newline at end of file diff --git a/android_pyapi/java/math.py b/android_pyapi/java/math.py new file mode 100644 index 0000000..bdbf2c7 --- /dev/null +++ b/android_pyapi/java/math.py @@ -0,0 +1,683 @@ +""" +Java math standard library APIs implemented in Python. +java.math package - BigInteger, BigDecimal, MathContext, RoundingMode. +""" + +from .._core import Stub +from .lang import Comparable +from decimal import ( + Decimal as _Decimal, + ROUND_DOWN as _DEC_ROUND_DOWN, + ROUND_HALF_UP as _DEC_ROUND_HALF_UP, + ROUND_HALF_EVEN as _DEC_ROUND_HALF_EVEN, + ROUND_UP as _DEC_ROUND_UP, + ROUND_CEILING as _DEC_ROUND_CEILING, + ROUND_FLOOR as _DEC_ROUND_FLOOR, + ROUND_HALF_DOWN as _DEC_ROUND_HALF_DOWN, + localcontext as _local_context, + getcontext as _get_context, +) +import random as _random +import math as _py_math +import sys as _sys + +__all__ = [ + "BigInteger", "BigDecimal", "MathContext", "RoundingMode", +] + + +# ============================================================ +# RoundingMode +# ============================================================ + +class RoundingMode(Stub): + UP = 0 + DOWN = 1 + CEILING = 2 + FLOOR = 3 + HALF_UP = 4 + HALF_DOWN = 5 + HALF_EVEN = 6 + UNNECESSARY = 7 + + _names = { + 0: "UP", 1: "DOWN", 2: "CEILING", 3: "FLOOR", + 4: "HALF_UP", 5: "HALF_DOWN", 6: "HALF_EVEN", 7: "UNNECESSARY", + } + + _py_map = { + 0: _DEC_ROUND_UP, + 1: _DEC_ROUND_DOWN, + 2: _DEC_ROUND_CEILING, + 3: _DEC_ROUND_FLOOR, + 4: _DEC_ROUND_HALF_UP, + 5: _DEC_ROUND_HALF_DOWN, + 6: _DEC_ROUND_HALF_EVEN, + 7: _DEC_ROUND_HALF_EVEN, # closest approximation + } + + def __init__(self, value): + super().__init__() + self._value = value + + def toString(self): + return self._names.get(self._value, "UNKNOWN") + + +# ============================================================ +# MathContext +# ============================================================ + +class MathContext(Stub): + UNLIMITED = None + DECIMAL32 = None + DECIMAL64 = None + DECIMAL128 = None + + def __init__(self, *args): + super().__init__() + if len(args) == 1: + if isinstance(args[0], str): + s = args[0].strip().lower() + if s == "precision=7 roundingmode=half_even": + self._precision = 7 + self._rounding_mode = RoundingMode.HALF_EVEN + elif s == "precision=16 roundingmode=half_even": + self._precision = 16 + self._rounding_mode = RoundingMode.HALF_EVEN + elif s == "precision=34 roundingmode=half_even": + self._precision = 34 + self._rounding_mode = RoundingMode.HALF_EVEN + else: + self._precision = 0 + self._rounding_mode = RoundingMode.HALF_UP + else: + self._precision = int(args[0]) + self._rounding_mode = RoundingMode.HALF_UP + elif len(args) == 2: + self._precision = int(args[0]) + self._rounding_mode = args[1] + + def getPrecision(self): + return self._precision + + def getRoundingMode(self): + return self._rounding_mode + + def equals(self, other): + if isinstance(other, MathContext): + return (self._precision == other._precision and + self._rounding_mode == other._rounding_mode) + return False + + def hashCode(self): + return hash((self._precision, self._rounding_mode)) & 0x7FFFFFFF + + def toString(self): + return f"precision={self._precision} roundingMode={self._rounding_mode.toString()}" + + +MathContext.UNLIMITED = MathContext(0) +MathContext.DECIMAL32 = MathContext(7, RoundingMode.HALF_EVEN) +MathContext.DECIMAL64 = MathContext(16, RoundingMode.HALF_EVEN) +MathContext.DECIMAL128 = MathContext(34, RoundingMode.HALF_EVEN) + + +# ============================================================ +# BigInteger +# ============================================================ + +class BigInteger(Comparable): + ZERO = None + ONE = None + TEN = None + + def __init__(self, *args): + super().__init__() + if len(args) == 0: + self._value = 0 + elif len(args) == 1: + if isinstance(args[0], str): + self._value = int(str(args[0])) + elif isinstance(args[0], bytes): + self._value = int.from_bytes(args[0], byteorder="big", signed=True) + elif isinstance(args[0], bytearray): + self._value = int.from_bytes(bytes(args[0]), byteorder="big", signed=True) + elif isinstance(args[0], int): + self._value = args[0] + elif isinstance(args[0], BigInteger): + self._value = args[0]._value + else: + self._value = int(args[0]) + elif len(args) == 2: + if isinstance(args[1], _random.Random): + bit_length, rng = args + self._value = rng.getrandbits(bit_length) + elif isinstance(args[1], int): + val_str, radix = args + self._value = int(str(val_str), radix) + else: + self._value = int.from_bytes(bytes(args[0]), byteorder="big", signed=True) + else: + self._value = 0 + + @staticmethod + def valueOf(val): + if isinstance(val, int): + if val == 0: + return BigInteger.ZERO + if val == 1: + return BigInteger.ONE + if val == 10: + return BigInteger.TEN + return BigInteger(val) + + def add(self, other): + if isinstance(other, BigInteger): + return BigInteger(self._value + other._value) + return BigInteger(self._value + int(other)) + + def subtract(self, other): + if isinstance(other, BigInteger): + return BigInteger(self._value - other._value) + return BigInteger(self._value - int(other)) + + def multiply(self, other): + if isinstance(other, BigInteger): + return BigInteger(self._value * other._value) + return BigInteger(self._value * int(other)) + + def divide(self, other): + if isinstance(other, BigInteger): + return BigInteger(self._value // other._value) + return BigInteger(self._value // int(other)) + + def pow(self, exponent): + return BigInteger(self._value ** exponent) + + def gcd(self, other): + return BigInteger(_py_math.gcd(self._value, other._value if isinstance(other, BigInteger) else int(other))) + + def abs(self): + return BigInteger(abs(self._value)) + + def negate(self): + return BigInteger(-self._value) + + def signum(self): + if self._value > 0: + return 1 + if self._value < 0: + return -1 + return 0 + + def mod(self, m): + if isinstance(m, BigInteger): + return BigInteger(self._value % m._value) + return BigInteger(self._value % int(m)) + + def remainder(self, other): + if isinstance(other, BigInteger): + return BigInteger(self._value % other._value) + return BigInteger(self._value % int(other)) + + def and_(self, other): + return BigInteger(self._value & (other._value if isinstance(other, BigInteger) else int(other))) + + def or_(self, other): + return BigInteger(self._value | (other._value if isinstance(other, BigInteger) else int(other))) + + def xor(self, other): + return BigInteger(self._value ^ (other._value if isinstance(other, BigInteger) else int(other))) + + def not_(self): + return BigInteger(~self._value) + + def andNot(self, other): + return BigInteger(self._value & ~(other._value if isinstance(other, BigInteger) else int(other))) + + def shiftLeft(self, n): + return BigInteger(self._value << n) + + def shiftRight(self, n): + return BigInteger(self._value >> n) + + def getLowestSetBit(self): + if self._value == 0: + return -1 + return (self._value & -self._value).bit_length() - 1 + + def bitLength(self): + if self._value == 0: + return 0 + return self._value.bit_length() + + def bitCount(self): + return bin(self._value & ((1 << self.bitLength()) - 1) if self._value >= 0 else self._value).count("1") + + def isProbablePrime(self, certainty): + if abs(self._value) < 2: + return False + if abs(self._value) == 2 or abs(self._value) == 3: + return True + if self._value % 2 == 0: + return False + d = self._value - 1 + s = 0 + while d % 2 == 0: + d //= 2 + s += 1 + for _ in range(min(certainty, 20)): + a = _random.randrange(2, min(self._value - 1, 1000000)) + x = pow(a, d, self._value) + if x == 1 or x == self._value - 1: + continue + for _ in range(s - 1): + x = pow(x, 2, self._value) + if x == self._value - 1: + break + else: + return False + return True + + def nextProbablePrime(self): + v = self._value + 1 + if v < 3: + return BigInteger(2) if v <= 2 else BigInteger(3) + while True: + if v % 2 == 0: + v += 1 + for i in range(3, int(_py_math.sqrt(v)) + 1, 2): + if v % i == 0: + break + else: + return BigInteger(v) + v += 2 + + def compareTo(self, other): + if isinstance(other, BigInteger): + return (self._value > other._value) - (self._value < other._value) + return -1 + + def equals(self, other): + if isinstance(other, BigInteger): + return self._value == other._value + return False + + def toByteArray(self): + if self._value == 0: + return b"\x00" + byte_length = (self._value.bit_length() + 8) // 8 + return self._value.to_bytes(byte_length, byteorder="big", signed=True) + + def toString(self, radix=10): + if radix == 10: + return str(self._value) + if radix == 16: + return hex(self._value)[2:] + if radix == 8: + return oct(self._value)[2:] + if radix == 2: + return bin(self._value)[2:] + return str(self._value) + + def intValue(self): + return self._value & 0xFFFFFFFF + + def longValue(self): + return self._value + + def floatValue(self): + return float(self._value) + + def doubleValue(self): + return float(self._value) + + def min(self, other): + return BigInteger(min(self._value, other._value if isinstance(other, BigInteger) else int(other))) + + def max(self, other): + return BigInteger(max(self._value, other._value if isinstance(other, BigInteger) else int(other))) + + def modPow(self, exponent, m): + if isinstance(exponent, BigInteger): + exp_val = exponent._value + else: + exp_val = int(exponent) + mod_val = m._value if isinstance(m, BigInteger) else int(m) + return BigInteger(pow(self._value, exp_val, mod_val)) + + def modInverse(self, m): + mod_val = m._value if isinstance(m, BigInteger) else int(m) + return BigInteger(pow(self._value, -1, mod_val)) + + def divideAndRemainder(self, other): + if isinstance(other, BigInteger): + divisor = other._value + else: + divisor = int(other) + q = self._value // divisor + r = self._value % divisor + return [BigInteger(q), BigInteger(r)] + + def __int__(self): + return self._value + + def __str__(self): + return str(self._value) + + def __neg__(self): + return self.negate() + + def __abs__(self): + return self.abs() + + def __add__(self, other): + return self.add(other) + + def __sub__(self, other): + return self.subtract(other) + + def __mul__(self, other): + return self.multiply(other) + + def __truediv__(self, other): + return self.divide(other) + + def __floordiv__(self, other): + return self.divide(other) + + def __mod__(self, other): + return self.mod(other) + + def __pow__(self, other): + return self.pow(other) + + def __and__(self, other): + return self.and_(other) + + def __or__(self, other): + return self.or_(other) + + def __xor__(self, other): + return self.xor(other) + + def __invert__(self): + return self.not_() + + def __lshift__(self, n): + return self.shiftLeft(n) + + def __rshift__(self, n): + return self.shiftRight(n) + + +BigInteger.ZERO = BigInteger(0) +BigInteger.ONE = BigInteger(1) +BigInteger.TEN = BigInteger(10) + + +# ============================================================ +# BigDecimal +# ============================================================ + +class BigDecimal(Comparable): + ZERO = None + ONE = None + TEN = None + + ROUND_UP = 0 + ROUND_DOWN = 1 + ROUND_CEILING = 2 + ROUND_FLOOR = 3 + ROUND_HALF_UP = 4 + ROUND_HALF_DOWN = 5 + ROUND_HALF_EVEN = 6 + ROUND_UNNECESSARY = 7 + + _round_map = { + 0: _DEC_ROUND_UP, + 1: _DEC_ROUND_DOWN, + 2: _DEC_ROUND_CEILING, + 3: _DEC_ROUND_FLOOR, + 4: _DEC_ROUND_HALF_UP, + 5: _DEC_ROUND_HALF_DOWN, + 6: _DEC_ROUND_HALF_EVEN, + 7: _DEC_ROUND_HALF_EVEN, + } + + def __init__(self, *args): + super().__init__() + if len(args) == 1: + val = args[0] + if isinstance(val, str): + self._dec = _Decimal(str(val)) + elif isinstance(val, float): + self._dec = _Decimal(repr(val)) + elif isinstance(val, int): + self._dec = _Decimal(val) + elif isinstance(val, BigInteger): + self._dec = _Decimal(val._value) + elif isinstance(val, BigDecimal): + self._dec = _Decimal(val._dec) + elif isinstance(val, _Decimal): + self._dec = val + else: + self._dec = _Decimal(str(val)) + elif len(args) == 2: + val, mc = args + if isinstance(val, str): + self._dec = _Decimal(str(val)) + elif isinstance(val, float): + self._dec = _Decimal(repr(val)) + else: + self._dec = _Decimal(val) + if mc and hasattr(mc, 'getPrecision') and mc.getPrecision() > 0: + self._dec = +self._dec + + @staticmethod + def valueOf(val): + if isinstance(val, int): + if val == 0: + return BigDecimal.ZERO + if val == 1: + return BigDecimal.ONE + if val == 10: + return BigDecimal.TEN + if isinstance(val, float): + return BigDecimal(repr(val)) + return BigDecimal(val) + + def add(self, other): + if isinstance(other, BigDecimal): + return BigDecimal(self._dec + other._dec) + return BigDecimal(self._dec + _Decimal(str(other))) + + def subtract(self, other): + if isinstance(other, BigDecimal): + return BigDecimal(self._dec - other._dec) + return BigDecimal(self._dec - _Decimal(str(other))) + + def multiply(self, other): + if isinstance(other, BigDecimal): + return BigDecimal(self._dec * other._dec) + return BigDecimal(self._dec * _Decimal(str(other))) + + def divide(self, *args): + if len(args) == 1: + other = args[0] + if isinstance(other, BigDecimal): + return BigDecimal(self._dec / other._dec) + return BigDecimal(self._dec / _Decimal(str(other))) + elif len(args) == 2: + other, rounding_mode = args + if isinstance(other, BigDecimal): + result = self._dec / other._dec + else: + result = self._dec / _Decimal(str(other)) + return BigDecimal(result) + elif len(args) == 3: + other, scale, rounding_mode = args + if isinstance(other, BigDecimal): + result = self._dec / other._dec + else: + result = self._dec / _Decimal(str(other)) + rounded = BigDecimal(result) + return rounded.setScale(scale, rounding_mode) + + def divideToIntegralValue(self, other): + if isinstance(other, BigDecimal): + return BigDecimal(int(self._dec / other._dec)) + return BigDecimal(int(self._dec / _Decimal(str(other)))) + + def remainder(self, other): + if isinstance(other, BigDecimal): + return BigDecimal(self._dec % other._dec) + return BigDecimal(self._dec % _Decimal(str(other))) + + def pow(self, n): + return BigDecimal(self._dec ** n) + + def abs(self): + return BigDecimal(abs(self._dec)) + + def negate(self): + return BigDecimal(-self._dec) + + def signum(self): + if self._dec > 0: + return 1 + if self._dec < 0: + return -1 + return 0 + + def scale(self): + return abs(self._dec.as_tuple().exponent) + + def precision(self): + return len(self._dec.as_tuple().digits) + + def round(self, mc): + if mc.getPrecision() > 0: + with _local_context() as ctx: + ctx.prec = mc.getPrecision() + return BigDecimal(+self._dec) + return BigDecimal(self._dec) + + def setScale(self, new_scale, rounding_mode=None): + if rounding_mode is None: + qe = _Decimal(10) ** (-new_scale) + return BigDecimal(self._dec.quantize(qe)) + py_mode = self._round_map.get(rounding_mode, _DEC_ROUND_HALF_UP) + qe = _Decimal(10) ** (-new_scale) + return BigDecimal(self._dec.quantize(qe, rounding=py_mode)) + + def ulp(self): + exponent = self._dec.as_tuple().exponent + return BigDecimal(_Decimal(10) ** exponent) + + def unscaledValue(self): + t = self._dec.as_tuple() + digits = t.digits + val = int("".join(str(d) for d in digits)) + return BigInteger(-val if t.sign else val) + + def byteValueExact(self): + val = self.intValueExact() + if val < -128 or val > 127: + raise ArithmeticError("Overflow") + return val + + def shortValueExact(self): + val = self.intValueExact() + if val < -32768 or val > 32767: + raise ArithmeticError("Overflow") + return val + + def intValueExact(self): + if self._dec != int(self._dec): + raise ArithmeticError("Rounding necessary") + return int(self._dec) + + def longValueExact(self): + if self._dec != int(self._dec): + raise ArithmeticError("Rounding necessary") + return int(self._dec) + + def floatValue(self): + return float(self._dec) + + def doubleValue(self): + return float(self._dec) + + def intValue(self): + return int(self._dec) + + def longValue(self): + return int(self._dec) + + def toString(self): + return str(self._dec) + + def toEngineeringString(self): + return format(self._dec, "e") + + def toPlainString(self): + return format(self._dec, "f") + + def compareTo(self, other): + if isinstance(other, BigDecimal): + return (self._dec > other._dec) - (self._dec < other._dec) + return -1 + + def equals(self, other): + if isinstance(other, BigDecimal): + return self._dec == other._dec + return False + + def hashCode(self): + return hash(self._dec) & 0x7FFFFFFF + + def min(self, other): + return BigDecimal(min(self._dec, other._dec if isinstance(other, BigDecimal) else _Decimal(str(other)))) + + def max(self, other): + return BigDecimal(max(self._dec, other._dec if isinstance(other, BigDecimal) else _Decimal(str(other)))) + + def __str__(self): + return str(self._dec) + + def __int__(self): + return int(self._dec) + + def __float__(self): + return float(self._dec) + + def __neg__(self): + return self.negate() + + def __abs__(self): + return self.abs() + + def __add__(self, other): + return self.add(other) + + def __sub__(self, other): + return self.subtract(other) + + def __mul__(self, other): + return self.multiply(other) + + def __truediv__(self, other): + return self.divide(other) + + def __mod__(self, other): + return self.remainder(other) + + def __pow__(self, other): + return self.pow(other) + + +BigDecimal.ZERO = BigDecimal(0) +BigDecimal.ONE = BigDecimal(1) +BigDecimal.TEN = BigDecimal(10) \ No newline at end of file diff --git a/android_pyapi/java/net.py b/android_pyapi/java/net.py new file mode 100644 index 0000000..9995689 --- /dev/null +++ b/android_pyapi/java/net.py @@ -0,0 +1,1582 @@ +""" +Java net standard library APIs implemented in Python. +java.net package - URL, Socket, HTTP connection, and networking classes. +""" + +from .._core import Stub, AndroidOnlyError, HAS_REQUESTS, HAS_HTTPX +from .io import IOException + +import os as _os +import socket as _socket +import struct as _struct +import threading as _threading +from urllib.parse import ( + urlparse as _urlparse, + urlunparse as _urlunparse, + quote as _quote, + unquote as _unquote, +) +from datetime import datetime as _datetime +from collections import OrderedDict as _OrderedDict + +__all__ = [ + "URL", "URLConnection", "HttpURLConnection", + "InetAddress", "InetSocketAddress", + "Socket", "ServerSocket", "DatagramSocket", "DatagramPacket", + "Proxy", "ProxySelector", "Authenticator", "PasswordAuthentication", + "NetworkInterface", "URI", + "CookieHandler", "CookieManager", "HttpCookie", + "URLDecoder", "URLEncoder", + "SocketException", "ConnectException", "BindException", + "NoRouteToHostException", "PortUnreachableException", + "ProtocolException", "SocketTimeoutException", + "MalformedURLException", "UnknownHostException", "UnknownServiceException", +] + + +# ============================================================ +# Exception classes +# ============================================================ + +class SocketException(IOException): + pass + +class ConnectException(SocketException): + pass + +class BindException(SocketException): + pass + +class NoRouteToHostException(SocketException): + pass + +class PortUnreachableException(SocketException): + pass + +class ProtocolException(IOException): + pass + +class SocketTimeoutException(IOException): + pass + +class MalformedURLException(IOException): + pass + +class UnknownHostException(IOException): + pass + +class UnknownServiceException(IOException): + pass + + +# ============================================================ +# InetAddress +# ============================================================ + +class InetAddress(Stub): + def __init__(self, host, addr): + super().__init__() + self._host = host + self._addr = addr # bytes, 4 or 16 + + @staticmethod + def getByName(host): + try: + addr = _socket.getaddrinfo(host, None, family=_socket.AF_UNSPEC) + if addr: + raw = addr[0][4][0] + return InetAddress(host, _socket.inet_pton(_socket.AF_INET, raw) if "." in raw else _socket.inet_pton(_socket.AF_INET6, raw)) + except Exception: + raise UnknownHostException(host) + + @staticmethod + def getAllByName(host): + try: + addrs = _socket.getaddrinfo(host, None, family=_socket.AF_UNSPEC) + results = [] + seen = set() + for a in addrs: + raw = a[4][0] + if raw not in seen: + seen.add(raw) + if "." in raw: + results.append(InetAddress(host, _socket.inet_pton(_socket.AF_INET, raw))) + else: + results.append(InetAddress(host, _socket.inet_pton(_socket.AF_INET6, raw))) + return results + except Exception: + raise UnknownHostException(host) + + @staticmethod + def getLocalHost(): + hostname = _socket.gethostname() + return InetAddress.getByName(hostname) + + @staticmethod + def getLoopbackAddress(): + return InetAddress("localhost", b"\x7f\x00\x00\x01") + + @staticmethod + def getByAddress(host, addr): + return InetAddress(host, addr) + + def getHostName(self): + return self._host + + def getHostAddress(self): + if len(self._addr) == 4: + return _socket.inet_ntoa(self._addr) + return _socket.inet_ntop(_socket.AF_INET6, self._addr) + + def getCanonicalHostName(self): + try: + name, _, _ = _socket.gethostbyaddr(self.getHostAddress()) + return name + except Exception: + return self._host + + def isReachable(self, timeout=5000): + try: + s = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM) + s.settimeout(timeout / 1000.0) + result = s.connect_ex((self.getHostAddress(), 7)) + s.close() + return result == 0 + except Exception: + return False + + def isLoopbackAddress(self): + if len(self._addr) == 4: + return self._addr[0] == 127 + return self._addr == b"\x00" * 15 + b"\x01" + + def isLinkLocalAddress(self): + if len(self._addr) == 4: + return self._addr[0] == 169 and self._addr[1] == 254 + return (self._addr[0] & 0xFF) == 0xFE and (self._addr[1] & 0xC0) == 0x80 + + def isSiteLocalAddress(self): + if len(self._addr) == 4: + b0 = self._addr[0] + return b0 == 10 or (b0 == 172 and 16 <= self._addr[1] <= 31) or (b0 == 192 and self._addr[1] == 168) + return False + + def isMCGlobal(self): + if len(self._addr) == 4: + return 224 <= self._addr[0] <= 239 and self._addr[0] != 224 and self._addr[0] != 239 + return (self._addr[0] & 0xFF) == 0xFF and (self._addr[1] & 0x0F) == 0x0E and (self._addr[2] & 0x20) == 0 + + def isMCLinkLocal(self): + if len(self._addr) == 4: + return self._addr[0] == 224 and self._addr[1] == 0 and self._addr[2] == 0 + return (self._addr[0] & 0xFF) == 0xFF and (self._addr[1] & 0x0F) == 0x02 + + def isMCNodeLocal(self): + if len(self._addr) == 4: + return self._addr[0] == 224 and self._addr[1] == 0 and self._addr[2] == 0 and self._addr[3] == 1 + return (self._addr[0] & 0xFF) == 0xFF and (self._addr[1] & 0x0F) == 0x01 + + def isMCOrgLocal(self): + if len(self._addr) == 4: + return self._addr[0] == 239 and 192 <= self._addr[1] <= 195 + return (self._addr[0] & 0xFF) == 0xFF and (self._addr[1] & 0x0F) == 0x08 + + def isMCSiteLocal(self): + if len(self._addr) == 4: + return self._addr[0] == 239 and 255 <= self._addr[1] <= 255 + return (self._addr[0] & 0xFF) == 0xFF and (self._addr[1] & 0x0F) == 0x05 + + def getAddress(self): + return self._addr + + def toString(self): + return f"{self._host}/{self.getHostAddress()}" + + def equals(self, other): + if isinstance(other, InetAddress): + return self._addr == other._addr + return False + + def hashCode(self): + return hash(bytes(self._addr)) & 0x7FFFFFFF + + +# ============================================================ +# InetSocketAddress +# ============================================================ + +class InetSocketAddress(Stub): + def __init__(self, *args): + super().__init__() + if len(args) == 2 and isinstance(args[0], int): + self._addr = None + self._port = args[0] if isinstance(args[0], int) else args[1] + elif len(args) == 2: + hostname, port = args + self._addr = InetAddress.getByName(hostname) if isinstance(hostname, str) else hostname + self._port = port + elif len(args) == 1 and isinstance(args[0], int): + self._addr = None + self._port = args[0] + + def getAddress(self): + return self._addr + + def getPort(self): + return self._port + + def getHostName(self): + return self._addr.getHostName() if self._addr else None + + def getHostString(self): + return self.getHostName() + + def isUnresolved(self): + return self._addr is None + + def toString(self): + return f"{self.getHostName()}:{self._port}" + + def equals(self, other): + if isinstance(other, InetSocketAddress): + return self._port == other._port and self._addr == other._addr + return False + + def hashCode(self): + return hash((self._port, self._addr)) & 0x7FFFFFFF + + +# ============================================================ +# URI +# ============================================================ + +class URI(Stub): + def __init__(self, *args): + super().__init__() + if len(args) == 1: + self._uri = args[0] + parsed = _urlparse(self._uri) + self._scheme = parsed.scheme + self._host = parsed.hostname + self._port = parsed.port + self._path = parsed.path + self._query = parsed.query + self._fragment = parsed.fragment + self._user_info = parsed.username + self._authority = parsed.netloc + elif len(args) == 5: + self._scheme = args[0] + self._authority = args[1] or "" + self._path = args[2] or "" + self._query = args[3] or "" + self._fragment = args[4] or "" + parsed = _urlparse(f"{self._scheme}://{self._authority}{self._path}") + self._host = parsed.hostname + self._port = parsed.port + self._user_info = parsed.username + self._uri = f"{self._scheme}://{self._authority}{self._path}" + if self._query: + self._uri += "?" + self._query + if self._fragment: + self._uri += "#" + self._fragment + else: + raise ValueError("URI constructor requires 1 or 5 arguments") + + def getScheme(self): + return self._scheme + + def getHost(self): + return self._host + + def getPort(self): + return self._port if self._port else -1 + + def getPath(self): + return self._path + + def getQuery(self): + return self._query + + def getFragment(self): + return self._fragment + + def getAuthority(self): + return self._authority + + def getRawAuthority(self): + return self._authority + + def getRawFragment(self): + return self._fragment + + def getRawPath(self): + return self._path + + def getRawQuery(self): + return self._query + + def getRawSchemeSpecificPart(self): + return f"//{self._authority}{self._path}" + + def getRawUserInfo(self): + return self._user_info or "" + + def getSchemeSpecificPart(self): + return self.getRawSchemeSpecificPart() + + def getUserInfo(self): + return self._user_info or "" + + def isAbsolute(self): + return bool(self._scheme) + + def isOpaque(self): + return not self._path and not self._authority and self._scheme + + def normalize(self): + import posixpath + normalized = posixpath.normpath(self._path) + return URI(f"{self._scheme}://{self._authority}{normalized}") + + def resolve(self, uri_or_str): + if isinstance(uri_or_str, URI): + other = uri_or_str + else: + other = URI(uri_or_str) + if other.isAbsolute(): + return other + base_path = self._path or "/" + if base_path.endswith("/"): + new_path = base_path + other._path + else: + new_path = "/".join(base_path.rsplit("/", 1)[:-1] + [other._path]) if other._path else base_path + return URI(f"{self._scheme}://{self._authority}{new_path}") + + def relativize(self, other): + if self._path and other._path and other._path.startswith(self._path): + rel = other._path[len(self._path):] + if rel.startswith("/"): + rel = rel[1:] + return URI(rel) + return other + + def toASCIIString(self): + return _quote(self._uri, safe=":/?#[]@!$&'()*+,;=-._~") + + def toString(self): + return self._uri + + def toURL(self): + return URL(self._uri) + + def compareTo(self, other): + return -1 if self._uri < other._uri else (1 if self._uri > other._uri else 0) + + def equals(self, other): + if isinstance(other, URI): + return self._uri == other._uri + return False + + def hashCode(self): + return hash(self._uri) & 0x7FFFFFFF + + def parseServerAuthority(self): + return self + + +# ============================================================ +# URL +# ============================================================ + +class URL(Stub): + def __init__(self, *args): + super().__init__() + if len(args) == 1: + spec = args[0] + parsed = _urlparse(str(spec)) + self._protocol = parsed.scheme + self._host = parsed.hostname or "" + self._port = parsed.port + self._path = parsed.path or "" + self._file = parsed.path or "" + if parsed.query: + self._file += "?" + parsed.query + self._query = parsed.query or "" + self._ref = parsed.fragment or "" + self._authority = parsed.netloc or "" + self._user_info = parsed.username or "" + self._url_str = str(spec) + elif len(args) == 4: + protocol, host, port, file = args + self._protocol = protocol or "" + self._host = host or "" + self._port = port + self._path = file or "" + self._file = file or "" + self._query = "" + self._ref = "" + self._authority = f"{host}:{port}" if port and port > 0 else host + self._user_info = "" + parts = [file or ""] + self._url_str = f"{protocol}://{self._authority}{file}" + + def getProtocol(self): + return self._protocol + + def getHost(self): + return self._host + + def getPort(self): + return self._port if self._port else -1 + + def getDefaultPort(self): + defaults = { + "http": 80, "https": 443, "ftp": 21, "smtp": 25, + "ssh": 22, "telnet": 23, "ldap": 389, + } + return defaults.get(self._protocol, -1) + + def getPath(self): + return self._path + + def getFile(self): + return self._file + + def getQuery(self): + return self._query + + def getRef(self): + return self._ref + + def getAuthority(self): + return self._authority + + def getUserInfo(self): + return self._user_info + + def getContent(self, classes=None): + return self.openConnection().getContent(classes) + + def openConnection(self, proxy=None): + return HttpURLConnection(self._url_str, proxy) + + def openStream(self): + return self.openConnection().getInputStream() + + def sameFile(self, other): + return (self._protocol == other._protocol and self._host == other._host + and self._port == other._port and self._path == other._path) + + def toExternalForm(self): + return self._url_str + + def toString(self): + return self._url_str + + def toURI(self): + return URI(self._url_str) + + def equals(self, other): + if isinstance(other, URL): + return self._url_str == other._url_str + return False + + def hashCode(self): + return hash(self._url_str) & 0x7FFFFFFF + + def openConnection(self, proxy=None): + return HttpURLConnection(self._url_str, proxy) + + def __str__(self): + return self._url_str + + +# ============================================================ +# URLConnection +# ============================================================ + +class URLConnection(Stub): + def __init__(self, url_str): + super().__init__() + self._url_str = url_str + self._connected = False + self._do_input = True + self._do_output = False + self._allow_user_interaction = False + self._use_caches = True + self._default_use_caches = True + self._if_modified_since = 0 + self._read_timeout = 0 + self._connect_timeout = 0 + self._request_properties = _OrderedDict() + self._response_code = None + self._response_message = None + self._response_headers = _OrderedDict() + self._content = None + + def connect(self): + if not self._connected: + self._connected = True + + def getContent(self, classes=None): + raise UnknownServiceException("getContent not implemented") + + def getContentEncoding(self): + return self._response_headers.get("Content-Encoding") + + def getContentLength(self): + val = self._response_headers.get("Content-Length") + return int(val) if val else -1 + + def getContentLengthLong(self): + return self.getContentLength() + + def getContentType(self): + return self._response_headers.get("Content-Type") + + def getDate(self): + val = self._response_headers.get("Date") + if val: + try: + return int(_datetime.strptime(val, "%a, %d %b %Y %H:%M:%S %Z").timestamp() * 1000) + except Exception: + pass + return 0 + + def getExpiration(self): + val = self._response_headers.get("Expires") + if val: + try: + return int(_datetime.strptime(val, "%a, %d %b %Y %H:%M:%S %Z").timestamp() * 1000) + except Exception: + pass + return 0 + + def getHeaderField(self, name): + return self._response_headers.get(name) + + def getHeaderFieldDate(self, name, default): + val = self._response_headers.get(name) + if val: + try: + return int(_datetime.strptime(val, "%a, %d %b %Y %H:%M:%S %Z").timestamp() * 1000) + except Exception: + pass + return default + + def getHeaderFieldInt(self, name, default): + val = self._response_headers.get(name) + return int(val) if val and val.isdigit() else default + + def getHeaderFieldKey(self, n): + keys = list(self._response_headers.keys()) + return keys[n] if n < len(keys) else None + + def getHeaderFields(self): + return self._response_headers + + def getInputStream(self): + raise UnknownServiceException("getInputStream not implemented") + + def getOutputStream(self): + raise UnknownServiceException("getOutputStream not implemented") + + def getPermission(self): + return None + + def getReadTimeout(self): + return self._read_timeout + + def setReadTimeout(self, timeout): + self._read_timeout = timeout + + def getConnectTimeout(self): + return self._connect_timeout + + def setConnectTimeout(self, timeout): + self._connect_timeout = timeout + + def getRequestProperty(self, key): + return self._request_properties.get(key) + + def setRequestProperty(self, key, value): + self._request_properties[key] = value + + def addRequestProperty(self, key, value): + if key in self._request_properties: + existing = self._request_properties[key] + if isinstance(existing, list): + existing.append(value) + else: + self._request_properties[key] = [existing, value] + else: + self._request_properties[key] = value + + def getDefaultUseCaches(self): + return self._default_use_caches + + def setDefaultUseCaches(self, use): + self._default_use_caches = use + + def getUseCaches(self): + return self._use_caches + + def setUseCaches(self, use): + self._use_caches = use + + def setDoInput(self, do_input): + self._do_input = do_input + + def getDoInput(self): + return self._do_input + + def setDoOutput(self, do_output): + self._do_output = do_output + + def getDoOutput(self): + return self._do_output + + def setAllowUserInteraction(self, allow): + self._allow_user_interaction = allow + + def getAllowUserInteraction(self): + return self._allow_user_interaction + + def setIfModifiedSince(self, time): + self._if_modified_since = time + + def getIfModifiedSince(self): + return self._if_modified_since + + +# ============================================================ +# HttpURLConnection +# ============================================================ + +class HttpURLConnection(URLConnection): + HTTP_OK = 200 + HTTP_CREATED = 201 + HTTP_ACCEPTED = 202 + HTTP_MOVED_PERM = 301 + HTTP_MOVED_TEMP = 302 + HTTP_NOT_MODIFIED = 304 + HTTP_BAD_REQUEST = 400 + HTTP_UNAUTHORIZED = 401 + HTTP_FORBIDDEN = 403 + HTTP_NOT_FOUND = 404 + HTTP_INTERNAL_ERROR = 500 + + def __init__(self, url_str, proxy=None): + super().__init__(url_str) + self._request_method = "GET" + self._instance_follow_redirects = True + self._chunked = False + self._fixed_length = -1 + self._input_stream = None + self._error_stream = None + self._response_code = -1 + self._response_message = "" + + def setRequestMethod(self, method): + method = method.upper() + valid = ["GET", "POST", "HEAD", "OPTIONS", "PUT", "DELETE", "TRACE", "PATCH"] + if method not in valid: + raise ProtocolException(f"Invalid HTTP method: {method}") + self._request_method = method + + def getRequestMethod(self): + return self._request_method + + def getResponseCode(self): + if self._response_code == -1: + self._do_request() + return self._response_code + + def getResponseMessage(self): + if self._response_code == -1: + self._do_request() + return self._response_message + + def getHeaderFields(self): + if self._response_code == -1: + self._do_request() + return self._response_headers + + def setInstanceFollowRedirects(self, follow): + self._instance_follow_redirects = follow + + def getInstanceFollowRedirects(self): + return self._instance_follow_redirects + + def getErrorStream(self): + if self._response_code == -1: + self._do_request() + if self._response_code >= 400: + return self._error_stream + return None + + def setChunkedStreamingMode(self, chunklen): + self._chunked = True + self._chunk_length = chunklen + + def setFixedLengthStreamingMode(self, content_length): + self._fixed_length = content_length + + def setFixedLengthStreamingModeLong(self, content_length): + self._fixed_length = content_length + + def disconnect(self): + self._input_stream = None + self._error_stream = None + self._connected = False + + def usingProxy(self): + return False + + def getInputStream(self): + if self._response_code == -1: + self._do_request() + if self._input_stream is None: + import io as _pyio_mod + self._input_stream = _pyio_mod.BytesIO(self._content.encode("utf-8") if isinstance(self._content, str) else self._content) + return self._input_stream + + def _do_request(self): + if HAS_REQUESTS: + self._do_requests() + elif HAS_HTTPX: + self._do_httpx() + else: + self._do_urllib() + + def _do_requests(self): + import requests + try: + kwargs = { + "headers": dict(self._request_properties), + "timeout": self._read_timeout / 1000.0 if self._read_timeout else None, + } + if self._instance_follow_redirects: + kwargs["allow_redirects"] = True + else: + kwargs["allow_redirects"] = False + method = self._request_method.lower() + if method == "get": + r = requests.get(self._url_str, **kwargs) + elif method == "post": + body = self._request_properties.pop("__body", None) + r = requests.post(self._url_str, data=body, **kwargs) + elif method == "put": + body = self._request_properties.pop("__body", None) + r = requests.put(self._url_str, data=body, **kwargs) + elif method == "delete": + r = requests.delete(self._url_str, **kwargs) + elif method == "head": + r = requests.head(self._url_str, **kwargs) + elif method == "options": + r = requests.options(self._url_str, **kwargs) + elif method == "patch": + body = self._request_properties.pop("__body", None) + r = requests.patch(self._url_str, data=body, **kwargs) + else: + r = requests.request(self._request_method, self._url_str, **kwargs) + self._response_code = r.status_code + self._response_message = r.reason + self._response_headers = dict(r.headers) + self._content = r.content + except Exception as e: + self._response_code = 0 + self._response_message = str(e) + + def _do_httpx(self): + import httpx + try: + client = httpx.Client(follow_redirects=self._instance_follow_redirects) + kwargs = { + "headers": dict(self._request_properties) if self._request_properties else None, + "timeout": self._read_timeout / 1000.0 if self._read_timeout else None, + } + method = self._request_method.lower() + if method == "get": + r = client.get(self._url_str, **kwargs) + elif method == "post": + body = self._request_properties.pop("__body", None) + r = client.post(self._url_str, content=body, **kwargs) + elif method == "put": + body = self._request_properties.pop("__body", None) + r = client.put(self._url_str, content=body, **kwargs) + elif method == "delete": + r = client.delete(self._url_str, **kwargs) + else: + r = client.request(self._request_method, self._url_str, **kwargs) + self._response_code = r.status_code + self._response_message = r.reason_phrase + self._response_headers = dict(r.headers) + self._content = r.content + except Exception as e: + self._response_code = 0 + self._response_message = str(e) + + def _do_urllib(self): + from urllib.request import urlopen, Request + from urllib.error import HTTPError + try: + req = Request(self._url_str, headers=dict(self._request_properties) if self._request_properties else {}, + method=self._request_method) + resp = urlopen(req, timeout=self._read_timeout / 1000.0 if self._read_timeout else None) + self._response_code = resp.status + self._response_message = resp.reason + self._response_headers = dict(resp.headers) + self._content = resp.read() + except HTTPError as e: + self._response_code = e.code + self._response_message = e.reason + self._response_headers = dict(e.headers) + self._content = e.read() + except Exception as e: + self._response_code = 0 + self._response_message = str(e) + self._content = b"" + + +# ============================================================ +# Socket +# ============================================================ + +class Socket(Stub): + def __init__(self, *args): + super().__init__() + self._socket = None + self._connected = False + self._bound = False + self._closed = False + self._input_shutdown = False + self._output_shutdown = False + self._input_stream = None + self._output_stream = None + self._timeout = 0 + self._keep_alive = False + self._tcp_no_delay = False + self._reuse_address = False + self._send_buffer_size = 0 + self._receive_buffer_size = 0 + self._linger = -1 + self._traffic_class = 0 + if len(args) == 2: + host, port = args + self.connect(InetSocketAddress(host, port)) + elif len(args) == 1 and isinstance(args[0], InetAddress): + addr, port = args[0], 0 + self.connect(InetSocketAddress(addr, port)) + + def connect(self, endpoint, timeout=None): + if isinstance(endpoint, InetSocketAddress): + host = endpoint.getHostName() + port = endpoint.getPort() + else: + host = str(endpoint) + port = 80 + self._socket = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM) + if self._timeout > 0: + self._socket.settimeout(self._timeout / 1000.0) + try: + self._socket.connect((host, port)) + self._connected = True + except OSError as e: + raise ConnectException(str(e)) + + def bind(self, endpoint): + if isinstance(endpoint, InetSocketAddress): + host = endpoint.getHostName() + port = endpoint.getPort() + else: + host = "0.0.0.0" + port = 0 + self._socket = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM) + self._socket.bind((host or "0.0.0.0", port)) + self._bound = True + + def close(self): + if not self._closed: + self._closed = True + if self._socket: + self._socket.close() + + def getInputStream(self): + if self._input_stream is None and self._socket: + import io as _pyio_mod + fd = self._socket.fileno() + self._input_stream = _pyio_mod.FileIO(fd, closefd=False) + return self._input_stream + + def getOutputStream(self): + if self._output_stream is None and self._socket: + import io as _pyio_mod + fd = self._socket.fileno() + self._output_stream = _pyio_mod.FileIO(fd, closefd=False, mode="ab") + return self._output_stream + + def getInetAddress(self): + if self._socket and self._connected: + host, _ = self._socket.getpeername() + return InetAddress.getByName(host) + return None + + def getPort(self): + if self._socket and self._connected: + _, port = self._socket.getpeername() + return port + return 0 + + def getLocalPort(self): + if self._socket: + _, port = self._socket.getsockname() + return port + return 0 + + def getLocalAddress(self): + if self._socket: + host, _ = self._socket.getsockname() + return InetAddress.getByName(host) + return InetAddress.getLoopbackAddress() + + def getRemoteSocketAddress(self): + if self._socket and self._connected: + host, port = self._socket.getpeername() + return InetSocketAddress(host, port) + return None + + def getLocalSocketAddress(self): + if self._socket: + host, port = self._socket.getsockname() + return InetSocketAddress(host, port) + return None + + def getSoTimeout(self): + return self._timeout + + def setSoTimeout(self, timeout): + self._timeout = timeout + if self._socket: + self._socket.settimeout(timeout / 1000.0 if timeout > 0 else None) + + def getTcpNoDelay(self): + return self._tcp_no_delay + + def setTcpNoDelay(self, on): + self._tcp_no_delay = on + if self._socket: + self._socket.setsockopt(_socket.IPPROTO_TCP, _socket.TCP_NODELAY, 1 if on else 0) + + def getKeepAlive(self): + return self._keep_alive + + def setKeepAlive(self, on): + self._keep_alive = on + if self._socket: + self._socket.setsockopt(_socket.SOL_SOCKET, _socket.SO_KEEPALIVE, 1 if on else 0) + + def getReuseAddress(self): + return self._reuse_address + + def setReuseAddress(self, on): + self._reuse_address = on + if self._socket: + self._socket.setsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR, 1 if on else 0) + + def getSendBufferSize(self): + return self._send_buffer_size + + def setSendBufferSize(self, size): + self._send_buffer_size = size + if self._socket: + self._socket.setsockopt(_socket.SOL_SOCKET, _socket.SO_SNDBUF, size) + + def getReceiveBufferSize(self): + return self._receive_buffer_size + + def setReceiveBufferSize(self, size): + self._receive_buffer_size = size + if self._socket: + self._socket.setsockopt(_socket.SOL_SOCKET, _socket.SO_RCVBUF, size) + + def getSoLinger(self): + return self._linger + + def setSoLinger(self, on, linger): + if on: + self._linger = linger + if self._socket: + self._socket.setsockopt(_socket.SOL_SOCKET, _socket.SO_LINGER, _struct.pack("ii", 1, linger)) + else: + self._linger = -1 + + def getTrafficClass(self): + return self._traffic_class + + def setTrafficClass(self, tc): + self._traffic_class = tc + + def shutdownInput(self): + if self._socket: + self._socket.shutdown(_socket.SHUT_RD) + self._input_shutdown = True + + def shutdownOutput(self): + if self._socket: + self._socket.shutdown(_socket.SHUT_WR) + self._output_shutdown = True + + def isConnected(self): + return self._connected + + def isBound(self): + return self._bound + + def isClosed(self): + return self._closed + + def isInputShutdown(self): + return self._input_shutdown + + def isOutputShutdown(self): + return self._output_shutdown + + def setPerformancePreferences(self, connection_time, latency, bandwidth): + pass + + +# ============================================================ +# ServerSocket +# ============================================================ + +class ServerSocket(Stub): + def __init__(self, port=0, backlog=50, bindAddr=None): + super().__init__() + self._socket = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM) + self._socket.setsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR, 1) + self._port = port + self._backlog = backlog + self._bind_addr = bindAddr + self._closed = False + self._timeout = 0 + if port > 0 or bindAddr: + self.bind(InetSocketAddress(bindAddr or "0.0.0.0", port), backlog) + + def bind(self, endpoint, backlog=50): + host = endpoint.getHostName() if isinstance(endpoint, InetSocketAddress) else str(endpoint) + port = endpoint.getPort() if isinstance(endpoint, InetSocketAddress) else 0 + self._socket.bind((host or "0.0.0.0", port)) + self._socket.listen(backlog) + self._port = self._socket.getsockname()[1] + + def accept(self): + if self._closed: + raise SocketException("Socket closed") + if self._timeout > 0: + self._socket.settimeout(self._timeout / 1000.0) + try: + client_sock, addr = self._socket.accept() + sock = Socket() + sock._socket = client_sock + sock._connected = True + return sock + except _socket.timeout: + raise SocketTimeoutException("Accept timed out") + + def close(self): + if not self._closed: + self._closed = True + self._socket.close() + + def getInetAddress(self): + host, _ = self._socket.getsockname() + return InetAddress.getByName(host) + + def getLocalPort(self): + return self._socket.getsockname()[1] if not self._closed else -1 + + def getSoTimeout(self): + return self._timeout + + def setSoTimeout(self, timeout): + self._timeout = timeout + self._socket.settimeout(timeout / 1000.0 if timeout > 0 else None) + + def getReceiveBufferSize(self): + return self._socket.getsockopt(_socket.SOL_SOCKET, _socket.SO_RCVBUF) + + def setReceiveBufferSize(self, size): + self._socket.setsockopt(_socket.SOL_SOCKET, _socket.SO_RCVBUF, size) + + def getReuseAddress(self): + return bool(self._socket.getsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR)) + + def setReuseAddress(self, on): + self._socket.setsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR, 1 if on else 0) + + +# ============================================================ +# DatagramSocket / DatagramPacket +# ============================================================ + +class DatagramPacket(Stub): + def __init__(self, buf, length, address=None, port=None): + super().__init__() + if address is not None: + self._buf = bytearray(buf) + self._length = length + self._address = address + self._port = port + else: + self._buf = bytearray(buf) + self._length = length + self._address = None + self._port = -1 + + def getAddress(self): + return self._address + + def getPort(self): + return self._port + + def getData(self): + return bytes(self._buf) + + def getLength(self): + return self._length + + def setAddress(self, address): + self._address = address + + def setPort(self, port): + self._port = port + + def setData(self, buf, offset=None, length=None): + if offset is not None and length is not None: + self._buf = bytearray(buf[offset:offset+length]) + self._length = length + else: + self._buf = bytearray(buf) + self._length = len(buf) + + def setLength(self, length): + self._length = length + + +class DatagramSocket(Stub): + def __init__(self, port=None): + super().__init__() + self._socket = _socket.socket(_socket.AF_INET, _socket.SOCK_DGRAM) + self._bound = False + self._closed = False + if port is not None: + self.bind(port) + + def bind(self, port): + self._socket.bind(("0.0.0.0", port)) + self._bound = True + + def send(self, p): + addr = p.getAddress() + port = p.getPort() + self._socket.sendto(p.getData()[:p.getLength()], (addr.getHostAddress(), port)) + + def receive(self, p): + data, addr = self._socket.recvfrom(p.getLength()) + p.setData(data) + p.setAddress(InetAddress(addr[0], _socket.inet_pton(_socket.AF_INET, addr[0]))) + p.setPort(addr[1]) + + def close(self): + if not self._closed: + self._closed = True + self._socket.close() + + def getLocalPort(self): + return self._socket.getsockname()[1] if not self._closed else -1 + + def isBound(self): + return self._bound + + def isClosed(self): + return self._closed + + def setSoTimeout(self, timeout): + self._socket.settimeout(timeout / 1000.0 if timeout > 0 else None) + + def getSoTimeout(self): + return self._socket.gettimeout() * 1000 if self._socket.gettimeout() else 0 + + +# ============================================================ +# Proxy +# ============================================================ + +class Proxy(Stub): + class Type: + DIRECT = "DIRECT" + HTTP = "HTTP" + SOCKS = "SOCKS" + + NO_PROXY = None + + def __init__(self, typ, sa=None): + super().__init__() + self._type = typ + self._address = sa + + def type(self): + return self._type + + def address(self): + return self._address + + def toString(self): + return f"{self._type} proxy @ {self._address}" + + +class ProxySelector(Stub): + _default = None + + @staticmethod + def getDefault(): + return ProxySelector._default + + @staticmethod + def setDefault(sel): + ProxySelector._default = sel + + def select(self, uri): + return [Proxy.NO_PROXY] + + def connectFailed(self, uri, sa, ioe): + pass + + +# ============================================================ +# Authenticator / PasswordAuthentication +# ============================================================ + +class Authenticator(Stub): + _default = None + + @staticmethod + def getDefault(): + return Authenticator._default + + @staticmethod + def setDefault(auth): + Authenticator._default = auth + + def getPasswordAuthentication(self): + return self._pwd_auth + + def requestPasswordAuthentication(self, addr, port, protocol, prompt, scheme): + return self._pwd_auth + + +class PasswordAuthentication(Stub): + def __init__(self, user, password): + super().__init__() + self._user = user + self._password = password + + def getUserName(self): + return self._user + + def getPassword(self): + return self._password + + +# ============================================================ +# NetworkInterface +# ============================================================ + +class NetworkInterface(Stub): + _cache = {} + + def __init__(self, name, display_name, addrs): + super().__init__() + self._name = name + self._display_name = display_name + self._addrs = addrs + + @staticmethod + def getByName(name): + if name in NetworkInterface._cache: + return NetworkInterface._cache[name] + + @staticmethod + def getByInetAddress(addr): + for ni in NetworkInterface._cache.values(): + for a in ni._addrs: + if a.equals(addr): + return ni + return None + + @staticmethod + def getNetworkInterfaces(): + return list(NetworkInterface._cache.values()) + + def getName(self): + return self._name + + def getDisplayName(self): + return self._display_name + + def getInetAddresses(self): + return iter(self._addrs) + + def getInterfaceAddresses(self): + return self._addrs + + def isUp(self): + return True + + def isLoopback(self): + return self._name == "lo" + + def isPointToPoint(self): + return False + + def supportsMulticast(self): + return True + + def getHardwareAddress(self): + return None + + def getMTU(self): + return 1500 + + def getSubInterfaces(self): + return iter([]) + + def getParent(self): + return None + + def isVirtual(self): + return False + + def toString(self): + return f"{self._display_name} ({self._name})" + + @staticmethod + def _init_from_socket(): + import netifaces + for iface_name in netifaces.interfaces(): + addrs = [] + ifaddresses = netifaces.ifaddresses(iface_name) + for family in [netifaces.AF_INET, netifaces.AF_INET6]: + if family in ifaddresses: + for addr_info in ifaddresses[family]: + try: + addr = addr_info["addr"] + if "." in addr: + addrs.append(InetAddress(addr, _socket.inet_pton(_socket.AF_INET, addr))) + else: + addrs.append(InetAddress(addr, _socket.inet_pton(_socket.AF_INET6, addr))) + except Exception: + pass + NetworkInterface._cache[iface_name] = NetworkInterface(iface_name, iface_name, addrs) + +try: + NetworkInterface._init_from_socket() +except Exception: + pass + + +# ============================================================ +# CookieHandler / CookieManager / HttpCookie +# ============================================================ + +class CookieHandler(Stub): + _default = None + + @staticmethod + def getDefault(): + return CookieHandler._default + + @staticmethod + def setDefault(handler): + CookieHandler._default = handler + + def get(self, uri, requestHeaders): + raise NotImplementedError + + def put(self, uri, responseHeaders): + raise NotImplementedError + + +class HttpCookie(Stub): + def __init__(self, name, value): + super().__init__() + self._name = name + self._value = value + self._comment = None + self._comment_url = None + self._discard = False + self._domain = None + self._max_age = -1 + self._path = None + self._portlist = None + self._secure = False + self._version = 0 + self._http_only = False + self._creation_time = _datetime.now() + + def getName(self): + return self._name + + def getValue(self): + return self._value + + def getComment(self): + return self._comment + + def getCommentURL(self): + return self._comment_url + + def getDiscard(self): + return self._discard + + def getDomain(self): + return self._domain + + def getMaxAge(self): + return self._max_age + + def getPath(self): + return self._path + + def getPortlist(self): + return self._portlist + + def getSecure(self): + return self._secure + + def getVersion(self): + return self._version + + def getHttpOnly(self): + return self._http_only + + def setComment(self, comment): + self._comment = comment + + def setCommentURL(self, url): + self._comment_url = url + + def setDiscard(self, discard): + self._discard = discard + + def setDomain(self, domain): + self._domain = domain + + def setMaxAge(self, max_age): + self._max_age = max_age + + def setPath(self, path): + self._path = path + + def setPortlist(self, portlist): + self._portlist = portlist + + def setSecure(self, secure): + self._secure = secure + + def setVersion(self, version): + self._version = version + + def setHttpOnly(self, http_only): + self._http_only = http_only + + def hasExpired(self): + if self._max_age < 0: + return False + elapsed = (_datetime.now() - self._creation_time).total_seconds() + return elapsed > self._max_age + + def equals(self, other): + if isinstance(other, HttpCookie): + return self._name == other._name + return False + + def toString(self): + return f"{self._name}={self._value}" + + def validate(self, name): + if not name or name.strip() == "": + raise ValueError("Cookie name cannot be empty") + + def __str__(self): + return self.toString() + + +class CookieManager(CookieHandler): + def __init__(self): + super().__init__() + self._cookie_store = {} + + def get(self, uri, requestHeaders): + cookies = [] + for domain, path, cookie in self._cookie_store.values(): + if not cookie.hasExpired(): + cookies.append(cookie.toString()) + return {"Cookie": "; ".join(cookies)} if cookies else {} + + def put(self, uri, responseHeaders): + set_cookie = responseHeaders.get("Set-Cookie") + if set_cookie: + parts = set_cookie.split(";") + name_val = parts[0].split("=", 1) + if len(name_val) == 2: + cookie = HttpCookie(name_val[0], name_val[1]) + for part in parts[1:]: + part = part.strip() + if "=" in part: + k, v = part.split("=", 1) + if k.lower() == "domain": + cookie.setDomain(v) + elif k.lower() == "path": + cookie.setPath(v) + elif k.lower() == "max-age": + cookie.setMaxAge(int(v)) + elif k.lower() == "version": + cookie.setVersion(int(v)) + else: + if part.lower() == "secure": + cookie.setSecure(True) + elif part.lower() == "httponly": + cookie.setHttpOnly(True) + elif part.lower() == "discard": + cookie.setDiscard(True) + self._cookie_store[(cookie.getDomain(), cookie.getPath(), cookie.getName())] = (cookie.getDomain(), cookie.getPath(), cookie) + + +# ============================================================ +# URLEncoder / URLDecoder +# ============================================================ + +class URLEncoder(Stub): + @staticmethod + def encode(s, charset="UTF-8"): + return _quote(str(s), safe="") + + @staticmethod + def encode(s): + return _quote(str(s), safe="") + + +class URLDecoder(Stub): + @staticmethod + def decode(s, charset="UTF-8"): + return _unquote(str(s), encoding=charset) + + @staticmethod + def decode(s): + return _unquote(str(s)) + + +# Initialize NO_PROXY +Proxy.NO_PROXY = Proxy(Proxy.Type.DIRECT, None) \ No newline at end of file diff --git a/android_pyapi/java/nio.py b/android_pyapi/java/nio.py new file mode 100644 index 0000000..9418716 --- /dev/null +++ b/android_pyapi/java/nio.py @@ -0,0 +1,622 @@ +""" +Java NIO standard library APIs implemented in Python. +java.nio package - Buffer, ByteBuffer, CharBuffer, etc. +""" + +from .._core import Stub +from .lang import RuntimeException +from .io import IOException +import struct as _struct +import sys as _sys + +IllegalStateException = type("IllegalStateException", (RuntimeException,), {}) +IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {}) + +__all__ = [ + "Buffer", "ByteBuffer", "CharBuffer", "ShortBuffer", + "IntBuffer", "LongBuffer", "FloatBuffer", "DoubleBuffer", + "MappedByteBuffer", "ByteOrder", + "BufferOverflowException", "BufferUnderflowException", + "ReadOnlyBufferException", "InvalidMarkException", +] + + +# ============================================================ +# Exception classes +# ============================================================ + +class BufferOverflowException(RuntimeException): + pass + +class BufferUnderflowException(RuntimeException): + pass + +class ReadOnlyBufferException(RuntimeException): + pass + +class InvalidMarkException(IllegalStateException): + pass + + +# ============================================================ +# ByteOrder +# ============================================================ + +class ByteOrder(Stub): + BIG_ENDIAN = None + LITTLE_ENDIAN = None + + def __init__(self, name): + super().__init__() + self._name = name + + @staticmethod + def nativeOrder(): + if _sys.byteorder == "little": + return ByteOrder.LITTLE_ENDIAN + return ByteOrder.BIG_ENDIAN + + def toString(self): + return self._name + + +ByteOrder.BIG_ENDIAN = ByteOrder("BIG_ENDIAN") +ByteOrder.LITTLE_ENDIAN = ByteOrder("LITTLE_ENDIAN") + + +# ============================================================ +# Buffer +# ============================================================ + +class Buffer(Stub): + def __init__(self, capacity, backing=None): + super().__init__() + self._capacity = capacity + self._position = 0 + self._limit = capacity + self._mark = -1 + self._backing = backing if backing is not None else bytearray(capacity) + self._read_only = False + + def capacity(self): + return self._capacity + + def position(self): + return self._position + + def position(self, new_position): + if new_position < 0 or new_position > self._limit: + raise IllegalArgumentException("Invalid position") + self._position = new_position + return self + + def limit(self): + return self._limit + + def limit(self, new_limit): + if new_limit < 0 or new_limit > self._capacity: + raise IllegalArgumentException("Invalid limit") + self._limit = new_limit + if self._position > self._limit: + self._position = self._limit + if self._mark > self._limit: + self._mark = -1 + return self + + def mark(self): + self._mark = self._position + return self + + def reset(self): + if self._mark < 0: + raise InvalidMarkException() + self._position = self._mark + return self + + def clear(self): + self._position = 0 + self._limit = self._capacity + self._mark = -1 + return self + + def flip(self): + self._limit = self._position + self._position = 0 + self._mark = -1 + return self + + def rewind(self): + self._position = 0 + self._mark = -1 + return self + + def remaining(self): + return self._limit - self._position + + def hasRemaining(self): + return self._position < self._limit + + def isReadOnly(self): + return self._read_only + + def isDirect(self): + return False + + def array(self): + if self._read_only: + raise ReadOnlyBufferException() + return self._backing + + def arrayOffset(self): + return 0 + + +# ============================================================ +# ByteBuffer +# ============================================================ + +class ByteBuffer(Buffer): + def __init__(self, capacity, backing=None, order=None): + super().__init__(capacity, backing) + self._order = order or ByteOrder.BIG_ENDIAN + + @staticmethod + def allocate(capacity): + return ByteBuffer(capacity, bytearray(capacity)) + + @staticmethod + def allocateDirect(capacity): + return ByteBuffer(capacity, bytearray(capacity)) + + @staticmethod + def wrap(array, offset=0, length=None): + if length is None: + length = len(array) - offset + buf = ByteBuffer(length, bytearray(array)) + buf._position = offset + buf._limit = offset + length + return buf + + def put(self, b, index=None): + if self._read_only: + raise ReadOnlyBufferException() + if index is None: + if isinstance(b, int): + if self._position >= self._limit: + raise BufferOverflowException() + self._backing[self._position] = b & 0xFF + self._position += 1 + elif isinstance(b, ByteBuffer): + n = b.remaining() + if self.remaining() < n: + raise BufferOverflowException() + self._backing[self._position:self._position+n] = b._backing[b._position:b._limit] + self._position += n + b._position = b._limit + elif isinstance(b, (bytes, bytearray)): + if self.remaining() < len(b): + raise BufferOverflowException() + self._backing[self._position:self._position+len(b)] = b + self._position += len(b) + else: + self._backing[index] = b & 0xFF + return self + + def get(self, index=None): + if index is None: + if self._position >= self._limit: + raise BufferUnderflowException() + val = self._backing[self._position] + self._position += 1 + return val & 0xFF + return self._backing[index] & 0xFF + + def putInt(self, value, index=None): + data = _struct.pack(">i" if self._order == ByteOrder.BIG_ENDIAN else "i" if self._order == ByteOrder.BIG_ENDIAN else "q" if self._order == ByteOrder.BIG_ENDIAN else "q" if self._order == ByteOrder.BIG_ENDIAN else "f" if self._order == ByteOrder.BIG_ENDIAN else "f" if self._order == ByteOrder.BIG_ENDIAN else "d" if self._order == ByteOrder.BIG_ENDIAN else "d" if self._order == ByteOrder.BIG_ENDIAN else "h" if self._order == ByteOrder.BIG_ENDIAN else "h" if self._order == ByteOrder.BIG_ENDIAN else " b) - (a < b) + return -1 + + +# ============================================================ +# IntBuffer +# ============================================================ + +class IntBuffer(Buffer): + def __init__(self, capacity, backing, offset=0, order=None): + super().__init__(capacity, backing) + self._int_order = order or ByteOrder.BIG_ENDIAN + self._int_offset = offset + + def get(self, index=None): + if index is not None: + idx = self._int_offset + index * 4 + return _struct.unpack(">i" if self._int_order == ByteOrder.BIG_ENDIAN else "i" if self._int_order == ByteOrder.BIG_ENDIAN else "i" if self._int_order == ByteOrder.BIG_ENDIAN else "q" if self._long_order == ByteOrder.BIG_ENDIAN else "q" if self._long_order == ByteOrder.BIG_ENDIAN else "q" if self._long_order == ByteOrder.BIG_ENDIAN else "f" if self._float_order == ByteOrder.BIG_ENDIAN else "f" if self._float_order == ByteOrder.BIG_ENDIAN else "f" if self._float_order == ByteOrder.BIG_ENDIAN else "d" if self._double_order == ByteOrder.BIG_ENDIAN else "d" if self._double_order == ByteOrder.BIG_ENDIAN else "d" if self._double_order == ByteOrder.BIG_ENDIAN else "h" if self._short_order == ByteOrder.BIG_ENDIAN else "h" if self._short_order == ByteOrder.BIG_ENDIAN else "h" if self._short_order == ByteOrder.BIG_ENDIAN else "h" if self._char_order == ByteOrder.BIG_ENDIAN else "h" if self._char_order == ByteOrder.BIG_ENDIAN else "h" if self._char_order == ByteOrder.BIG_ENDIAN else "= len(parts): + raise IllegalArgumentException("Invalid index") + return Path(parts[index]) + + def getNameCount(self): + parts = self._pypath.parts + if self.getRoot(): + parts = parts[1:] + return len(parts) + + def subpath(self, beginIndex, endIndex): + parts = self._pypath.parts + if self.getRoot(): + parts = parts[1:] + return Path(_os.path.join(*parts[beginIndex:endIndex])) + + def startsWith(self, other): + if isinstance(other, Path): + return str(self._pypath).startswith(str(other._pypath)) + return str(self._pypath).startswith(str(other)) + + def endsWith(self, other): + if isinstance(other, Path): + return str(self._pypath).endswith(str(other._pypath)) + return str(self._pypath).endswith(str(other)) + + def normalize(self): + return Path(_os.path.normpath(self._path)) + + def resolve(self, other): + if isinstance(other, Path): + other_path = str(other) + else: + other_path = str(other) + if _os.path.isabs(other_path): + return Path(other_path) + return Path(_os.path.join(self._path, other_path)) + + def resolveSibling(self, other): + parent = self.getParent() + if parent: + return parent.resolve(other) + return Path(other) + + def relativize(self, other): + if isinstance(other, Path): + other_str = str(other._pypath) + else: + other_str = str(other) + try: + rel = _os.path.relpath(other_str, self._path) + return Path(rel) + except ValueError: + return other + + def compareTo(self, other): + if isinstance(other, Path): + return (self._path > other._path) - (self._path < other._path) + return -1 + + def toString(self): + return self._path + + def toFile(self): + from ..io import File + return File(self._path) + + def isAbsolute(self): + return _os.path.isabs(self._path) + + def getFileSystem(self): + return FileSystems.getDefault() + + def iterator(self): + parts = self._pypath.parts + if self.getRoot(): + parts = parts[1:] + return iter([Path(p) for p in parts]) + + def register(self, watcher, events, *modifiers): + raise AndroidOnlyError("WatchService nio") + + def __str__(self): + return self._path + + def __eq__(self, other): + if isinstance(other, Path): + return self._path == other._path + return NotImplemented + + def __hash__(self): + return hash(self._path) + + +# ============================================================ +# Paths +# ============================================================ + +class Paths(Stub): + @staticmethod + def get(first, *more): + parts = [str(first)] + parts.extend(str(m) for m in more) + return Path(_os.path.join(*parts)) + + +# ============================================================ +# FileSystem +# ============================================================ + +class FileSystem(Stub): + def __init__(self): + super().__init__() + self._separator = _os.sep + self._open = True + + def getPath(self, first, *more): + return Paths.get(first, *more) + + def getSeparator(self): + return self._separator + + def getRootDirectories(self): + if _os.name == "nt": + import string + return [Path(d + ":\\") for d in string.ascii_uppercase if _os.path.exists(d + ":\\")] + return [Path("/")] + + def getUserPrincipalLookupService(self): + raise AndroidOnlyError("UserPrincipalLookupService") + + def newWatchService(self): + raise AndroidOnlyError("WatchService") + + def getFileStores(self): + return [FileStore("/")] + + def supportedFileAttributeViews(self): + return ["basic", "owner", "posix"] + + def close(self): + self._open = False + + def isOpen(self): + return self._open + + def isReadOnly(self): + return False + + +class FileSystems(Stub): + _default = None + + @staticmethod + def getDefault(): + if FileSystems._default is None: + FileSystems._default = FileSystem() + return FileSystems._default + + +# ============================================================ +# FileStore +# ============================================================ + +class FileStore(Stub): + def __init__(self, path): + super().__init__() + self._path = path + + def name(self): + return _os.path.basename(self._path) or "/" + + def type(self): + return "ext4" + + def isReadOnly(self): + return False + + def getTotalSpace(self): + try: + st = _os.statvfs(self._path) + return st.f_frsize * st.f_blocks + except OSError: + return 0 + + def getUsableSpace(self): + try: + st = _os.statvfs(self._path) + return st.f_frsize * st.f_bavail + except OSError: + return 0 + + def getUnallocatedSpace(self): + try: + st = _os.statvfs(self._path) + return st.f_frsize * st.f_bfree + except OSError: + return 0 + + def toString(self): + return f"{self.name()} ({self.type()})" + + +# ============================================================ +# FileVisitor / SimpleFileVisitor +# ============================================================ + +class FileVisitor(Stub): + def preVisitDirectory(self, dir, attrs): + return FileVisitResult.CONTINUE + + def postVisitDirectory(self, dir, exc): + return FileVisitResult.CONTINUE + + def visitFile(self, file, attrs): + return FileVisitResult.CONTINUE + + def visitFileFailed(self, file, exc): + return FileVisitResult.CONTINUE + + +class SimpleFileVisitor(FileVisitor): + pass + + +# ============================================================ +# DirectoryStream / Filter +# ============================================================ + +class DirectoryStream(Stub): + def __init__(self, path, filter=None): + super().__init__() + self._path = path + self._filter = filter + + def __iter__(self): + try: + entries = _os.listdir(str(self._path)) + for entry in entries: + p = Path(self._path, entry) + if self._filter is None or self._filter.accept(p): + yield p + except OSError: + raise IOException(f"Failed to list directory: {self._path}") + + def close(self): + pass + + +class DirectoryStreamFilter(Stub): + def accept(self, entry): + raise NotImplementedError + + +# ============================================================ +# PathMatcher +# ============================================================ + +class PathMatcher(Stub): + def __init__(self, pattern): + super().__init__() + self._pattern = pattern + + def matches(self, path): + import fnmatch + return fnmatch.fnmatch(str(path), self._pattern) + + +# ============================================================ +# WatchService / WatchKey / WatchEvent / Watchable (stubs) +# ============================================================ + +class Watchable(Stub): + def register(self, watcher, events, *modifiers): + raise AndroidOnlyError("WatchService") + +class WatchService(Stub): + def close(self): + pass + def poll(self): + return None + def take(self): + raise AndroidOnlyError("WatchService.take") + def poll(self, timeout, unit): + return None + +class WatchKey(Stub): + def isValid(self): + return True + def pollEvents(self): + return [] + def reset(self): + return True + def cancel(self): + pass + def watchable(self): + return None + +class WatchEvent(Stub): + class Kind(Stub): + def name(self): + return "" + def type(self): + return None + + def kind(self): + return None + def count(self): + return 0 + def context(self): + return None + + +# ============================================================ +# Files +# ============================================================ + +class Files(Stub): + @staticmethod + def copy(source, target, *options): + src = str(source) + dst = str(target) + replace = any(isinstance(o, StandardCopyOption) and o == StandardCopyOption.REPLACE_EXISTING for o in options) + try: + if replace and _os.path.exists(dst): + _os.remove(dst) + if _os.path.isdir(src): + _shutil.copytree(src, dst) + else: + _shutil.copy2(src, dst) + except OSError as e: + raise IOException(str(e)) + + @staticmethod + def move(source, target, *options): + src = str(source) + dst = str(target) + replace = any(isinstance(o, StandardCopyOption) and o == StandardCopyOption.REPLACE_EXISTING for o in options) + try: + if replace and _os.path.exists(dst): + _os.remove(dst) + _shutil.move(src, dst) + except OSError as e: + raise IOException(str(e)) + + @staticmethod + def delete(path): + try: + p = str(path) + if _os.path.isdir(p): + _os.rmdir(p) + else: + _os.remove(p) + except OSError as e: + raise NoSuchFileException(str(path)) + + @staticmethod + def deleteIfExists(path): + try: + Files.delete(path) + return True + except NoSuchFileException: + return False + + @staticmethod + def createDirectories(path): + _os.makedirs(str(path), exist_ok=True) + return path + + @staticmethod + def createDirectory(path, attrs=None): + _os.makedirs(str(path), exist_ok=True) + return path + + @staticmethod + def createFile(path, attrs=None): + p = str(path) + if _os.path.exists(p): + raise FileAlreadyExistsException(str(path)) + open(p, "a").close() + return path + + @staticmethod + def createTempFile(prefix, suffix, dir=None): + f = _tempfile.NamedTemporaryFile(prefix=prefix, suffix=suffix, + dir=str(dir) if dir else None, delete=False) + p = f.name + f.close() + return Path(p) + + @staticmethod + def createTempDirectory(prefix, attrs=None): + d = _tempfile.mkdtemp(prefix=prefix) + return Path(d) + + @staticmethod + def exists(path, *options): + return _os.path.exists(str(path)) + + @staticmethod + def notExists(path, *options): + return not _os.path.exists(str(path)) + + @staticmethod + def isReadable(path): + return _os.access(str(path), _os.R_OK) + + @staticmethod + def isWritable(path): + return _os.access(str(path), _os.W_OK) + + @staticmethod + def isExecutable(path): + return _os.access(str(path), _os.X_OK) + + @staticmethod + def isDirectory(path, *options): + return _os.path.isdir(str(path)) + + @staticmethod + def isRegularFile(path, *options): + return _os.path.isfile(str(path)) + + @staticmethod + def isSymbolicLink(path): + return _os.path.islink(str(path)) + + @staticmethod + def isHidden(path): + return _os.path.basename(str(path)).startswith(".") + + @staticmethod + def getLastModifiedTime(path, *options): + return int(_os.path.getmtime(str(path)) * 1000) + + @staticmethod + def setLastModifiedTime(path, time): + _os.utime(str(path), (time / 1000, time / 1000)) + + @staticmethod + def getAttribute(path, attribute, *options): + return None + + @staticmethod + def setAttribute(path, attribute, value, *options): + pass + + @staticmethod + def getPosixFilePermissions(path, *options): + return [] + + @staticmethod + def setPosixFilePermissions(path, perms, *options): + pass + + @staticmethod + def newInputStream(path, *options): + from ..io import FileInputStream + return FileInputStream(str(path)) + + @staticmethod + def newOutputStream(path, *options): + from ..io import FileOutputStream + append = any(isinstance(o, StandardOpenOption) and o == StandardOpenOption.APPEND for o in options) + return FileOutputStream(str(path), append) + + @staticmethod + def newBufferedReader(path, charset=None): + from ..io import BufferedReader, InputStreamReader, FileInputStream + inp = FileInputStream(str(path)) + reader = InputStreamReader(inp, charset or "utf-8") + return BufferedReader(reader) + + @staticmethod + def newBufferedWriter(path, charset=None, *options): + from ..io import BufferedWriter, OutputStreamWriter, FileOutputStream + append = any(isinstance(o, StandardOpenOption) and o == StandardOpenOption.APPEND for o in options) + out = FileOutputStream(str(path), append) + writer = OutputStreamWriter(out, charset or "utf-8") + return BufferedWriter(writer) + + @staticmethod + def readAllBytes(path): + with open(str(path), "rb") as f: + return f.read() + + @staticmethod + def readAllLines(path, charset=None): + with open(str(path), "r", encoding=charset or "utf-8") as f: + return f.read().splitlines() + + @staticmethod + def readString(path, charset=None): + with open(str(path), "r", encoding=charset or "utf-8") as f: + return f.read() + + @staticmethod + def write(path, content, *options): + mode = "wb" if isinstance(content, bytes) else "w" + open_mode = mode + if any(isinstance(o, StandardOpenOption) and o == StandardOpenOption.APPEND for o in options): + open_mode = "ab" if mode == "wb" else "a" + with open(str(path), open_mode) as f: + f.write(content) + + @staticmethod + def writeString(path, content, *options): + open_mode = "w" + if any(isinstance(o, StandardOpenOption) and o == StandardOpenOption.APPEND for o in options): + open_mode = "a" + with open(str(path), open_mode, encoding="utf-8") as f: + f.write(content) + + @staticmethod + def list(path): + try: + return [Path(_os.path.join(str(path), entry)) for entry in _os.listdir(str(path))] + except OSError: + raise IOException(f"Failed to list directory: {path}") + + @staticmethod + def walk(path, maxDepth=None): + for root, dirs, files in _os.walk(str(path)): + yield Path(root) + + @staticmethod + def find(start, maxDepth, matcher, *options): + for root, dirs, files in _os.walk(str(start)): + for f in files: + p = Path(_os.path.join(root, f)) + if matcher.matches(p): + yield p + + @staticmethod + def lines(path, charset=None): + with open(str(path), "r", encoding=charset or "utf-8") as f: + for line in f: + yield line.rstrip("\n") + + @staticmethod + def getFileStore(path): + return FileStore(str(path)) + + @staticmethod + def probeContentType(path): + return "application/octet-stream" + + @staticmethod + def getOwner(path, *options): + raise AndroidOnlyError("getOwner") + + @staticmethod + def setOwner(path, owner, *options): + raise AndroidOnlyError("setOwner") \ No newline at end of file diff --git a/android_pyapi/java/security.py b/android_pyapi/java/security.py new file mode 100644 index 0000000..2a7e131 --- /dev/null +++ b/android_pyapi/java/security.py @@ -0,0 +1,1145 @@ +""" +Java security standard library APIs implemented in Python. +java.security package - MessageDigest, SecureRandom, KeyStore, Signature, etc. +""" + +from .._core import Stub, AndroidOnlyError +from .lang import RuntimeException +import hashlib as _hashlib +import os as _os + +GeneralSecurityException = type("GeneralSecurityException", (RuntimeException,), {}) +IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {}) +DigestException = type("DigestException", (GeneralSecurityException,), {}) +InvalidAlgorithmParameterException = type("InvalidAlgorithmParameterException", (GeneralSecurityException,), {}) +InvalidKeyException = type("InvalidKeyException", (GeneralSecurityException,), {}) +InvalidKeySpecException = type("InvalidKeySpecException", (GeneralSecurityException,), {}) +InvalidParameterException = type("InvalidParameterException", (IllegalArgumentException,), {}) +KeyException = type("KeyException", (GeneralSecurityException,), {}) +KeyManagementException = type("KeyManagementException", (KeyException,), {}) +KeyStoreException = type("KeyStoreException", (GeneralSecurityException,), {}) +NoSuchAlgorithmException = type("NoSuchAlgorithmException", (GeneralSecurityException,), {}) +NoSuchProviderException = type("NoSuchProviderException", (GeneralSecurityException,), {}) +ProviderException = type("ProviderException", (RuntimeException,), {}) +SignatureException = type("SignatureException", (GeneralSecurityException,), {}) + +__all__ = [ + "MessageDigest", "MessageDigestSpi", + "SecureRandom", "SecureRandomSpi", + "KeyStore", "KeyStoreSpi", + "Key", "PrivateKey", "PublicKey", "KeyPair", "KeyPairGenerator", + "KeyPairGeneratorSpi", "KeyFactory", "KeyFactorySpi", + "KeySpec", "SecretKeySpec", + "RSAPublicKeySpec", "RSAPrivateKeySpec", + "PKCS8EncodedKeySpec", "X509EncodedKeySpec", + "AlgorithmParameters", "AlgorithmParameterGenerator", + "AlgorithmParameterGeneratorSpi", "AlgorithmParametersSpi", + "Provider", "Security", + "DigestInputStream", "DigestOutputStream", + "Signature", "SignatureSpi", + "CodeSigner", "CodeSource", "Policy", "Permission", + "AllPermission", "BasicPermission", "PermissionCollection", + "Principal", + "CertPath", "CertPathBuilder", "CertPathBuilderSpi", + "CertPathValidator", "CertPathValidatorSpi", + "CertificateFactory", "CertificateFactorySpi", + "CertStore", "CertStoreSpi", + "CRL", "X509CRL", "X509Certificate", "X509Extension", + "Guard", "GuardedObject", "Identity", "IdentityScope", "Signer", + "Timestamp", "UnresolvedPermission", + "GeneralSecurityException", "DigestException", + "InvalidAlgorithmParameterException", "InvalidKeyException", + "InvalidKeySpecException", "InvalidParameterException", + "KeyException", "KeyManagementException", "KeyStoreException", + "NoSuchAlgorithmException", "NoSuchProviderException", + "ProviderException", "SignatureException", +] + + +# ============================================================ +# Key interfaces +# ============================================================ + +class Key(Stub): + def getAlgorithm(self): + return "" + + def getFormat(self): + return "" + + def getEncoded(self): + return b"" + + +class PrivateKey(Key): + pass + + +class PublicKey(Key): + pass + + +# ============================================================ +# KeySpec / SecretKeySpec / RSA specs / EncodedKeySpecs +# ============================================================ + +class KeySpec(Stub): + pass + + +class SecretKeySpec(KeySpec, Key): + def __init__(self, key_bytes, algorithm): + super().__init__() + self._key = key_bytes + self._algorithm = algorithm + + def getAlgorithm(self): + return self._algorithm + + def getFormat(self): + return "RAW" + + def getEncoded(self): + return self._key + + def hashCode(self): + return hash(self._key) ^ hash(self._algorithm) + + +class RSAPublicKeySpec(KeySpec): + def __init__(self, modulus, public_exponent): + super().__init__() + self._modulus = modulus + self._public_exponent = public_exponent + + def getModulus(self): + return self._modulus + + def getPublicExponent(self): + return self._public_exponent + + +class RSAPrivateKeySpec(KeySpec): + def __init__(self, modulus, private_exponent): + super().__init__() + self._modulus = modulus + self._private_exponent = private_exponent + + def getModulus(self): + return self._modulus + + def getPrivateExponent(self): + return self._private_exponent + + +class PKCS8EncodedKeySpec(KeySpec): + def __init__(self, encoded_key): + super().__init__() + self._encoded_key = encoded_key + + def getEncoded(self): + return self._encoded_key + + def getFormat(self): + return "PKCS#8" + + +class X509EncodedKeySpec(KeySpec): + def __init__(self, encoded_key): + super().__init__() + self._encoded_key = encoded_key + + def getEncoded(self): + return self._encoded_key + + def getFormat(self): + return "X.509" + + +# ============================================================ +# KeyPair +# ============================================================ + +class KeyPair(Stub): + def __init__(self, public_key, private_key): + super().__init__() + self._public = public_key + self._private = private_key + + def getPublic(self): + return self._public + + def getPrivate(self): + return self._private + + +# ============================================================ +# KeyPairGenerator +# ============================================================ + +class KeyPairGenerator(Stub): + def __init__(self, algorithm): + super().__init__() + self._algorithm = algorithm + self._keysize = 2048 + + @staticmethod + def getInstance(algorithm, provider=None): + return KeyPairGenerator(algorithm) + + def initialize(self, keysize_or_spec, random=None): + if isinstance(keysize_or_spec, int): + self._keysize = keysize_or_spec + + def generateKeyPair(self): + return KeyPair(PublicKey(), PrivateKey()) + + def getAlgorithm(self): + return self._algorithm + + def getProvider(self): + return Provider("SUN", 1.0, "Default provider") + + +# ============================================================ +# KeyFactory +# ============================================================ + +class KeyFactory(Stub): + def __init__(self, algorithm): + super().__init__() + self._algorithm = algorithm + + @staticmethod + def getInstance(algorithm, provider=None): + return KeyFactory(algorithm) + + def generatePublic(self, key_spec): + return PublicKey() + + def generatePrivate(self, key_spec): + return PrivateKey() + + def getKeySpec(self, key, key_spec_cls): + if key_spec_cls == X509EncodedKeySpec: + return X509EncodedKeySpec(key.getEncoded()) + raise InvalidKeySpecException("Unsupported key spec") + + def translateKey(self, key): + return key + + def getAlgorithm(self): + return self._algorithm + + +# ============================================================ +# KeyFactorySpi / KeyPairGeneratorSpi (stubs) +# ============================================================ + +class KeyFactorySpi(Stub): + pass + +class KeyPairGeneratorSpi(Stub): + pass + + +# ============================================================ +# MessageDigest +# ============================================================ + +class MessageDigest(Stub): + _MD_MAP = { + "MD5": "md5", + "SHA-1": "sha1", + "SHA": "sha1", + "SHA-224": "sha224", + "SHA-256": "sha256", + "SHA-384": "sha384", + "SHA-512": "sha512", + } + + def __init__(self, algorithm): + super().__init__() + self._algorithm = algorithm + algo_lower = algorithm.replace("-", "").lower() + if algo_lower in ("md5", "sha1", "sha224", "sha256", "sha384", "sha512"): + self._impl = _hashlib.new(algo_lower) + else: + self._impl = _hashlib.new("sha256") + + @staticmethod + def getInstance(algorithm, provider=None): + if algorithm not in MessageDigest._MD_MAP: + raise NoSuchAlgorithmException(f"{algorithm} not available") + return MessageDigest(algorithm) + + def update(self, data, offset=0, length=-1): + if length < 0: + self._impl.update(data) + else: + self._impl.update(data[offset:offset+length]) + + def digest(self, data=None): + if data is not None: + self._impl.update(data) + return self._impl.digest() + + def toString(self): + return f"MessageDigest: {self._algorithm}" + + def getAlgorithm(self): + return self._algorithm + + def getProvider(self): + return Provider("SUN", 1.0, "Default provider") + + def getDigestLength(self): + return self._impl.digest_size + + @staticmethod + def isEqual(digest_a, digest_b): + return digest_a == digest_b + + def clone(self): + md = MessageDigest(self._algorithm) + md._impl = self._impl.copy() + return md + + def reset(self): + self._impl = _hashlib.new(self._algorithm.replace("-", "").lower()) + + +class MessageDigestSpi(Stub): + pass + + +# ============================================================ +# SecureRandom +# ============================================================ + +class SecureRandom(Stub): + def __init__(self, seed=None): + super().__init__() + import random as _random + self._random = _random.Random() + if seed is not None: + self._random.seed(seed) + + def nextBytes(self, bytes_arr): + data = _os.urandom(len(bytes_arr)) + for i in range(len(bytes_arr)): + bytes_arr[i] = data[i] + + def nextInt(self, bound=None): + if bound is None: + return int.from_bytes(_os.urandom(4), "big") + return int.from_bytes(_os.urandom(4), "big") % bound + + def nextLong(self): + return int.from_bytes(_os.urandom(8), "big") + + def nextBoolean(self): + return int.from_bytes(_os.urandom(1), "big") % 2 == 0 + + def nextFloat(self): + return int.from_bytes(_os.urandom(4), "big") / 4294967296.0 + + def nextDouble(self): + return int.from_bytes(_os.urandom(8), "big") / 18446744073709551616.0 + + def nextGaussian(self): + import random as _random + return _random.gauss(0, 1) + + def generateSeed(self, num_bytes): + return _os.urandom(num_bytes) + + def getAlgorithm(self): + return "SHA1PRNG" + + def getProvider(self): + return Provider("SUN", 1.0, "Default provider") + + def setSeed(self, seed): + self._random.seed(seed) + + def getSeed(self, num_bytes): + return _os.urandom(num_bytes) + + +class SecureRandomSpi(Stub): + pass + + +# ============================================================ +# Provider / Security +# ============================================================ + +class Provider(Stub): + def __init__(self, name, version, info): + super().__init__() + self._name = name + self._version = version + self._info = info + self._properties = {} + + def getName(self): + return self._name + + def getVersion(self): + return self._version + + def getInfo(self): + return self._info + + def getProperty(self, key): + return self._properties.get(key) + + def setProperty(self, key, value): + self._properties[key] = value + + def toString(self): + return f"{self._name} v{self._version}" + + +class Security(Stub): + _providers = [Provider("SUN", 1.0, "SUN provider")] + + @staticmethod + def getProvider(name): + for p in Security._providers: + if p.getName() == name: + return p + return None + + @staticmethod + def getProviders(): + return Security._providers + + @staticmethod + def addProvider(provider): + Security._providers.append(provider) + return len(Security._providers) - 1 + + @staticmethod + def removeProvider(name): + for i, p in enumerate(Security._providers): + if p.getName() == name: + Security._providers.pop(i) + return + + @staticmethod + def getAlgorithms(service_name): + if service_name == "MessageDigest": + return list(MessageDigest._MD_MAP.keys()) + return [] + + +# ============================================================ +# DigestInputStream / DigestOutputStream +# ============================================================ + +class DigestInputStream(Stub): + def __init__(self, stream, digest): + super().__init__() + self._stream = stream + self._digest = digest + + def getMessageDigest(self): + return self._digest + + def setMessageDigest(self, digest): + self._digest = digest + + def read(self, b=None, off=0, length=0): + if b is None: + data = self._stream.read() + else: + data = self._stream.read(length) + if data: + self._digest.update(data) + return data + + def toString(self): + return f"DigestInputStream: {self._digest}" + + +class DigestOutputStream(Stub): + def __init__(self, stream, digest): + super().__init__() + self._stream = stream + self._digest = digest + + def getMessageDigest(self): + return self._digest + + def setMessageDigest(self, digest): + self._digest = digest + + def write(self, b, off=0, length=0): + if isinstance(b, (bytes, bytearray)): + data = b if length == 0 else b[off:off+length] + else: + data = bytes([b]) + self._digest.update(data) + self._stream.write(data) + + def toString(self): + return f"DigestOutputStream: {self._digest}" + + +# ============================================================ +# Signature +# ============================================================ + +class Signature(Stub): + def __init__(self, algorithm): + super().__init__() + self._algorithm = algorithm + self._state = "UNINITIALIZED" + self._impl = _hashlib.new("sha256") + + @staticmethod + def getInstance(algorithm, provider=None): + return Signature(algorithm) + + def initSign(self, private_key, random=None): + self._state = "SIGN" + + def initVerify(self, public_key): + self._state = "VERIFY" + + def update(self, data, off=0, length=-1): + if length < 0: + self._impl.update(data) + else: + self._impl.update(data[off:off+length]) + + def sign(self): + self._state = "UNINITIALIZED" + return self._impl.digest() + + def verify(self, signature): + self._state = "UNINITIALIZED" + return self._impl.digest() == signature + + def setParameter(self, param, value=None): + pass + + def getParameters(self): + return None + + def getAlgorithm(self): + return self._algorithm + + def getProvider(self): + return Provider("SUN", 1.0, "SUN provider") + + +class SignatureSpi(Stub): + pass + + +# ============================================================ +# KeyStore +# ============================================================ + +class KeyStore(Stub): + class PasswordProtection(Stub): + def __init__(self, password): + super().__init__() + self._password = password + + def getPassword(self): + return self._password + + class Entry(Stub): + pass + + class PrivateKeyEntry(Entry): + def __init__(self, private_key, cert_chain): + super().__init__() + self._private_key = private_key + self._cert_chain = cert_chain + + def getPrivateKey(self): + return self._private_key + + def getCertificateChain(self): + return self._cert_chain + + class SecretKeyEntry(Entry): + def __init__(self, secret_key): + super().__init__() + self._secret_key = secret_key + + def getSecretKey(self): + return self._secret_key + + class TrustedCertificateEntry(Entry): + def __init__(self, cert): + super().__init__() + self._cert = cert + + def getTrustedCertificate(self): + return self._cert + + def __init__(self, type_name="JKS"): + super().__init__() + self._type = type_name + self._entries = {} + self._loaded = False + + @staticmethod + def getInstance(type_name, provider=None): + return KeyStore(type_name) + + def load(self, stream=None, password=None): + self._loaded = True + + def store(self, stream, password): + pass + + def setKeyEntry(self, alias, key, password, chain): + self._entries[alias] = (key, chain) + + def setCertificateEntry(self, alias, cert): + self._entries[alias] = cert + + def getKey(self, alias, password): + entry = self._entries.get(alias) + if isinstance(entry, tuple): + return entry[0] + return None + + def getCertificate(self, alias): + entry = self._entries.get(alias) + if isinstance(entry, tuple): + return entry[1][0] if entry[1] else None + return entry + + def getCertificateChain(self, alias): + entry = self._entries.get(alias) + if isinstance(entry, tuple): + return entry[1] + return None + + def getCertificateAliases(self, cert): + return [] + + def aliases(self): + return list(self._entries.keys()) + + def containsAlias(self, alias): + return alias in self._entries + + def deleteEntry(self, alias): + if alias in self._entries: + del self._entries[alias] + + def size(self): + return len(self._entries) + + def isCertificateEntry(self, alias): + return alias in self._entries and not isinstance(self._entries[alias], tuple) + + def isKeyEntry(self, alias): + return alias in self._entries and isinstance(self._entries[alias], tuple) + + def getType(self): + return self._type + + def getProvider(self): + return Provider("SUN", 1.0, "SUN provider") + + def getCreationDate(self, alias): + from datetime import datetime + return datetime.now() + + +class KeyStoreSpi(Stub): + pass + + +# ============================================================ +# X509Certificate +# ============================================================ + +class X509Certificate(Stub): + def __init__(self): + super().__init__() + self._encoded = b"" + + def getSubjectX500Principal(self): + return Principal() + + def getIssuerX500Principal(self): + return Principal() + + def getSerialNumber(self): + return 0 + + def getNotBefore(self): + from datetime import datetime + return datetime.now() + + def getNotAfter(self): + from datetime import datetime + return datetime.now() + + def getSigAlgName(self): + return "SHA256withRSA" + + def getSigAlgOID(self): + return "1.2.840.113549.1.1.11" + + def getVersion(self): + return 3 + + def getPublicKey(self): + return PublicKey() + + def getEncoded(self): + return self._encoded + + def verify(self, key): + return True + + def checkValidity(self, date=None): + return True + + def toString(self): + return "X509Certificate" + + +# ============================================================ +# AlgorithmParameters / AlgorithmParameterGenerator (stubs) +# ============================================================ + +class AlgorithmParameters(Stub): + def __init__(self, algorithm): + super().__init__() + self._algorithm = algorithm + + @staticmethod + def getInstance(algorithm, provider=None): + return AlgorithmParameters(algorithm) + + def init(self, params, format=None): + pass + + def getEncoded(self, format=None): + return b"" + + def getAlgorithm(self): + return self._algorithm + + def getProvider(self): + return Provider("SUN", 1.0, "SUN provider") + + def toString(self): + return f"{self._algorithm} parameters" + + +class AlgorithmParametersSpi(Stub): + pass + + +class AlgorithmParameterGenerator(Stub): + @staticmethod + def getInstance(algorithm, provider=None): + return AlgorithmParameterGenerator() + + def init(self, size_or_genparam, random=None): + pass + + def generateParameters(self): + return AlgorithmParameters("DSA") + + +class AlgorithmParameterGeneratorSpi(Stub): + pass + + +# ============================================================ +# Permission / AllPermission / BasicPermission (stubs) +# ============================================================ + +class Permission(Stub): + def __init__(self, name): + super().__init__() + self._name = name + + def getName(self): + return self._name + + def getActions(self): + return "" + + def implies(self, permission): + return True + + def equals(self, obj): + return isinstance(obj, Permission) and self._name == obj._name + + def hashCode(self): + return hash(self._name) + + def toString(self): + return f"({self.__class__.__name__} {self._name})" + + +class AllPermission(Permission): + def __init__(self): + super().__init__("") + + +class BasicPermission(Permission): + def __init__(self, name, actions=None): + super().__init__(name) + + +class PermissionCollection(Stub): + def __init__(self): + super().__init__() + self._permissions = [] + + def add(self, permission): + self._permissions.append(permission) + + def implies(self, permission): + return True + + def elements(self): + return iter(self._permissions) + + def toString(self): + return str(self._permissions) + + +class UnresolvedPermission(Permission): + def __init__(self, type_name, name, actions, certs): + super().__init__(name) + self._unresolved_type = type_name + self._unresolved_actions = actions + self._certs = certs + + def getUnresolvedType(self): + return self._unresolved_type + + def getUnresolvedActions(self): + return self._unresolved_actions + + def getUnresolvedCerts(self): + return self._certs + + +# ============================================================ +# Principal / CodeSource / Policy (stubs) +# ============================================================ + +class Principal(Stub): + def __init__(self, name=""): + super().__init__() + self._name = name + + def getName(self): + return self._name + + def toString(self): + return self._name + + def equals(self, other): + return isinstance(other, Principal) and self._name == other._name + + def hashCode(self): + return hash(self._name) + + +class CodeSource(Stub): + def __init__(self, location, certs): + super().__init__() + self._location = location + + def getLocation(self): + return self._location + + def getCertificates(self): + return [] + + def implies(self, codesource): + return True + + +class Policy(Stub): + _policy = None + + @staticmethod + def getPolicy(): + if Policy._policy is None: + Policy._policy = Policy() + return Policy._policy + + @staticmethod + def setPolicy(policy): + Policy._policy = policy + + def getPermissions(self, codesource): + return PermissionCollection() + + def implies(self, cs, perm): + return True + + def refresh(self): + pass + + +# ============================================================ +# CertPath / CertPathBuilder / CertPathValidator (stubs) +# ============================================================ + +class CertPath(Stub): + def __init__(self, algorithm): + super().__init__() + self._algorithm = algorithm + self._certs = [] + + def getCertificates(self): + return self._certs + + def getType(self): + return self._algorithm + + def getEncoded(self): + return b"" + + def toString(self): + return f"CertPath: {self._algorithm}" + + +class CertPathBuilder(Stub): + @staticmethod + def getInstance(algorithm, provider=None): + return CertPathBuilder() + + def build(self, params): + return CertPath("X.509") + + +class CertPathBuilderSpi(Stub): + pass + + +class CertPathValidator(Stub): + @staticmethod + def getInstance(algorithm, provider=None): + return CertPathValidator() + + def validate(self, cert_path, params): + return None + + +class CertPathValidatorSpi(Stub): + pass + + +class CertificateFactory(Stub): + @staticmethod + def getInstance(algorithm, provider=None): + return CertificateFactory() + + def generateCertificate(self, in_stream): + return X509Certificate() + + def generateCertPath(self, in_stream): + return CertPath("X.509") + + def getCertPathEncodings(self): + return ["PKCS7"] + + +class CertificateFactorySpi(Stub): + pass + + +class CertStore(Stub): + @staticmethod + def getInstance(type_name, params, provider=None): + return CertStore() + + def getCertificates(self, selector): + return [] + + def getCRLs(self, selector): + return [] + + +class CertStoreSpi(Stub): + pass + + +# ============================================================ +# CRL / X509CRL (stubs) +# ============================================================ + +class CRL(Stub): + def __init__(self): + super().__init__() + + def isRevoked(self, cert): + return False + + def toString(self): + return "CRL" + + +class X509CRL(CRL): + def __init__(self): + super().__init__() + + def getEncoded(self): + return b"" + + def verify(self, key): + return True + + def getIssuerX500Principal(self): + return Principal() + + def toString(self): + return "X509CRL" + + +class X509Extension(Stub): + pass + + +# ============================================================ +# Guard / GuardedObject (stubs) +# ============================================================ + +class Guard(Stub): + def checkGuard(self, object): + pass + + +class GuardedObject(Stub): + def __init__(self, object, guard): + super().__init__() + self._object = object + + def getObject(self): + return self._object + + +# ============================================================ +# Identity / IdentityScope / Signer (stubs) +# ============================================================ + +class Identity(Stub): + def __init__(self, name, scope=None): + super().__init__() + self._name = name + + def getName(self): + return self._name + + def getPublicKey(self): + return PublicKey() + + def setPublicKey(self, key): + pass + + def toString(self): + return self._name + + def getScope(self): + return None + + +class IdentityScope(Identity): + def __init__(self, name): + super().__init__(name) + + def getIdentity(self, name): + return None + + def addIdentity(self, identity): + pass + + def removeIdentity(self, identity): + pass + + def identities(self): + return [] + + @staticmethod + def getSystemScope(): + return None + + def size(self): + return 0 + + def toString(self): + return self._name + + +class Signer(Identity): + def __init__(self, name): + super().__init__(name) + + def getPrivateKey(self): + return PrivateKey() + + def setKeyPair(self, pair): + pass + + def toString(self): + return self._name + + +# ============================================================ +# CodeSigner / Timestamp (stubs) +# ============================================================ + +class Timestamp(Stub): + def __init__(self, timestamp, signer_cert_path): + super().__init__() + self._timestamp = timestamp + + def getTimestamp(self): + return self._timestamp + + def getSignerCertPath(self): + return CertPath("X.509") + + def equals(self, other): + return isinstance(other, Timestamp) + + def hashCode(self): + return 0 + + def toString(self): + return "Timestamp" + + +class CodeSigner(Stub): + def __init__(self, signer_cert_path, timestamp): + super().__init__() + self._signer_cert_path = signer_cert_path + self._timestamp = timestamp + + def getSignerCertPath(self): + return self._signer_cert_path + + def getTimestamp(self): + return self._timestamp + + def equals(self, other): + return isinstance(other, CodeSigner) + + def hashCode(self): + return 0 + + def toString(self): + return "CodeSigner" \ No newline at end of file diff --git a/android_pyapi/java/text.py b/android_pyapi/java/text.py new file mode 100644 index 0000000..3e36ffa --- /dev/null +++ b/android_pyapi/java/text.py @@ -0,0 +1,1041 @@ +""" +Java text standard library APIs implemented in Python. +java.text package - DateFormat, SimpleDateFormat, DecimalFormat, NumberFormat, etc. +""" + +from .._core import Stub +from .lang import RuntimeException +import datetime as _datetime +import time as _time +import re as _re +import math as _py_math +import locale as _locale +from decimal import Decimal as _Decimal + +IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {}) + +__all__ = [ + "SimpleDateFormat", "DateFormat", "DateFormatSymbols", + "DecimalFormat", "DecimalFormatSymbols", "NumberFormat", + "ChoiceFormat", "MessageFormat", "FieldPosition", "ParsePosition", + "ParseException", "Normalizer", + "StringCharacterIterator", "CharacterIterator", + "BreakIterator", "Collator", "CollationKey", "RuleBasedCollator", + "Annotation", "AttributedCharacterIterator", "AttributedString", + "Bidi", "Format", +] + + +# ============================================================ +# ParseException +# ============================================================ + +class ParseException(Exception): + def __init__(self, s, error_offset): + super().__init__(s) + self._error_offset = error_offset + + def getErrorOffset(self): + return self._error_offset + + +# ============================================================ +# ParsePosition +# ============================================================ + +class ParsePosition(Stub): + def __init__(self, index): + super().__init__() + self._index = index + self._error_index = -1 + + def getIndex(self): + return self._index + + def setIndex(self, index): + self._index = index + + def getErrorIndex(self): + return self._error_index + + def setErrorIndex(self, ei): + self._error_index = ei + + +# ============================================================ +# FieldPosition +# ============================================================ + +class FieldPosition(Stub): + def __init__(self, field): + super().__init__() + self._field = field + self._begin = 0 + self._end = 0 + + def getField(self): + return self._field + + def getBeginIndex(self): + return self._begin + + def getEndIndex(self): + return self._end + + def setBeginIndex(self, bi): + self._begin = bi + + def setEndIndex(self, ei): + self._end = ei + + +# ============================================================ +# Format (base) +# ============================================================ + +class Format(Stub): + def format(self, obj, to_append_to=None, pos=None): + raise NotImplementedError + + def parseObject(self, source, pos=None): + raise NotImplementedError + + +# ============================================================ +# DateFormat +# ============================================================ + +class DateFormat(Format): + SHORT = 3 + MEDIUM = 2 + LONG = 1 + FULL = 0 + DEFAULT = 2 + + def __init__(self): + super().__init__() + self._calendar = None + self._number_format = None + self._lenient = False + self._timezone = None + + @staticmethod + def getDateInstance(style=2, locale=None): + return SimpleDateFormat("yyyy-MM-dd") + + @staticmethod + def getTimeInstance(style=2, locale=None): + return SimpleDateFormat("HH:mm:ss") + + @staticmethod + def getDateTimeInstance(date_style=2, time_style=2, locale=None): + return SimpleDateFormat("yyyy-MM-dd HH:mm:ss") + + @staticmethod + def getInstance(): + return SimpleDateFormat("yyyy-MM-dd HH:mm:ss") + + def format(self, date, to_append_to=None, pos=None): + raise NotImplementedError + + def parse(self, source, pos=None): + raise NotImplementedError + + def setLenient(self, lenient): + self._lenient = lenient + + def isLenient(self): + return self._lenient + + def getCalendar(self): + return self._calendar + + def setCalendar(self, cal): + self._calendar = cal + + def getNumberFormat(self): + return self._number_format + + def setNumberFormat(self, nf): + self._number_format = nf + + def getTimeZone(self): + return self._timezone + + def setTimeZone(self, tz): + self._timezone = tz + + +# ============================================================ +# DateFormatSymbols +# ============================================================ + +class DateFormatSymbols(Stub): + def __init__(self, locale=None): + super().__init__() + self._months = [ + "January", "February", "March", "April", "May", "June", + "July", "August", "September", "October", "November", "December", + ] + self._short_months = [ + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", + ] + self._weekdays = [ + "", "Sunday", "Monday", "Tuesday", "Wednesday", + "Thursday", "Friday", "Saturday", + ] + self._short_weekdays = [ + "", "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", + ] + self._ampm = ["AM", "PM"] + self._eras = ["BC", "AD"] + self._zone_strings = [] + self._local_pattern_chars = "GyMdkHmsSEDFwWahKzZ" + + def getMonths(self): + return self._months + + def setMonths(self, months): + self._months = months + + def getShortMonths(self): + return self._short_months + + def setShortMonths(self, months): + self._short_months = months + + def getWeekdays(self): + return self._weekdays + + def setWeekdays(self, wd): + self._weekdays = wd + + def getShortWeekdays(self): + return self._short_weekdays + + def setShortWeekdays(self, wd): + self._short_weekdays = wd + + def getAmPmStrings(self): + return self._ampm + + def setAmPmStrings(self, ap): + self._ampm = ap + + def getZoneStrings(self): + return self._zone_strings + + def setZoneStrings(self, zs): + self._zone_strings = zs + + def getLocalPatternChars(self): + return self._local_pattern_chars + + def setLocalPatternChars(self, chars): + self._local_pattern_chars = chars + + def getEras(self): + return self._eras + + def setEras(self, eras): + self._eras = eras + + +# ============================================================ +# SimpleDateFormat +# ============================================================ + +_JAVA_TO_PYTHON_FORMAT = { + "yyyy": "%Y", "yy": "%y", + "MM": "%m", + "dd": "%d", + "HH": "%H", + "mm": "%M", + "ss": "%S", + "SSS": "%f", + "a": "%p", + "EEE": "%a", "EEEE": "%A", + "D": "%j", + "zzz": "%Z", "z": "%Z", + "Z": "%z", +} + +class SimpleDateFormat(DateFormat): + def __init__(self, pattern, locale=None): + super().__init__() + self._pattern = pattern + self._locale = locale + self._dfs = DateFormatSymbols(locale) + self._lenient = False + + def applyPattern(self, pattern): + self._pattern = pattern + + def toPattern(self): + return self._pattern + + def toLocalizedPattern(self): + return self._pattern + + def applyLocalizedPattern(self, pattern): + self._pattern = pattern + + def _java_to_py(self, pattern): + py_pattern = pattern + sorted_keys = sorted(_JAVA_TO_PYTHON_FORMAT.keys(), key=lambda x: -len(x)) + for java_fmt in sorted_keys: + py_fmt = _JAVA_TO_PYTHON_FORMAT[java_fmt] + py_pattern = py_pattern.replace(java_fmt, py_fmt) + py_pattern = py_pattern.replace("'", "") + return py_pattern + + def _to_datetime(self, date): + if isinstance(date, _datetime.datetime): + return date + if isinstance(date, _datetime.date): + return _datetime.datetime.combine(date, _datetime.time()) + try: + ts = date.getTime() / 1000.0 + return _datetime.datetime.fromtimestamp(ts) + except AttributeError: + return _datetime.datetime.now() + + def format(self, date, to_append_to=None, pos=None): + py_pattern = self._java_to_py(self._pattern) + dt = self._to_datetime(date) + result = dt.strftime(py_pattern) + if to_append_to is not None: + sb = str(to_append_to) + idx = len(sb) + to_append_to.append(result) + if pos is not None: + pos.setBeginIndex(idx) + pos.setEndIndex(idx + len(result)) + return to_append_to + return result + + def parse(self, source, pos=None): + py_pattern = self._java_to_py(self._pattern) + try: + dt = _datetime.datetime.strptime(source, py_pattern) + if pos is not None: + pos.setIndex(len(source)) + return dt + except ValueError: + if pos is not None: + pos.setErrorIndex(0) + raise ParseException(f"Unparseable date: {source}", 0) + + def setLenient(self, lenient): + self._lenient = lenient + + def isLenient(self): + return self._lenient + + def setTimeZone(self, tz): + self._timezone = tz + + def getTimeZone(self): + return self._timezone + + def setCalendar(self, cal): + self._calendar = cal + + def getCalendar(self): + return self._calendar + + def setNumberFormat(self, nf): + self._number_format = nf + + def getNumberFormat(self): + return self._number_format + + def getDateFormatSymbols(self): + return self._dfs + + def setDateFormatSymbols(self, dfs): + self._dfs = dfs + + +# ============================================================ +# DecimalFormatSymbols +# ============================================================ + +class DecimalFormatSymbols(Stub): + def __init__(self, locale=None): + super().__init__() + self._decimal_sep = "." + self._grouping_sep = "," + self._pattern_sep = ";" + self._minus_sign = "-" + self._infinity = "\u221e" + self._nan = "NaN" + self._percent = "%" + self._per_mill = "\u2030" + self._zero_digit = "0" + self._digit = "#" + self._exponential_sep = "E" + self._monetary_decimal_sep = "." + self._intl_currency_symbol = "USD" + self._currency = "USD" + + def getDecimalSeparator(self): return self._decimal_sep + def setDecimalSeparator(self, c): self._decimal_sep = c + def getGroupingSeparator(self): return self._grouping_sep + def setGroupingSeparator(self, c): self._grouping_sep = c + def getPatternSeparator(self): return self._pattern_sep + def setPatternSeparator(self, c): self._pattern_sep = c + def getMinusSign(self): return self._minus_sign + def setMinusSign(self, c): self._minus_sign = c + def getInfinity(self): return self._infinity + def setInfinity(self, s): self._infinity = s + def getNaN(self): return self._nan + def setNaN(self, s): self._nan = s + def getPercent(self): return self._percent + def setPercent(self, c): self._percent = c + def getPerMill(self): return self._per_mill + def setPerMill(self, c): self._per_mill = c + def getZeroDigit(self): return self._zero_digit + def setZeroDigit(self, c): self._zero_digit = c + def getDigit(self): return self._digit + def setDigit(self, c): self._digit = c + def getExponentialSeparator(self): return self._exponential_sep + def setExponentialSeparator(self, s): self._exponential_sep = s + def getMonetaryDecimalSeparator(self): return self._monetary_decimal_sep + def setMonetaryDecimalSeparator(self, c): self._monetary_decimal_sep = c + def getInternationalCurrencySymbol(self): return self._intl_currency_symbol + def setInternationalCurrencySymbol(self, s): self._intl_currency_symbol = s + def getCurrency(self): return self._currency + def setCurrency(self, c): self._currency = c + + +# ============================================================ +# DecimalFormat +# ============================================================ + +class NumberFormat(Format): + def __init__(self): + super().__init__() + self._grouping_used = True + self._max_int_digits = 2000000000 + self._min_int_digits = 1 + self._max_frac_digits = 3 + self._min_frac_digits = 0 + self._parse_integer_only = False + self._rounding_mode = 4 + + @staticmethod + def getInstance(locale=None): + return DecimalFormat("#,##0.###") + + @staticmethod + def getNumberInstance(locale=None): + return DecimalFormat("#,##0.###") + + @staticmethod + def getCurrencyInstance(locale=None): + return DecimalFormat("#,##0.00") + + @staticmethod + def getPercentInstance(locale=None): + return DecimalFormat("#,##0%") + + @staticmethod + def getIntegerInstance(locale=None): + nf = DecimalFormat("#,##0") + nf.setMaximumFractionDigits(0) + return nf + + @staticmethod + def getCompactNumberInstance(locale=None, style=None): + return DecimalFormat("#,##0") + + def format(self, number, to_append_to=None, pos=None): + raise NotImplementedError + + def parse(self, source, pos=None): + raise NotImplementedError + + def isGroupingUsed(self): return self._grouping_used + def setGroupingUsed(self, v): self._grouping_used = v + def getMaximumIntegerDigits(self): return self._max_int_digits + def setMaximumIntegerDigits(self, v): self._max_int_digits = v + def getMinimumIntegerDigits(self): return self._min_int_digits + def setMinimumIntegerDigits(self, v): self._min_int_digits = v + def getMaximumFractionDigits(self): return self._max_frac_digits + def setMaximumFractionDigits(self, v): self._max_frac_digits = v + def getMinimumFractionDigits(self): return self._min_frac_digits + def setMinimumFractionDigits(self, v): self._min_frac_digits = v + def setParseIntegerOnly(self, v): self._parse_integer_only = v + def isParseIntegerOnly(self): return self._parse_integer_only + def setRoundingMode(self, v): self._rounding_mode = v + def getRoundingMode(self): return self._rounding_mode + def getCurrency(self): return "USD" + def setCurrency(self, c): pass + + @staticmethod + def getAvailableLocales(): + return list(_locale.locale_alias.keys()) + + +# ============================================================ +# ChoiceFormat +# ============================================================ + +class ChoiceFormat(NumberFormat): + def __init__(self, formats=None, limits=None): + super().__init__() + self._formats = formats if formats is not None else [] + self._limits = limits if limits is not None else [] + + def format(self, number, to_append_to=None, pos=None): + val = float(number) + idx = 0 + for i, lim in enumerate(self._limits): + if val >= lim: + idx = i + result = str(self._formats[idx]) if idx < len(self._formats) else "" + if to_append_to is not None: + sb = str(to_append_to) + idx2 = len(sb) + to_append_to.append(result) + if pos is not None: + pos.setBeginIndex(idx2) + pos.setEndIndex(idx2 + len(result)) + return to_append_to + return result + + def parse(self, source, pos=None): + raise NotImplementedError + + @staticmethod + def nextDouble(d, upwards=True): + if upwards: + return d + _py_math.ulp(d) + return d - _py_math.ulp(d) + + @staticmethod + def previousDouble(d): + return ChoiceFormat.nextDouble(d, False) + + def getLimits(self): + return self._limits + + def getFormats(self): + return self._formats + + +# ============================================================ +# MessageFormat +# ============================================================ +# NumberFormat +# ============================================================ + +# ============================================================ +# DecimalFormat +# ============================================================ + +class DecimalFormat(NumberFormat): + def __init__(self, pattern=None, symbols=None): + super().__init__() + self._pattern = pattern or "#,##0.###" + self._symbols = symbols or DecimalFormatSymbols() + self._decimal_sep_always = False + self._grouping_size = 3 + self._grouping_used = True + self._max_int_digits = 2000000000 + self._min_int_digits = 1 + self._max_frac_digits = 2000000000 + self._min_frac_digits = 0 + self._neg_prefix = "-" + self._neg_suffix = "" + self._pos_prefix = "" + self._pos_suffix = "" + self._multiplier = 1 + self._rounding_mode = 4 + self._parse_bigdecimal = False + + def applyPattern(self, pattern): + self._pattern = pattern + + def toPattern(self): + return self._pattern + + def toLocalizedPattern(self): + return self._pattern + + def applyLocalizedPattern(self, pattern): + self._pattern = pattern + + def format(self, number, to_append_to=None, pos=None): + if isinstance(number, (int, float)): + val = number * self._multiplier + elif isinstance(number, _Decimal): + val = float(str(number)) * self._multiplier + else: + val = float(str(number)) * self._multiplier + if self._grouping_used and self._grouping_size > 0: + result = f"{val:,.{self._max_frac_digits}f}" + else: + fmt = "{{:.{}f}}".format(self._max_frac_digits) + result = fmt.format(val) + prefix = self._pos_prefix if val >= 0 else self._neg_prefix + suffix = self._pos_suffix if val >= 0 else self._neg_suffix + result = prefix + result + suffix + if to_append_to is not None: + sb = str(to_append_to) + idx = len(sb) + to_append_to.append(result) + if pos is not None: + pos.setBeginIndex(idx) + pos.setEndIndex(idx + len(result)) + return to_append_to + return result + + def parse(self, source, pos=None): + text = source.strip() + try: + val = float(text) + if pos is not None: + pos.setIndex(len(source)) + if self._parse_bigdecimal: + return _Decimal(str(val)) + return val + except ValueError: + if pos is not None: + pos.setErrorIndex(0) + raise Exception(f"Unparseable: {source}") + + def setDecimalSeparatorAlwaysShown(self, v): self._decimal_sep_always = v + def getDecimalSeparatorAlwaysShown(self): return self._decimal_sep_always + def setGroupingSize(self, v): self._grouping_size = v + def getGroupingSize(self): return self._grouping_size + def setGroupingUsed(self, v): self._grouping_used = v + def isGroupingUsed(self): return self._grouping_used + def setMaximumIntegerDigits(self, v): self._max_int_digits = v + def getMaximumIntegerDigits(self): return self._max_int_digits + def setMinimumIntegerDigits(self, v): self._min_int_digits = v + def getMinimumIntegerDigits(self): return self._min_int_digits + def setMaximumFractionDigits(self, v): self._max_frac_digits = v + def getMaximumFractionDigits(self): return self._max_frac_digits + def setMinimumFractionDigits(self, v): self._min_frac_digits = v + def getMinimumFractionDigits(self): return self._min_frac_digits + def setNegativePrefix(self, v): self._neg_prefix = v + def getNegativePrefix(self): return self._neg_prefix + def setNegativeSuffix(self, v): self._neg_suffix = v + def getNegativeSuffix(self): return self._neg_suffix + def setPositivePrefix(self, v): self._pos_prefix = v + def getPositivePrefix(self): return self._pos_prefix + def setPositiveSuffix(self, v): self._pos_suffix = v + def getPositiveSuffix(self): return self._pos_suffix + def setDecimalFormatSymbols(self, v): self._symbols = v + def getDecimalFormatSymbols(self): return self._symbols + def setParseBigDecimal(self, v): self._parse_bigdecimal = v + def isParseBigDecimal(self): return self._parse_bigdecimal + def setMultiplier(self, v): self._multiplier = v + def getMultiplier(self): return self._multiplier + def setRoundingMode(self, v): self._rounding_mode = v + def getRoundingMode(self): return self._rounding_mode + + +# ============================================================ +# MessageFormat +# ============================================================ + +_MSG_PATTERN_RE = _re.compile(r"\{(\d+)(?:,(\w+)(?:,(.+))?)?\}") + +class MessageFormat(Format): + def __init__(self, pattern, locale=None): + super().__init__() + self._pattern = pattern + self._locale = locale + self._formats = {} + + def applyPattern(self, pattern): + self._pattern = pattern + + def toPattern(self): + return self._pattern + + def _format_impl(self, objects): + def replacer(m): + idx = int(m.group(1)) + if idx < len(objects): + return str(objects[idx]) + return m.group(0) + return _MSG_PATTERN_RE.sub(replacer, self._pattern) + + def format(self, objects, to_append_to=None, pos=None): + result = self._format_impl(objects) + if to_append_to is not None: + sb = str(to_append_to) + idx = len(sb) + to_append_to.append(result) + if pos is not None: + pos.setBeginIndex(idx) + pos.setEndIndex(idx + len(result)) + return to_append_to + return result + + @staticmethod + def format_static(pattern, *args): + mf = MessageFormat(pattern) + return mf.format(args) + + def parse(self, source, pos=None): + parts = _MSG_PATTERN_RE.split(self._pattern) + result = [] + idx = 0 + for i, part in enumerate(parts): + if i % 2 == 0: + if not source[idx:].startswith(part): + if pos is not None: + pos.setErrorIndex(idx) + return result + idx += len(part) + else: + arg_idx = int(part) + remaining = source[idx:] + next_part = parts[i + 1] if i + 1 < len(parts) else "" + end = remaining.find(next_part) if next_part else len(remaining) + if end < 0: + end = len(remaining) + result.append(remaining[:end]) + idx += end + if pos is not None: + pos.setIndex(idx) + return result + + def setLocale(self, locale): + self._locale = locale + + def getLocale(self): + return self._locale + + def setFormats(self, formats): + self._formats = formats + + def getFormats(self): + return self._formats + + def setFormat(self, idx, fmt): + self._formats[idx] = fmt + + def getFormat(self, idx): + return self._formats.get(idx) + + +# ============================================================ +# CharacterIterator +# ============================================================ + +class CharacterIterator(Stub): + DONE = chr(0xFFFF) + + def first(self): + raise NotImplementedError + + def last(self): + raise NotImplementedError + + def current(self): + raise NotImplementedError + + def next(self): + raise NotImplementedError + + def previous(self): + raise NotImplementedError + + def setIndex(self, position): + raise NotImplementedError + + def getBeginIndex(self): + raise NotImplementedError + + def getEndIndex(self): + raise NotImplementedError + + def getIndex(self): + raise NotImplementedError + + def clone(self): + raise NotImplementedError + + +# ============================================================ +# StringCharacterIterator +# ============================================================ + +class StringCharacterIterator(CharacterIterator): + def __init__(self, text): + super().__init__() + self._text = text + self._begin = 0 + self._end = len(text) + self._pos = 0 + + def first(self): + self._pos = self._begin + return self.current() + + def last(self): + self._pos = self._end - 1 if self._end > self._begin else self._begin + return self.current() + + def current(self): + if self._pos >= self._begin and self._pos < self._end: + return self._text[self._pos] + return CharacterIterator.DONE + + def next(self): + self._pos += 1 + if self._pos >= self._end: + self._pos = self._end + return CharacterIterator.DONE + return self._text[self._pos] + + def previous(self): + self._pos -= 1 + if self._pos < self._begin: + self._pos = self._begin + return CharacterIterator.DONE + return self._text[self._pos] + + def setIndex(self, pos): + self._pos = max(self._begin, min(pos, self._end)) + return self.current() + + def getBeginIndex(self): + return self._begin + + def getEndIndex(self): + return self._end + + def getIndex(self): + return self._pos + + def clone(self): + return StringCharacterIterator(self._text) + + +# ============================================================ +# BreakIterator +# ============================================================ + +class BreakIterator(Stub): + DONE = -1 + + @staticmethod + def getWordInstance(locale=None): + return BreakIterator() + + @staticmethod + def getLineInstance(locale=None): + return BreakIterator() + + @staticmethod + def getCharacterInstance(locale=None): + return BreakIterator() + + @staticmethod + def getSentenceInstance(locale=None): + return BreakIterator() + + def setText(self, text): + self._text = text + + def first(self): + return 0 + + def last(self): + return len(self._text) if hasattr(self, "_text") else 0 + + def next(self, n=1): + return BreakIterator.DONE + + def previous(self): + return BreakIterator.DONE + + def current(self): + return 0 + + def following(self, offset): + return BreakIterator.DONE + + def preceding(self, offset): + return BreakIterator.DONE + + def isBoundary(self, offset): + return True + + +# ============================================================ +# Collator / CollationKey / RuleBasedCollator +# ============================================================ + +class CollationKey(Stub): + def __init__(self, source, key): + super().__init__() + self._source = source + self._key = key + + def compareTo(self, other): + if isinstance(other, CollationKey): + return (self._key > other._key) - (self._key < other._key) + return -1 + + def getSourceString(self): + return self._source + + def toByteArray(self): + return self._key.encode("utf-8") + + +class Collator(Stub): + PRIMARY = 0 + SECONDARY = 1 + TERTIARY = 2 + IDENTICAL = 3 + NO_DECOMPOSITION = 0 + CANONICAL_DECOMPOSITION = 1 + FULL_DECOMPOSITION = 2 + + @staticmethod + def getInstance(locale=None): + return RuleBasedCollator() + + def compare(self, source, target): + return (source > target) - (source < target) + + def getCollationKey(self, source): + return CollationKey(source, source) + + def setStrength(self, strength): + self._strength = strength + + def getStrength(self): + return getattr(self, "_strength", Collator.TERTIARY) + + def setDecomposition(self, decomposition): + self._decomposition = decomposition + + def getDecomposition(self): + return getattr(self, "_decomposition", Collator.NO_DECOMPOSITION) + + +class RuleBasedCollator(Collator): + def __init__(self, rules=None): + super().__init__() + self._rules = rules or "" + + +# ============================================================ +# Normalizer +# ============================================================ + +class Normalizer(Stub): + class Form(Stub): + NFC = "NFC" + NFD = "NFD" + NFKC = "NFKC" + NFKD = "NFKD" + + @staticmethod + def normalize(src, form): + import unicodedata + form_map = { + Normalizer.Form.NFC: "NFC", + Normalizer.Form.NFD: "NFD", + Normalizer.Form.NFKC: "NFKC", + Normalizer.Form.NFKD: "NFKD", + } + return unicodedata.normalize(form_map.get(form, "NFC"), src) + + @staticmethod + def isNormalized(src, form): + return Normalizer.normalize(src, form) == src + + +# ============================================================ +# Annotation / AttributedCharacterIterator / AttributedString +# ============================================================ + +class Annotation(Stub): + def __init__(self, value): + super().__init__() + self._value = value + + def getValue(self): + return self._value + + def toString(self): + return str(self._value) + + +class AttributedCharacterIterator(CharacterIterator): + pass + + +class AttributedString(Stub): + def __init__(self, text, attributes=None): + super().__init__() + self._text = text + + def getIterator(self): + return StringCharacterIterator(self._text) + + +# ============================================================ +# Bidi +# ============================================================ + +class Bidi(Stub): + DIRECTION_LEFT_TO_RIGHT = 0 + DIRECTION_RIGHT_TO_LEFT = 1 + DIRECTION_DEFAULT_LEFT_TO_RIGHT = -2 + DIRECTION_DEFAULT_RIGHT_TO_LEFT = -1 + + def __init__(self, text, flags=0): + super().__init__() + self._text = text + self._base_level = 0 if flags >= 0 else 1 + + def isLeftToRight(self): + return self._base_level == 0 + + def isRightToLeft(self): + return self._base_level == 1 + + def getLength(self): + return len(self._text) + + def getLevelAt(self, offset): + return self._base_level + + def getRunCount(self): + return 1 + + def getRunLevel(self, run): + return self._base_level + + def getRunLimit(self, run): + return len(self._text) + + def getRunStart(self, run): + return 0 + + def requiresBidi(self, text): + for ch in text: + if ord(ch) > 0x590: + return True + return False + + @staticmethod + def reorderVisually(levels, objects, index, count): + pass + + @staticmethod + def baseIsLeftToRight(): + return True \ No newline at end of file diff --git a/android_pyapi/java/time.py b/android_pyapi/java/time.py new file mode 100644 index 0000000..c68f1cc --- /dev/null +++ b/android_pyapi/java/time.py @@ -0,0 +1,1619 @@ +""" +Java time standard library APIs implemented in Python. +java.time package - LocalDate, LocalTime, LocalDateTime, ZonedDateTime, Instant, Duration, Period, etc. +""" + +from .._core import Stub +from .lang import RuntimeException, Comparable +import datetime as _dt +import re as _re +import math as _py_math + +IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {}) + +__all__ = [ + "LocalDate", "LocalTime", "LocalDateTime", + "ZonedDateTime", "OffsetDateTime", "OffsetTime", + "Instant", "Duration", "Period", + "ZoneId", "ZoneOffset", "ZoneRules", + "DayOfWeek", "Month", "Year", "YearMonth", "MonthDay", + "Clock", + "DateTimeFormatter", "DateTimeFormatterBuilder", + "TemporalAdjusters", + "Temporal", "TemporalAccessor", "TemporalUnit", + "ChronoUnit", "ChronoField", +] + + +# ============================================================ +# TemporalAccessor / Temporal / TemporalUnit (base interfaces) +# ============================================================ + +class TemporalAccessor(Stub): + def get(self, field): + raise NotImplementedError + + def getLong(self, field): + raise NotImplementedError + + def isSupported(self, field): + raise NotImplementedError + + def range(self, field): + raise NotImplementedError + + +class Temporal(TemporalAccessor): + def plus(self, amount, unit=None): + raise NotImplementedError + + def minus(self, amount, unit=None): + raise NotImplementedError + + def with_(self, field, new_value): + raise NotImplementedError + + def until(self, end_exclusive, unit): + raise NotImplementedError + + +class TemporalUnit(Stub): + def getDuration(self): + raise NotImplementedError + + def isDurationEstimated(self): + raise NotImplementedError + + def isDateBased(self): + raise NotImplementedError + + def isTimeBased(self): + raise NotImplementedError + + def between(self, temporal1, temporal2): + raise NotImplementedError + + +# ============================================================ +# ChronoField +# ============================================================ + +class ChronoField(Stub): + NANO_OF_SECOND = "NanoOfSecond" + NANO_OF_DAY = "NanoOfDay" + MICRO_OF_SECOND = "MicroOfSecond" + MICRO_OF_DAY = "MicroOfDay" + MILLI_OF_SECOND = "MilliOfSecond" + MILLI_OF_DAY = "MilliOfDay" + SECOND_OF_MINUTE = "SecondOfMinute" + SECOND_OF_DAY = "SecondOfDay" + MINUTE_OF_HOUR = "MinuteOfHour" + MINUTE_OF_DAY = "MinuteOfDay" + HOUR_OF_AMPM = "HourOfAmPm" + CLOCK_HOUR_OF_AMPM = "ClockHourOfAmPm" + HOUR_OF_DAY = "HourOfDay" + CLOCK_HOUR_OF_DAY = "ClockHourOfDay" + AMPM_OF_DAY = "AmPmOfDay" + DAY_OF_WEEK = "DayOfWeek" + ALIGNED_DAY_OF_WEEK_IN_MONTH = "AlignedDayOfWeekInMonth" + ALIGNED_DAY_OF_WEEK_IN_YEAR = "AlignedDayOfWeekInYear" + DAY_OF_MONTH = "DayOfMonth" + DAY_OF_YEAR = "DayOfYear" + EPOCH_DAY = "EpochDay" + ALIGNED_WEEK_OF_MONTH = "AlignedWeekOfMonth" + ALIGNED_WEEK_OF_YEAR = "AlignedWeekOfYear" + MONTH_OF_YEAR = "MonthOfYear" + PROLEPTIC_MONTH = "ProlepticMonth" + YEAR_OF_ERA = "YearOfEra" + YEAR = "Year" + ERA = "Era" + INSTANT_SECONDS = "InstantSeconds" + OFFSET_SECONDS = "OffsetSeconds" + + def __init__(self, name): + super().__init__() + self._name = name + + def toString(self): + return self._name + + def getDisplayName(self, locale=None): + return self._name + + +# ============================================================ +# ChronoUnit +# ============================================================ + +class ChronoUnit(Stub): + NANOS = None + MICROS = None + MILLIS = None + SECONDS = None + MINUTES = None + HOURS = None + HALF_DAYS = None + DAYS = None + WEEKS = None + MONTHS = None + YEARS = None + DECADES = None + CENTURIES = None + MILLENNIA = None + ERAS = None + FOREVER = None + + def __init__(self, name, duration, estimated=False): + self._name = name + self._duration = duration + self._estimated = estimated + + def toString(self): + return self._name + + def getDuration(self): + return self._duration + + def isDurationEstimated(self): + return self._estimated + + def isDateBased(self): + return self in (ChronoUnit.WEEKS, ChronoUnit.MONTHS, ChronoUnit.YEARS, + ChronoUnit.DECADES, ChronoUnit.CENTURIES, + ChronoUnit.MILLENNIA, ChronoUnit.ERAS) + + def isTimeBased(self): + return self in (ChronoUnit.NANOS, ChronoUnit.MICROS, ChronoUnit.MILLIS, + ChronoUnit.SECONDS, ChronoUnit.MINUTES, ChronoUnit.HOURS, + ChronoUnit.HALF_DAYS) + + def between(self, temporal1, temporal2): + return temporal1.until(temporal2, self) + + @staticmethod + def from_(temporal): + if isinstance(temporal, ChronoUnit): + return temporal + raise Exception(f"Cannot convert to ChronoUnit: {temporal}") + + +# ChronoUnit 常量在 Duration 定义之后初始化（见下方） + + +# ============================================================ +# DayOfWeek +# ============================================================ + +class DayOfWeek(Stub): + MONDAY = None + TUESDAY = None + WEDNESDAY = None + THURSDAY = None + FRIDAY = None + SATURDAY = None + SUNDAY = None + + def __init__(self, value, name): + self._value = value + self._name = name + + def getValue(self): + return self._value + + def getDisplayName(self, style, locale=None): + return self._name + + def plus(self, days): + idx = ((self._value - 1 + days) % 7) + 1 + return DayOfWeek._from_value(idx) + + def minus(self, days): + return self.plus(-days) + + @staticmethod + def _from_value(v): + mapping = {1: DayOfWeek.MONDAY, 2: DayOfWeek.TUESDAY, 3: DayOfWeek.WEDNESDAY, + 4: DayOfWeek.THURSDAY, 5: DayOfWeek.FRIDAY, 6: DayOfWeek.SATURDAY, + 7: DayOfWeek.SUNDAY} + return mapping.get(v) + + def toString(self): + return self._name + + def compareTo(self, other): + if isinstance(other, DayOfWeek): + return self._value - other._value + return -1 + + +DayOfWeek.MONDAY = DayOfWeek(1, "MONDAY") +DayOfWeek.TUESDAY = DayOfWeek(2, "TUESDAY") +DayOfWeek.WEDNESDAY = DayOfWeek(3, "WEDNESDAY") +DayOfWeek.THURSDAY = DayOfWeek(4, "THURSDAY") +DayOfWeek.FRIDAY = DayOfWeek(5, "FRIDAY") +DayOfWeek.SATURDAY = DayOfWeek(6, "SATURDAY") +DayOfWeek.SUNDAY = DayOfWeek(7, "SUNDAY") + + +# ============================================================ +# Month +# ============================================================ + +class Month(Stub): + JANUARY = None + FEBRUARY = None + MARCH = None + APRIL = None + MAY = None + JUNE = None + JULY = None + AUGUST = None + SEPTEMBER = None + OCTOBER = None + NOVEMBER = None + DECEMBER = None + + def __init__(self, value, name): + self._value = value + self._name = name + + def getValue(self): + return self._value + + def getDisplayName(self, style, locale=None): + return self._name + + def plus(self, months): + idx = ((self._value - 1 + months) % 12) + 1 + return Month._from_value(idx) + + def minus(self, months): + return self.plus(-months) + + def length(self, leap_year=False): + if self._value == 2: + return 29 if leap_year else 28 + if self._value in (4, 6, 9, 11): + return 30 + return 31 + + def minLength(self): + return 29 if self._value == 2 else (30 if self._value in (4, 6, 9, 11) else 31) + + def maxLength(self): + return 29 if self._value == 2 else (30 if self._value in (4, 6, 9, 11) else 31) + + def firstDayOfYear(self, leap_year=False): + days = 0 + for m in range(1, self._value): + days += Month._from_value(m).length(leap_year) + return days + 1 + + def firstMonthOfQuarter(self): + q = (self._value - 1) // 3 + return Month._from_value(q * 3 + 1) + + @staticmethod + def _from_value(v): + values = [None, Month.JANUARY, Month.FEBRUARY, Month.MARCH, Month.APRIL, + Month.MAY, Month.JUNE, Month.JULY, Month.AUGUST, + Month.SEPTEMBER, Month.OCTOBER, Month.NOVEMBER, Month.DECEMBER] + return values[v] if 0 < v <= 12 else None + + def toString(self): + return self._name + + def compareTo(self, other): + if isinstance(other, Month): + return self._value - other._value + return -1 + + +Month.JANUARY = Month(1, "JANUARY") +Month.FEBRUARY = Month(2, "FEBRUARY") +Month.MARCH = Month(3, "MARCH") +Month.APRIL = Month(4, "APRIL") +Month.MAY = Month(5, "MAY") +Month.JUNE = Month(6, "JUNE") +Month.JULY = Month(7, "JULY") +Month.AUGUST = Month(8, "AUGUST") +Month.SEPTEMBER = Month(9, "SEPTEMBER") +Month.OCTOBER = Month(10, "OCTOBER") +Month.NOVEMBER = Month(11, "NOVEMBER") +Month.DECEMBER = Month(12, "DECEMBER") + + +# ============================================================ +# ZoneId / ZoneOffset / ZoneRules +# ============================================================ + +class ZoneId(Stub): + SHORT_IDS = { + "ACT": "Australia/Darwin", + "AET": "Australia/Sydney", + "AGT": "America/Argentina/Buenos_Aires", + "ART": "Africa/Cairo", + "AST": "America/Anchorage", + "BET": "America/Sao_Paulo", + "BST": "Asia/Dhaka", + "CAT": "Africa/Harare", + "CNT": "America/St_Johns", + "CST": "America/Chicago", + "CTT": "Asia/Shanghai", + "EAT": "Africa/Addis_Ababa", + "ECT": "Europe/Paris", + "EST": "America/New_York", + "HST": "Pacific/Honolulu", + "IET": "America/Indianapolis", + "IST": "Asia/Kolkata", + "JST": "Asia/Tokyo", + "MIT": "Pacific/Apia", + "MST": "America/Denver", + "NET": "Asia/Yerevan", + "NST": "Pacific/Auckland", + "PLT": "Asia/Karachi", + "PNT": "America/Phoenix", + "PRT": "America/Puerto_Rico", + "PST": "America/Los_Angeles", + "SST": "Pacific/Guadalcanal", + "VST": "Asia/Ho_Chi_Minh", + } + + _cache = {} + + def __init__(self, zone_id): + super().__init__() + self._id = zone_id + + @staticmethod + def systemDefault(): + import time as _t + idx = 1 if _t.daylight else 0 + tz_name = _t.tzname[idx] if idx < len(_t.tzname) and _t.tzname[idx] else _t.tzname[0] + return ZoneId.of(tz_name) if tz_name else ZoneId("UTC") + + @staticmethod + def of(zone_id): + if zone_id in ZoneId.SHORT_IDS: + zone_id = ZoneId.SHORT_IDS[zone_id] + if zone_id not in ZoneId._cache: + ZoneId._cache[zone_id] = ZoneId(zone_id) + return ZoneId._cache[zone_id] + + @staticmethod + def getAvailableZoneIds(): + import time as _t + return set(_t.tzname) + + def getDisplayName(self, style, locale=None): + return self._id + + def getRules(self): + return ZoneRules() + + def toString(self): + return self._id + + def equals(self, other): + if isinstance(other, ZoneId): + return self._id == other._id + return False + + def hashCode(self): + return hash(self._id) + + +class ZoneOffset(ZoneId): + MAX = None + MIN = None + UTC = None + + _cache = {} + + def __init__(self, total_seconds): + hours = total_seconds // 3600 + mins = (abs(total_seconds) % 3600) // 60 + sign = "+" if total_seconds >= 0 else "-" + if mins == 0: + zone_id = f"{sign}{abs(hours):02d}:00" + else: + zone_id = f"{sign}{abs(hours):02d}:{mins:02d}" + super().__init__(zone_id) + self._total_seconds = total_seconds + + @staticmethod + def of(offset_id): + if offset_id in ZoneOffset._cache: + return ZoneOffset._cache[offset_id] + if offset_id == "Z" or offset_id == "UTC" or offset_id == "GMT": + z = ZoneOffset(0) + ZoneOffset._cache[offset_id] = z + return z + sign = 1 if offset_id[0] == "+" else -1 + parts = offset_id[1:].split(":") + h = int(parts[0]) + m = int(parts[1]) if len(parts) > 1 else 0 + total = sign * (h * 3600 + m * 60) + z = ZoneOffset(total) + ZoneOffset._cache[offset_id] = z + return z + + @staticmethod + def ofHours(hours): + return ZoneOffset(hours * 3600) + + @staticmethod + def ofHoursMinutes(hours, minutes): + sign = 1 if hours >= 0 else -1 + return ZoneOffset(sign * (abs(hours) * 3600 + minutes * 60)) + + @staticmethod + def ofTotalSeconds(total_seconds): + if total_seconds in ZoneOffset._cache: + return ZoneOffset._cache[total_seconds] + z = ZoneOffset(total_seconds) + ZoneOffset._cache[total_seconds] = z + return z + + def getTotalSeconds(self): + return self._total_seconds + + def toString(self): + if self._total_seconds == 0: + return "Z" + return super().toString() + + def equals(self, other): + if isinstance(other, ZoneOffset): + return self._total_seconds == other._total_seconds + return False + + def hashCode(self): + return self._total_seconds + + +ZoneOffset.MAX = ZoneOffset(18 * 3600) +ZoneOffset.MIN = ZoneOffset(-18 * 3600) +ZoneOffset.UTC = ZoneOffset(0) + + +class ZoneRules(Stub): + def isFixedOffset(self): + return True + + def getOffset(self, instant): + return ZoneOffset.UTC + + def getDaylightSavings(self, instant): + return Duration.ZERO + + def isDaylightSavings(self, instant): + return False + + def isValidOffset(self, local_date_time, offset): + return True + + def nextTransition(self, instant): + return None + + def previousTransition(self, instant): + return None + + def getTransitions(self): + return [] + + def getTransitionRules(self): + return [] + + +# ============================================================ +# Instant +# ============================================================ + +class Instant(Temporal, Comparable): + EPOCH = None + + def __init__(self, epoch_second, nano=0): + super().__init__() + self._epoch_second = int(epoch_second) + self._nano = int(nano) + + @staticmethod + def now(): + import time as _t + t = _t.time() + sec = int(t) + nano = int((t - sec) * 1_000_000_000) + return Instant(sec, nano) + + @staticmethod + def ofEpochMilli(epoch_milli): + return Instant(epoch_milli // 1000, (epoch_milli % 1000) * 1_000_000) + + @staticmethod + def ofEpochSecond(epoch_second, nano_adjustment=0): + return Instant(epoch_second + nano_adjustment // 1_000_000_000, + nano_adjustment % 1_000_000_000) + + def getEpochSecond(self): + return self._epoch_second + + def getNano(self): + return self._nano + + def toEpochMilli(self): + return self._epoch_second * 1000 + self._nano // 1_000_000 + + def plus(self, seconds, nano=0): + return Instant(self._epoch_second + seconds, self._nano + nano) + + def minus(self, seconds, nano=0): + return self.plus(-seconds, -nano) + + def isBefore(self, other): + if isinstance(other, Instant): + return (self._epoch_second, self._nano) < (other._epoch_second, other._nano) + return False + + def isAfter(self, other): + if isinstance(other, Instant): + return (self._epoch_second, self._nano) > (other._epoch_second, other._nano) + return False + + def compareTo(self, other): + if isinstance(other, Instant): + diff = self._epoch_second - other._epoch_second + if diff != 0: + return -1 if diff < 0 else 1 + diff = self._nano - other._nano + return -1 if diff < 0 else (1 if diff > 0 else 0) + return -1 + + def equals(self, other): + if isinstance(other, Instant): + return self._epoch_second == other._epoch_second and self._nano == other._nano + return False + + def hashCode(self): + return hash((self._epoch_second, self._nano)) + + def toString(self): + return f"Instant({self._epoch_second},{self._nano})" + + +Instant.EPOCH = Instant(0, 0) + + +# ============================================================ +# Duration +# ============================================================ + +class Duration(Temporal, Comparable): + ZERO = None + + def __init__(self, seconds, nanos=0): + super().__init__() + self._seconds = int(seconds) + self._nanos = int(nanos) + + @staticmethod + def ofDays(days): + return Duration(days * 86400) + + @staticmethod + def ofHours(hours): + return Duration(hours * 3600) + + @staticmethod + def ofMinutes(minutes): + return Duration(minutes * 60) + + @staticmethod + def ofSeconds(seconds): + return Duration(seconds) + + @staticmethod + def ofMillis(millis): + return Duration(millis // 1000, (millis % 1000) * 1_000_000) + + @staticmethod + def ofNanos(nanos): + return Duration(nanos // 1_000_000_000, nanos % 1_000_000_000) + + @staticmethod + def between(start, end): + if isinstance(start, Instant) and isinstance(end, Instant): + return Duration(end.getEpochSecond() - start.getEpochSecond(), + end.getNano() - start.getNano()) + return Duration.ZERO + + def getSeconds(self): + return self._seconds + + def getNano(self): + return self._nanos + + def toDays(self): + return self._seconds // 86400 + + def toHours(self): + return self._seconds // 3600 + + def toMinutes(self): + return self._seconds // 60 + + def toSeconds(self): + return self._seconds + + def toMillis(self): + return self._seconds * 1000 + self._nanos // 1_000_000 + + def toNanos(self): + return self._seconds * 1_000_000_000 + self._nanos + + def plus(self, duration): + if isinstance(duration, Duration): + return Duration(self._seconds + duration._seconds, + self._nanos + duration._nanos) + return self + + def minus(self, duration): + if isinstance(duration, Duration): + return Duration(self._seconds - duration._seconds, + self._nanos - duration._nanos) + return self + + def isNegative(self): + return self._seconds < 0 or (self._seconds == 0 and self._nanos < 0) + + def isZero(self): + return self._seconds == 0 and self._nanos == 0 + + def compareTo(self, other): + if isinstance(other, Duration): + diff = self._seconds - other._seconds + if diff != 0: + return -1 if diff < 0 else 1 + diff = self._nanos - other._nanos + return -1 if diff < 0 else (1 if diff > 0 else 0) + return -1 + + def equals(self, other): + if isinstance(other, Duration): + return self._seconds == other._seconds and self._nanos == other._nanos + return False + + def toString(self): + return f"PT{self._seconds}S" + + def hashCode(self): + return hash((self._seconds, self._nanos)) + + +Duration.ZERO = Duration(0, 0) + + +# === 延迟初始化 ChronoUnit 常量（必须在 Duration 定义之后） === +ChronoUnit.NANOS = ChronoUnit("Nanos", Duration.ofNanos(1)) +ChronoUnit.MICROS = ChronoUnit("Micros", Duration.ofNanos(1000)) +ChronoUnit.MILLIS = ChronoUnit("Millis", Duration.ofNanos(1_000_000)) +ChronoUnit.SECONDS = ChronoUnit("Seconds", Duration.ofSeconds(1)) +ChronoUnit.MINUTES = ChronoUnit("Minutes", Duration.ofMinutes(1)) +ChronoUnit.HOURS = ChronoUnit("Hours", Duration.ofHours(1)) +ChronoUnit.HALF_DAYS = ChronoUnit("HalfDays", Duration.ofHours(12)) +ChronoUnit.DAYS = ChronoUnit("Days", Duration.ofDays(1)) +ChronoUnit.WEEKS = ChronoUnit("Weeks", Duration.ofDays(7)) +ChronoUnit.MONTHS = ChronoUnit("Months", Duration.ofDays(30), estimated=True) +ChronoUnit.YEARS = ChronoUnit("Years", Duration.ofDays(365), estimated=True) +ChronoUnit.DECADES = ChronoUnit("Decades", Duration.ofDays(365 * 10), estimated=True) +ChronoUnit.CENTURIES = ChronoUnit("Centuries", Duration.ofDays(365 * 100), estimated=True) +ChronoUnit.MILLENNIA = ChronoUnit("Millennia", Duration.ofDays(365 * 1000), estimated=True) +ChronoUnit.ERAS = ChronoUnit("Eras", Duration.ofDays(365 * 1_000_000_000), estimated=True) +ChronoUnit.FOREVER = ChronoUnit("Forever", Duration.ofSeconds(1_000_000_000 * 86400 * 365), estimated=True) + + +# ============================================================ +# Period +# ============================================================ + +class Period(Stub): + ZERO = None + + def __init__(self, years, months, days): + super().__init__() + self._years = years + self._months = months + self._days = days + + @staticmethod + def ofDays(days): + return Period(0, 0, days) + + @staticmethod + def ofWeeks(weeks): + return Period(0, 0, weeks * 7) + + @staticmethod + def ofMonths(months): + return Period(0, months, 0) + + @staticmethod + def ofYears(years): + return Period(years, 0, 0) + + @staticmethod + def between(start, end): + if isinstance(start, LocalDate) and isinstance(end, LocalDate): + return Period(end._year - start._year, + end._month - start._month, + end._day - start._day) + return Period.ZERO + + def getYears(self): + return self._years + + def getMonths(self): + return self._months + + def getDays(self): + return self._days + + def plus(self, period): + if isinstance(period, Period): + return Period(self._years + period._years, + self._months + period._months, + self._days + period._days) + return self + + def minus(self, period): + if isinstance(period, Period): + return Period(self._years - period._years, + self._months - period._months, + self._days - period._days) + return self + + def isZero(self): + return self._years == 0 and self._months == 0 and self._days == 0 + + def isNegative(self): + return self._years < 0 or self._months < 0 or self._days < 0 + + def equals(self, other): + if isinstance(other, Period): + return (self._years == other._years and + self._months == other._months and + self._days == other._days) + return False + + def toString(self): + return f"P{self._years}Y{self._months}M{self._days}D" + + def hashCode(self): + return hash((self._years, self._months, self._days)) + + +Period.ZERO = Period(0, 0, 0) + + +# ============================================================ +# LocalDate +# ============================================================ + +class LocalDate(Temporal, Comparable): + MIN = None + MAX = None + + def __init__(self, year, month, day): + super().__init__() + self._year = year + self._month = month + self._day = day + + @staticmethod + def now(zone=None): + today = _dt.date.today() + return LocalDate(today.year, today.month, today.day) + + @staticmethod + def of(year, month, dayOfMonth): + if isinstance(month, Month): + month = month.getValue() + return LocalDate(year, month, dayOfMonth) + + @staticmethod + def parse(text, formatter=None): + if formatter is None: + parts = text.split("-") + return LocalDate(int(parts[0]), int(parts[1]), int(parts[2])) + return formatter.parse(text, LocalDate) + + def getYear(self): + return self._year + + def getMonth(self): + return Month._from_value(self._month) + + def getMonthValue(self): + return self._month + + def getDayOfMonth(self): + return self._day + + def getDayOfWeek(self): + import time as _t + import datetime as _dt2 + d = _dt2.date(self._year, self._month, self._day) + return DayOfWeek._from_value(d.isoweekday()) + + def getDayOfYear(self): + d = _dt.date(self._year, self._month, self._day) + return d.timetuple().tm_yday + + def getEra(self): + return "CE" if self._year > 0 else "BCE" + + def isLeapYear(self): + return _dt.date(self._year, 3, 1) - _dt.date(self._year, 2, 28) == _dt.timedelta(days=1) + + def lengthOfMonth(self): + m = self._month + if m == 2: + return 29 if self.isLeapYear() else 28 + if m in (4, 6, 9, 11): + return 30 + return 31 + + def lengthOfYear(self): + return 366 if self.isLeapYear() else 365 + + def toEpochDay(self): + d = _dt.date(self._year, self._month, self._day) + return d.toordinal() + + def plusDays(self, days): + d = _dt.date(self._year, self._month, self._day) + _dt.timedelta(days=days) + return LocalDate(d.year, d.month, d.day) + + def plusWeeks(self, weeks): + return self.plusDays(weeks * 7) + + def plusMonths(self, months): + total = self._year * 12 + (self._month - 1) + months + y = total // 12 + m = (total % 12) + 1 + d = min(self._day, 29 if m == 2 and _dt.date(y, 3, 1) - _dt.date(y, 2, 28) == _dt.timedelta(days=1) else + 30 if m in (4, 6, 9, 11) else 31) + return LocalDate(y, m, d) + + def plusYears(self, years): + return self.plusMonths(years * 12) + + def minusDays(self, days): + return self.plusDays(-days) + + def minusWeeks(self, weeks): + return self.plusDays(-weeks * 7) + + def minusMonths(self, months): + return self.plusMonths(-months) + + def minusYears(self, years): + return self.plusYears(-years) + + def isBefore(self, other): + if isinstance(other, LocalDate): + return (self._year, self._month, self._day) < (other._year, other._month, other._day) + return False + + def isAfter(self, other): + if isinstance(other, LocalDate): + return (self._year, self._month, self._day) > (other._year, other._month, other._day) + return False + + def isEqual(self, other): + if isinstance(other, LocalDate): + return (self._year, self._month, self._day) == (other._year, other._month, other._day) + return False + + def withDayOfMonth(self, day): + return LocalDate(self._year, self._month, day) + + def withMonth(self, month): + if isinstance(month, Month): + month = month.getValue() + return LocalDate(self._year, month, self._day) + + def withYear(self, year): + return LocalDate(year, self._month, self._day) + + def atTime(self, hour, minute=0, second=0, nano=0): + return LocalDateTime(self, LocalTime(hour, minute, second, nano)) + + def atStartOfDay(self, zone=None): + return LocalDateTime(self, LocalTime.MIDNIGHT) + + def format(self, formatter): + return formatter.format(self) + + def compareTo(self, other): + if isinstance(other, LocalDate): + v = self._year - other._year + if v != 0: + return -1 if v < 0 else 1 + v = self._month - other._month + if v != 0: + return -1 if v < 0 else 1 + v = self._day - other._day + return -1 if v < 0 else (1 if v > 0 else 0) + return -1 + + def equals(self, other): + if isinstance(other, LocalDate): + return (self._year, self._month, self._day) == (other._year, other._month, other._day) + return False + + def toString(self): + return f"{self._year:04d}-{self._month:02d}-{self._day:02d}" + + def hashCode(self): + return hash((self._year, self._month, self._day)) + + +LocalDate.MIN = LocalDate(-999999999, 1, 1) +LocalDate.MAX = LocalDate(999999999, 12, 31) + + +# ============================================================ +# LocalTime +# ============================================================ + +class LocalTime(Temporal, Comparable): + MIDNIGHT = None + NOON = None + MIN = None + MAX = None + + def __init__(self, hour, minute=0, second=0, nano=0): + super().__init__() + self._hour = hour + self._minute = minute + self._second = second + self._nano = nano + + @staticmethod + def now(zone=None): + t = _dt.datetime.now().time() + return LocalTime(t.hour, t.minute, t.second, t.microsecond * 1000) + + @staticmethod + def of(hour, minute=0, second=0, nano=0): + return LocalTime(hour, minute, second, nano) + + @staticmethod + def parse(text, formatter=None): + parts = text.split(":") + h = int(parts[0]) + m = int(parts[1]) + s = int(parts[2]) if len(parts) > 2 else 0 + return LocalTime(h, m, s) + + def getHour(self): + return self._hour + + def getMinute(self): + return self._minute + + def getSecond(self): + return self._second + + def getNano(self): + return self._nano + + def toSecondOfDay(self): + return self._hour * 3600 + self._minute * 60 + self._second + + def toNanoOfDay(self): + return self.toSecondOfDay() * 1_000_000_000 + self._nano + + def plusHours(self, h): + total = self._hour + h + return LocalTime(total % 24, self._minute, self._second, self._nano) + + def plusMinutes(self, m): + total = self.toSecondOfDay() + m * 60 + total %= 86400 + h = total // 3600 + total %= 3600 + mi = total // 60 + s = total % 60 + return LocalTime(h, mi, s, self._nano) + + def plusSeconds(self, s): + total = self.toSecondOfDay() + s + total %= 86400 + h = total // 3600 + total %= 3600 + mi = total // 60 + sec = total % 60 + return LocalTime(h, mi, sec, self._nano) + + def plusNanos(self, n): + return LocalTime(self._hour, self._minute, self._second, self._nano + n) + + def minusHours(self, h): + return self.plusHours(-h) + + def minusMinutes(self, m): + return self.plusMinutes(-m) + + def minusSeconds(self, s): + return self.plusSeconds(-s) + + def withHour(self, h): + return LocalTime(h, self._minute, self._second, self._nano) + + def withMinute(self, m): + return LocalTime(self._hour, m, self._second, self._nano) + + def withSecond(self, s): + return LocalTime(self._hour, self._minute, s, self._nano) + + def withNano(self, n): + return LocalTime(self._hour, self._minute, self._second, n) + + def atDate(self, date): + return LocalDateTime(date, self) + + def isBefore(self, other): + if isinstance(other, LocalTime): + return self.toNanoOfDay() < other.toNanoOfDay() + return False + + def isAfter(self, other): + if isinstance(other, LocalTime): + return self.toNanoOfDay() > other.toNanoOfDay() + return False + + def format(self, formatter): + return formatter.format(self) + + def compareTo(self, other): + if isinstance(other, LocalTime): + diff = self.toNanoOfDay() - other.toNanoOfDay() + return -1 if diff < 0 else (1 if diff > 0 else 0) + return -1 + + def equals(self, other): + if isinstance(other, LocalTime): + return (self._hour, self._minute, self._second, self._nano) == \ + (other._hour, other._minute, other._second, other._nano) + return False + + def toString(self): + return f"{self._hour:02d}:{self._minute:02d}:{self._second:02d}" + + def hashCode(self): + return hash((self._hour, self._minute, self._second, self._nano)) + + +LocalTime.MIDNIGHT = LocalTime(0, 0, 0, 0) +LocalTime.NOON = LocalTime(12, 0, 0, 0) +LocalTime.MIN = LocalTime(0, 0, 0, 0) +LocalTime.MAX = LocalTime(23, 59, 59, 999999999) + + +# ============================================================ +# LocalDateTime +# ============================================================ + +class LocalDateTime(Temporal, Comparable): + MIN = None + MAX = None + + def __init__(self, date, time): + super().__init__() + self._date = date + self._time = time + + @staticmethod + def now(zone=None): + now = _dt.datetime.now() + date = LocalDate(now.year, now.month, now.day) + time = LocalTime(now.hour, now.minute, now.second, now.microsecond * 1000) + return LocalDateTime(date, time) + + @staticmethod + def of(date_or_year, month=None, dayOfMonth=None, hour=None, minute=0, second=0, nano=0): + if isinstance(date_or_year, LocalDate): + return LocalDateTime(date_or_year, LocalTime(month or 0, dayOfMonth or 0, hour or 0)) + return LocalDateTime(LocalDate(date_or_year, month, dayOfMonth), + LocalTime(hour, minute, second, nano)) + + @staticmethod + def parse(text, formatter=None): + parts = text.split("T") + date = LocalDate.parse(parts[0]) + time = LocalTime.parse(parts[1]) if len(parts) > 1 else LocalTime.MIDNIGHT + return LocalDateTime(date, time) + + def toLocalDate(self): + return self._date + + def toLocalTime(self): + return self._time + + def getYear(self): + return self._date.getYear() + + def getMonth(self): + return self._date.getMonth() + + def getMonthValue(self): + return self._date.getMonthValue() + + def getDayOfMonth(self): + return self._date.getDayOfMonth() + + def getDayOfWeek(self): + return self._date.getDayOfWeek() + + def getDayOfYear(self): + return self._date.getDayOfYear() + + def getHour(self): + return self._time.getHour() + + def getMinute(self): + return self._time.getMinute() + + def getSecond(self): + return self._time.getSecond() + + def getNano(self): + return self._time.getNano() + + def plusDays(self, d): + return LocalDateTime(self._date.plusDays(d), self._time) + + def plusHours(self, h): + return LocalDateTime(self._date, self._time.plusHours(h)) + + def plusMinutes(self, m): + return LocalDateTime(self._date, self._time.plusMinutes(m)) + + def plusSeconds(self, s): + return LocalDateTime(self._date, self._time.plusSeconds(s)) + + def minusDays(self, d): + return self.plusDays(-d) + + def minusHours(self, h): + return self.plusHours(-h) + + def minusMinutes(self, m): + return self.plusMinutes(-m) + + def minusSeconds(self, s): + return self.plusSeconds(-s) + + def withYear(self, y): + return LocalDateTime(self._date.withYear(y), self._time) + + def withMonth(self, m): + return LocalDateTime(self._date.withMonth(m), self._time) + + def withDayOfMonth(self, d): + return LocalDateTime(self._date.withDayOfMonth(d), self._time) + + def atZone(self, zone): + return ZonedDateTime(self, zone) + + def isBefore(self, other): + if isinstance(other, LocalDateTime): + if not self._date.isEqual(other._date): + return self._date.isBefore(other._date) + return self._time.isBefore(other._time) + return False + + def isAfter(self, other): + if isinstance(other, LocalDateTime): + if not self._date.isEqual(other._date): + return self._date.isAfter(other._date) + return self._time.isAfter(other._time) + return False + + def format(self, formatter): + return formatter.format(self) + + def compareTo(self, other): + if isinstance(other, LocalDateTime): + c = self._date.compareTo(other._date) + return c if c != 0 else self._time.compareTo(other._time) + return -1 + + def equals(self, other): + if isinstance(other, LocalDateTime): + return self._date.equals(other._date) and self._time.equals(other._time) + return False + + def toString(self): + return f"{self._date}T{self._time}" + + def hashCode(self): + return hash((self._date, self._time)) + + +LocalDateTime.MIN = LocalDateTime(LocalDate.MIN, LocalTime.MIN) +LocalDateTime.MAX = LocalDateTime(LocalDate.MAX, LocalTime.MAX) + + +# ============================================================ +# ZonedDateTime +# ============================================================ + +class ZonedDateTime(Temporal, Comparable): + def __init__(self, date_time, zone): + super().__init__() + self._date_time = date_time + self._zone = zone + + @staticmethod + def now(zone=None): + ldt = LocalDateTime.now() + z = zone or ZoneId.systemDefault() + return ZonedDateTime(ldt, z) + + @staticmethod + def of(date, time=None, zone=None, offset=None): + if isinstance(date, LocalDateTime): + return ZonedDateTime(date, time or ZoneId.systemDefault()) + return ZonedDateTime(LocalDateTime.of(date, time), zone) + + @staticmethod + def parse(text, formatter=None): + return ZonedDateTime(LocalDateTime.now(), ZoneId.systemDefault()) + + def getZone(self): + return self._zone + + def getOffset(self): + return ZoneOffset.UTC + + def withZoneSameInstant(self, zone): + return ZonedDateTime(self._date_time, zone) + + def withZoneSameLocal(self, zone): + return ZonedDateTime(self._date_time, zone) + + def toLocalDate(self): + return self._date_time.toLocalDate() + + def toLocalTime(self): + return self._date_time.toLocalTime() + + def toLocalDateTime(self): + return self._date_time + + def toInstant(self): + return Instant.now() + + def plusDays(self, d): + return ZonedDateTime(self._date_time.plusDays(d), self._zone) + + def plusHours(self, h): + return ZonedDateTime(self._date_time.plusHours(h), self._zone) + + def minusDays(self, d): + return self.plusDays(-d) + + def minusHours(self, h): + return self.plusHours(-h) + + def format(self, formatter): + return formatter.format(self) + + def compareTo(self, other): + if isinstance(other, ZonedDateTime): + return self._date_time.compareTo(other._date_time) + return -1 + + def equals(self, other): + if isinstance(other, ZonedDateTime): + return self._date_time.equals(other._date_time) and str(self._zone) == str(other._zone) + return False + + def toString(self): + return f"{self._date_time}[{self._zone}]" + + def hashCode(self): + return hash((self._date_time, str(self._zone))) + + +# ============================================================ +# OffsetDateTime / OffsetTime (stubs) +# ============================================================ + +class OffsetDateTime(Temporal): + def __init__(self, date_time, offset): + super().__init__() + self._date_time = date_time + self._offset = offset + + @staticmethod + def now(): + return OffsetDateTime(LocalDateTime.now(), ZoneOffset.UTC) + + def toLocalDate(self): + return self._date_time.toLocalDate() + + def toLocalTime(self): + return self._date_time.toLocalTime() + + def toString(self): + return f"{self._date_time}{self._offset}" + + +class OffsetTime(Stub): + def __init__(self, time, offset): + super().__init__() + self._time = time + self._offset = offset + + @staticmethod + def now(): + return OffsetTime(LocalTime.now(), ZoneOffset.UTC) + + def toString(self): + return f"{self._time}{self._offset}" + + +# ============================================================ +# Year / YearMonth / MonthDay +# ============================================================ + +class Year(Temporal, Comparable): + def __init__(self, year): + super().__init__() + self._year = year + + @staticmethod + def now(): + return Year(_dt.date.today().year) + + @staticmethod + def of(year): + return Year(year) + + def getValue(self): + return self._year + + def isLeap(self): + return _dt.date(self._year, 3, 1) - _dt.date(self._year, 2, 28) == _dt.timedelta(days=1) + + def length(self): + return 366 if self.isLeap() else 365 + + def atMonth(self, month): + if isinstance(month, Month): + month = month.getValue() + return YearMonth(self._year, month) + + def compareTo(self, other): + if isinstance(other, Year): + return -1 if self._year < other._year else (1 if self._year > other._year else 0) + return -1 + + def toString(self): + return str(self._year) + + +class YearMonth(Temporal, Comparable): + def __init__(self, year, month): + super().__init__() + self._year = year + self._month = month + + @staticmethod + def now(): + d = _dt.date.today() + return YearMonth(d.year, d.month) + + @staticmethod + def of(year, month): + return YearMonth(year, month) + + def getYear(self): + return self._year + + def getMonth(self): + return self._month + + def getMonthValue(self): + return self._month if isinstance(self._month, int) else self._month.getValue() + + def lengthOfMonth(self): + m = self.getMonthValue() + if m == 2: + return 29 if _dt.date(self._year, 3, 1) - _dt.date(self._year, 2, 28) == _dt.timedelta(days=1) else 28 + return 30 if m in (4, 6, 9, 11) else 31 + + def lengthOfYear(self): + return 366 if _dt.date(self._year, 3, 1) - _dt.date(self._year, 2, 28) == _dt.timedelta(days=1) else 365 + + def atDay(self, day): + return LocalDate(self._year, self.getMonthValue(), day) + + def compareTo(self, other): + if isinstance(other, YearMonth): + diff = self._year - other._year + if diff != 0: + return -1 if diff < 0 else 1 + diff = self.getMonthValue() - other.getMonthValue() + return -1 if diff < 0 else (1 if diff > 0 else 0) + return -1 + + def toString(self): + return f"{self._year}-{self.getMonthValue():02d}" + + +class MonthDay(Stub): + def __init__(self, month, day): + super().__init__() + self._month = month + self._day = day + + @staticmethod + def now(): + d = _dt.date.today() + return MonthDay(d.month, d.day) + + @staticmethod + def of(month, day): + return MonthDay(month, day) + + def getMonth(self): + return self._month + + def getMonthValue(self): + return self._month if isinstance(self._month, int) else self._month.getValue() + + def getDayOfMonth(self): + return self._day + + def atYear(self, year): + return LocalDate.of(year, self.getMonthValue(), self._day) + + def toString(self): + return f"--{self.getMonthValue():02d}-{self._day:02d}" + + +# ============================================================ +# Clock +# ============================================================ + +class Clock(Stub): + @staticmethod + def systemUTC(): + return Clock() + + @staticmethod + def systemDefaultZone(): + return Clock() + + @staticmethod + def system(zone): + return Clock() + + def millis(self): + import time as _t + return int(_t.time() * 1000) + + def instant(self): + return Instant.now() + + def getZone(self): + return ZoneId.systemDefault() + + +# ============================================================ +# DateTimeFormatter +# ============================================================ + +class DateTimeFormatter(Stub): + ISO_LOCAL_DATE = None + ISO_LOCAL_TIME = None + ISO_LOCAL_DATE_TIME = None + ISO_INSTANT = None + ISO_ZONED_DATE_TIME = None + ISO_OFFSET_DATE_TIME = None + + def __init__(self, pattern): + super().__init__() + self._pattern = pattern + + @staticmethod + def ofPattern(pattern): + return DateTimeFormatter(pattern) + + def format(self, temporal): + if isinstance(temporal, LocalDate): + return temporal.toString() + if isinstance(temporal, LocalTime): + return temporal.toString() + if isinstance(temporal, LocalDateTime): + return temporal.toString() + if isinstance(temporal, ZonedDateTime): + return temporal.toString() + if isinstance(temporal, Instant): + return temporal.toString() + return str(temporal) + + def parse(self, text, query=None): + if query is LocalDate or query is None: + return LocalDate.parse(text) + if query is LocalTime: + return LocalTime.parse(text) + if query is LocalDateTime: + return LocalDateTime.parse(text) + return text + + +DateTimeFormatter.ISO_LOCAL_DATE = DateTimeFormatter("yyyy-MM-dd") +DateTimeFormatter.ISO_LOCAL_TIME = DateTimeFormatter("HH:mm:ss") +DateTimeFormatter.ISO_LOCAL_DATE_TIME = DateTimeFormatter("yyyy-MM-ddTHH:mm:ss") +DateTimeFormatter.ISO_INSTANT = DateTimeFormatter("yyyy-MM-ddTHH:mm:ssZ") +DateTimeFormatter.ISO_ZONED_DATE_TIME = DateTimeFormatter("yyyy-MM-ddTHH:mm:ssZ") +DateTimeFormatter.ISO_OFFSET_DATE_TIME = DateTimeFormatter("yyyy-MM-ddTHH:mm:ssZ") + + +# ============================================================ +# DateTimeFormatterBuilder (stub) +# ============================================================ + +class DateTimeFormatterBuilder(Stub): + def __init__(self): + super().__init__() + self._pattern_parts = [] + + def appendValue(self, field, width=1): + return self + + def appendLiteral(self, literal): + return self + + def appendPattern(self, pattern): + self._pattern_parts.append(pattern) + return self + + def toFormatter(self): + return DateTimeFormatter("".join(self._pattern_parts)) + + +# ============================================================ +# TemporalAdjusters (stub) +# ============================================================ + +class TemporalAdjusters(Stub): + @staticmethod + def firstDayOfMonth(): + return lambda d: d.withDayOfMonth(1) + + @staticmethod + def lastDayOfMonth(): + return lambda d: d.withDayOfMonth(d.lengthOfMonth()) + + @staticmethod + def firstDayOfYear(): + return lambda d: d.withDayOfMonth(1).withMonth(1) + + @staticmethod + def lastDayOfYear(): + return lambda d: d.withDayOfMonth(31).withMonth(12) + + @staticmethod + def firstInMonth(day_of_week): + return lambda d: d + + @staticmethod + def next(day_of_week): + return lambda d: d.plusDays(1) \ No newline at end of file diff --git a/android_pyapi/java/util.py b/android_pyapi/java/util.py new file mode 100644 index 0000000..5273186 --- /dev/null +++ b/android_pyapi/java/util.py @@ -0,0 +1,3693 @@ +""" +Java java.util standard library APIs implemented in Python. +Android-pyApi: desktop Python translation of Android Java APIs. +""" + +from .._core import Stub +from .lang import RuntimeException +import heapq as _heapq +import bisect as _bisect +import datetime as _datetime +import uuid as _uuid +import random as _py_random +import math as _py_math +import copy as _copy +import re as _re +import io as _io +import threading as _threading +import time as _time +from typing import Any, Dict, List, Callable, Tuple, Iterable as _IterableType +import typing as _typing +from collections.abc import Iterable as _IterableABC + +__all__ = [ + "ArrayList", "LinkedList", "HashMap", "LinkedHashMap", "TreeMap", + "HashSet", "TreeSet", "LinkedHashSet", + "Collections", "Arrays", "Date", "Calendar", "GregorianCalendar", + "UUID", "StringTokenizer", "Optional", "Random", + "Properties", "EnumSet", "EnumMap", + "Iterator", "ListIterator", "Enumeration", + "Objects", "Locale", "BitSet", "PriorityQueue", + "Vector", "Stack", + "ConcurrentModificationException", "NoSuchElementException", + "EmptyStackException", "TooManyListenersException", + "MissingResourceException", "IllegalFormatException", + "DuplicateFormatFlagsException", "FormatFlagsConversionMismatchException", + "FormatterClosedException", +] + +# ============================================================ +# Exceptions +# ============================================================ + +# Define exception classes in correct dependency order. +# IllegalArgumentException comes before IllegalFormatException. +IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {}) + +ConcurrentModificationException = type( + "ConcurrentModificationException", (RuntimeException,), {} +) +NoSuchElementException = type("NoSuchElementException", (RuntimeException,), {}) +EmptyStackException = type("EmptyStackException", (RuntimeException,), {}) +TooManyListenersException = type("TooManyListenersException", (Exception,), {}) +MissingResourceException = type("MissingResourceException", (RuntimeException,), {}) +IllegalFormatException = type("IllegalFormatException", (IllegalArgumentException,), {}) +DuplicateFormatFlagsException = type( + "DuplicateFormatFlagsException", (IllegalFormatException,), {} +) +FormatFlagsConversionMismatchException = type( + "FormatFlagsConversionMismatchException", (IllegalFormatException,), {} +) + +# We need IllegalStateException for FormatterClosedException +from .lang import RuntimeException as _RuntimeException +IllegalStateException = type("IllegalStateException", (_RuntimeException,), {}) + +FormatterClosedException = type("FormatterClosedException", (IllegalStateException,), {}) +UnsupportedOperationException = type("UnsupportedOperationException", (RuntimeException,), {}) + +# ============================================================ +# Iterator / ListIterator / Enumeration +# ============================================================ + +class Iterator(Stub): + """java.util.Iterator""" + def __init__(self, data): + super().__init__() + self._data = list(data) + self._index = 0 + self._mod_count = 0 + + def hasNext(self) -> bool: + return self._index < len(self._data) + + def next(self): + if not self.hasNext(): + raise NoSuchElementException() + val = self._data[self._index] + self._index += 1 + return val + + def remove(self): + raise UnsupportedOperationException("remove") + + def forEachRemaining(self, action): + while self.hasNext(): + action(self.next()) + + +class ListIterator(Iterator): + """java.util.ListIterator""" + def __init__(self, data): + super().__init__(data) + + def hasPrevious(self) -> bool: + return self._index > 0 + + def previous(self): + if not self.hasPrevious(): + raise NoSuchElementException() + self._index -= 1 + return self._data[self._index] + + def nextIndex(self) -> int: + return self._index + + def previousIndex(self) -> int: + return self._index - 1 + + def set(self, obj): + self._data[self._index - 1] = obj + + def add(self, obj): + self._data.insert(self._index, obj) + self._index += 1 + + +class Enumeration(Stub): + """java.util.Enumeration""" + def __init__(self, data): + super().__init__() + self._it = iter(data) + + def hasMoreElements(self) -> bool: + try: + self._next = next(self._it) + return True + except StopIteration: + return False + + def nextElement(self): + if hasattr(self, '_next'): + val = self._next + del self._next + return val + return next(self._it) + + def asIterator(self) -> Iterator: + return Iterator(self._it) + + +# ============================================================ +# ArrayList +# ============================================================ + +class ArrayList(Stub): + """java.util.ArrayList — backed by Python list""" + def __init__(self, initial_capacity: Any = None): + super().__init__() + if initial_capacity is None: + self._data = [] + elif isinstance(initial_capacity, int): + self._data = [] + elif isinstance(initial_capacity, _IterableABC): + self._data = list(initial_capacity) + else: + self._data = [] + + def add(self, obj) -> bool: + self._data.append(obj) + return True + + def addAt(self, index: int, obj) -> None: + self._data.insert(index, obj) + + def addAll(self, c) -> bool: + if isinstance(c, ArrayList): + self._data.extend(c._data) + else: + self._data.extend(c) + return True + + def addAllAt(self, index: int, c) -> bool: + if isinstance(c, ArrayList): + self._data[index:index] = c._data + else: + self._data[index:index] = list(c) + return True + + def clear(self) -> None: + self._data.clear() + + def clone(self) -> 'ArrayList': + return ArrayList(self._data) + + def contains(self, obj) -> bool: + return obj in self._data + + def containsAll(self, c) -> bool: + if isinstance(c, ArrayList): + return all(x in self._data for x in c._data) + return all(x in self._data for x in c) + + def ensureCapacity(self, min_capacity: int) -> None: + pass # Python list handles resizing automatically + + def get(self, index: int): + return self._data[index] + + def indexOf(self, obj) -> int: + try: + return self._data.index(obj) + except ValueError: + return -1 + + def isEmpty(self) -> bool: + return len(self._data) == 0 + + def iterator(self) -> Iterator: + return Iterator(self._data) + + def listIterator(self) -> ListIterator: + return ListIterator(self._data) + + def lastIndexOf(self, obj) -> int: + try: + return len(self._data) - 1 - self._data[::-1].index(obj) + except ValueError: + return -1 + + def remove(self, obj) -> bool: + if obj in self._data: + self._data.remove(obj) + return True + return False + + def removeAt(self, index: int): + return self._data.pop(index) + + def removeAll(self, c) -> bool: + if isinstance(c, ArrayList): + items = c._data + else: + items = list(c) + old_len = len(self._data) + self._data = [x for x in self._data if x not in items] + return len(self._data) != old_len + + def retainAll(self, c) -> bool: + if isinstance(c, ArrayList): + items = set(c._data) + else: + items = set(c) + old_len = len(self._data) + self._data = [x for x in self._data if x in items] + return len(self._data) != old_len + + def set(self, index: int, obj): + old = self._data[index] + self._data[index] = obj + return old + + def size(self) -> int: + return len(self._data) + + def sort(self, key=None, reverse: bool = False) -> None: + self._data.sort(key=key, reverse=reverse) + + def subList(self, from_index: int, to_index: int) -> 'ArrayList': + return ArrayList(self._data[from_index:to_index]) + + def toArray(self, a=None): + if a is None: + return list(self._data) + if len(a) < len(self._data): + return list(self._data) + for i, v in enumerate(self._data): + a[i] = v + if len(self._data) < len(a): + a[len(self._data)] = None + return a + + def trimToSize(self) -> None: + pass + + def forEach(self, action) -> None: + for item in self._data: + action(item) + + def removeIf(self, predicate) -> bool: + old_len = len(self._data) + self._data = [x for x in self._data if not predicate(x)] + return len(self._data) != old_len + + def replaceAll(self, operator) -> None: + self._data = [operator(x) for x in self._data] + + def equals(self, other) -> bool: + if isinstance(other, ArrayList): + return self._data == other._data + return False + + def hashCode(self) -> int: + h = 1 + for v in self._data: + h = (31 * h + hash(v)) & 0x7FFFFFFF + return h + + def toString(self) -> str: + items = ", ".join(str(x) for x in self._data) + return f"[{items}]" + + def __len__(self): + return len(self._data) + + def __getitem__(self, idx): + return self._data[idx] + + def __setitem__(self, idx, val): + self._data[idx] = val + + def __delitem__(self, idx): + del self._data[idx] + + def __iter__(self): + return iter(self._data) + + def __repr__(self): + return self.toString() + + def __contains__(self, obj): + return obj in self._data + + def __add__(self, other): + if isinstance(other, ArrayList): + result = ArrayList(self._data) + result._data.extend(other._data) + return result + return NotImplemented + + def __eq__(self, other): + return self.equals(other) + + +# ============================================================ +# LinkedList +# ============================================================ + +class LinkedList(Stub): + """java.util.LinkedList — backed by Python list""" + def __init__(self, c=None): + super().__init__() + if c is None: + self._data = [] + elif isinstance(c, _IterableABC): + self._data = list(c) + else: + self._data = [] + + def add(self, obj) -> bool: + self._data.append(obj) + return True + + def addFirst(self, obj) -> None: + self._data.insert(0, obj) + + def addLast(self, obj) -> None: + self._data.append(obj) + + def addAt(self, index: int, obj) -> None: + self._data.insert(index, obj) + + def addAll(self, c) -> bool: + if isinstance(c, LinkedList): + self._data.extend(c._data) + else: + self._data.extend(c) + return True + + def clear(self) -> None: + self._data.clear() + + def clone(self) -> 'LinkedList': + return LinkedList(self._data) + + def contains(self, obj) -> bool: + return obj in self._data + + def descendingIterator(self) -> Iterator: + return Iterator(reversed(self._data)) + + def element(self): + if not self._data: + raise NoSuchElementException() + return self._data[0] + + def get(self, index: int): + return self._data[index] + + def getFirst(self): + if not self._data: + raise NoSuchElementException() + return self._data[0] + + def getLast(self): + if not self._data: + raise NoSuchElementException() + return self._data[-1] + + def indexOf(self, obj) -> int: + try: + return self._data.index(obj) + except ValueError: + return -1 + + def isEmpty(self) -> bool: + return len(self._data) == 0 + + def iterator(self) -> Iterator: + return Iterator(self._data) + + def lastIndexOf(self, obj) -> int: + try: + return len(self._data) - 1 - self._data[::-1].index(obj) + except ValueError: + return -1 + + def listIterator(self, index: int = 0) -> ListIterator: + li = ListIterator(self._data) + li._index = index + return li + + def offer(self, obj) -> bool: + self._data.append(obj) + return True + + def offerFirst(self, obj) -> bool: + self._data.insert(0, obj) + return True + + def offerLast(self, obj) -> bool: + self._data.append(obj) + return True + + def peek(self): + return self._data[0] if self._data else None + + def peekFirst(self): + return self._data[0] if self._data else None + + def peekLast(self): + return self._data[-1] if self._data else None + + def poll(self): + return self._data.pop(0) if self._data else None + + def pollFirst(self): + return self._data.pop(0) if self._data else None + + def pollLast(self): + return self._data.pop() if self._data else None + + def pop(self): + if not self._data: + raise NoSuchElementException() + return self._data.pop() + + def push(self, obj) -> None: + self._data.insert(0, obj) + + def remove(self, obj) -> bool: + if obj in self._data: + self._data.remove(obj) + return True + return False + + def removeAt(self, index: int): + return self._data.pop(index) + + def removeFirst(self): + if not self._data: + raise NoSuchElementException() + return self._data.pop(0) + + def removeFirstOccurrence(self, obj) -> bool: + try: + idx = self._data.index(obj) + self._data.pop(idx) + return True + except ValueError: + return False + + def removeLast(self): + if not self._data: + raise NoSuchElementException() + return self._data.pop() + + def removeLastOccurrence(self, obj) -> bool: + try: + idx = len(self._data) - 1 - self._data[::-1].index(obj) + self._data.pop(idx) + return True + except ValueError: + return False + + def set(self, index: int, obj): + old = self._data[index] + self._data[index] = obj + return old + + def size(self) -> int: + return len(self._data) + + def toArray(self, a=None): + if a is None: + return list(self._data) + if len(a) < len(self._data): + return list(self._data) + for i, v in enumerate(self._data): + a[i] = v + if len(self._data) < len(a): + a[len(self._data)] = None + return a + + def forEach(self, action) -> None: + for item in self._data: + action(item) + + def equals(self, other) -> bool: + if isinstance(other, LinkedList): + return self._data == other._data + return False + + def hashCode(self) -> int: + h = 1 + for v in self._data: + h = (31 * h + hash(v)) & 0x7FFFFFFF + return h + + def toString(self) -> str: + items = ", ".join(str(x) for x in self._data) + return f"[{items}]" + + def __len__(self): + return len(self._data) + + def __getitem__(self, idx): + return self._data[idx] + + def __iter__(self): + return iter(self._data) + + def __repr__(self): + return self.toString() + + def __eq__(self, other): + return self.equals(other) + + +# ============================================================ +# HashMap +# ============================================================ + +class HashMap(Stub): + """java.util.HashMap — backed by Python dict""" + def __init__(self, initial_capacity: Any = None, load_factor: float = 0.75): + super().__init__() + self._data: Dict = {} + if initial_capacity is not None and not isinstance(initial_capacity, (int, float)): + if isinstance(initial_capacity, HashMap): + self._data.update(initial_capacity._data) + elif isinstance(initial_capacity, dict): + self._data.update(initial_capacity) + elif isinstance(initial_capacity, _IterableABC): + for item in initial_capacity: + if hasattr(item, 'getKey') and hasattr(item, 'getValue'): + k, v = item.getKey(), item.getValue() + elif isinstance(item, tuple) and len(item) >= 2: + k, v = item[0], item[1] + else: + continue + self._data[k] = v + + def clear(self) -> None: + self._data.clear() + + def clone(self) -> 'HashMap': + return HashMap(self._data) + + def compute(self, key, remapping_function): + old = self._data.get(key) + new_val = remapping_function(key, old) + if new_val is not None: + self._data[key] = new_val + return new_val + self._data.pop(key, None) + return None + + def computeIfAbsent(self, key, mapping_function): + if key not in self._data: + new_val = mapping_function(key) + if new_val is not None: + self._data[key] = new_val + return new_val + return self._data.get(key) + + def computeIfPresent(self, key, remapping_function): + if key in self._data: + new_val = remapping_function(key, self._data[key]) + if new_val is not None: + self._data[key] = new_val + return new_val + self._data.pop(key, None) + return None + + def containsKey(self, key) -> bool: + return key in self._data + + def containsValue(self, value) -> bool: + return value in self._data.values() + + def entrySet(self) -> set: + return self._data.items() + + def forEach(self, action) -> None: + for k, v in self._data.items(): + action(k, v) + + def get(self, key): + return self._data.get(key) + + def getOrDefault(self, key, default): + return self._data.get(key, default) + + def isEmpty(self) -> bool: + return len(self._data) == 0 + + def keySet(self) -> set: + return set(self._data.keys()) + + def merge(self, key, value, remapping_function): + old = self._data.get(key) + if old is None: + self._data[key] = value + return value + new_val = remapping_function(old, value) + if new_val is not None: + self._data[key] = new_val + return new_val + self._data.pop(key, None) + return None + + def put(self, key, value): + old = self._data.get(key) + self._data[key] = value + return old + + def putAll(self, m) -> None: + if isinstance(m, HashMap): + self._data.update(m._data) + else: + self._data.update(m) + + def putIfAbsent(self, key, value): + if key not in self._data: + self._data[key] = value + return None + return self._data[key] + + def remove(self, key, value=None) -> bool: + if value is None: + return self._data.pop(key, None) is not None or key in self._data + if key in self._data and self._data[key] == value: + del self._data[key] + return True + return False + + def replace(self, key, old_value=None, new_value=None): + if old_value is None and new_value is None: + return None + if new_value is None: + # replace(key, value) form + if key in self._data: + old = self._data[key] + self._data[key] = old_value # old_value is actually new value here + return old + return None + # replace(key, oldValue, newValue) form + if key in self._data and self._data[key] == old_value: + self._data[key] = new_value + return True + return False + + def replaceAll(self, function) -> None: + for k in list(self._data.keys()): + self._data[k] = function(k, self._data[k]) + + def size(self) -> int: + return len(self._data) + + def values(self): + return list(self._data.values()) + + def equals(self, other) -> bool: + if isinstance(other, HashMap): + return self._data == other._data + return False + + def hashCode(self) -> int: + h = 0 + for k, v in self._data.items(): + h = (h + (hash(k) ^ hash(v))) & 0x7FFFFFFF + return h + + def toString(self) -> str: + items = ", ".join(f"{k}={v}" for k, v in self._data.items()) + return f"{{{items}}}" + + def __len__(self): + return len(self._data) + + def __getitem__(self, key): + return self._data[key] + + def __setitem__(self, key, value): + self._data[key] = value + + def __delitem__(self, key): + del self._data[key] + + def __iter__(self): + return iter(self._data) + + def __contains__(self, key): + return key in self._data + + def __repr__(self): + return self.toString() + + def __eq__(self, other): + return self.equals(other) + + +# ============================================================ +# LinkedHashMap +# ============================================================ + +class LinkedHashMap(HashMap): + """java.util.LinkedHashMap — backed by dict (preserves order in Python 3.7+)""" + def __init__(self, initial_capacity: Any = None, load_factor: float = 0.75, + access_order: bool = False): + super().__init__(initial_capacity, load_factor) + self._access_order = access_order + + def get(self, key): + val = self._data.get(key) + if val is not None and self._access_order: + # Move to end (most recently accessed) by delete/reinsert + del self._data[key] + self._data[key] = val + return val + + def getOrDefault(self, key, default): + val = self._data.get(key, default) + if key in self._data and self._access_order: + del self._data[key] + self._data[key] = val + return val + + def put(self, key, value): + old = self._data.get(key) + if key in self._data: + del self._data[key] + self._data[key] = value + return old + + def removeEldestEntry(self, eldest) -> bool: + return False + + def eldest(self): + if not self._data: + return None + key = next(iter(self._data)) + return (key, self._data[key]) + + +# ============================================================ +# TreeMap +# ============================================================ + +class TreeMap(Stub): + """java.util.TreeMap — sorted map using Python's sorted()""" + def __init__(self, comparator=None, m=None): + super().__init__() + self._data: Dict = {} + self._comparator = comparator + if m is not None: + if isinstance(m, TreeMap): + self._data.update(m._data) + elif isinstance(m, dict): + self._data.update(m) + elif isinstance(m, _IterableABC): + for item in m: + if isinstance(item, tuple) and len(item) >= 2: + self._data[item[0]] = item[1] + + def _sorted_keys(self): + key_fn = self._comparator if self._comparator else None + return sorted(self._data.keys(), key=key_fn) + + def _get_entry_by_key(self, key): + if key in self._data: + return (key, self._data[key]) + return None + + def clear(self) -> None: + self._data.clear() + + def clone(self) -> 'TreeMap': + return TreeMap(self._comparator, self._data) + + def comparator(self): + return self._comparator + + def containsKey(self, key) -> bool: + return key in self._data + + def containsValue(self, value) -> bool: + return value in self._data.values() + + def ceilingKey(self, key): + keys = self._sorted_keys() + for k in keys: + if (self._comparator(k, key) >= 0 if self._comparator else k >= key): + return k + return None + + def ceilingEntry(self, key): + k = self.ceilingKey(key) + return (k, self._data[k]) if k is not None else None + + def floorKey(self, key): + keys = self._sorted_keys() + for k in reversed(keys): + if (self._comparator(k, key) <= 0 if self._comparator else k <= key): + return k + return None + + def floorEntry(self, key): + k = self.floorKey(key) + return (k, self._data[k]) if k is not None else None + + def higherKey(self, key): + keys = self._sorted_keys() + for k in keys: + if (self._comparator(k, key) > 0 if self._comparator else k > key): + return k + return None + + def higherEntry(self, key): + k = self.higherKey(key) + return (k, self._data[k]) if k is not None else None + + def lowerKey(self, key): + keys = self._sorted_keys() + for k in reversed(keys): + if (self._comparator(k, key) < 0 if self._comparator else k < key): + return k + return None + + def lowerEntry(self, key): + k = self.lowerKey(key) + return (k, self._data[k]) if k is not None else None + + def firstKey(self): + if not self._data: + raise NoSuchElementException() + return self._sorted_keys()[0] + + def firstEntry(self): + k = self.firstKey() + return (k, self._data[k]) + + def lastKey(self): + if not self._data: + raise NoSuchElementException() + return self._sorted_keys()[-1] + + def lastEntry(self): + k = self.lastKey() + return (k, self._data[k]) + + def pollFirstEntry(self): + if not self._data: + return None + k = self.firstKey() + v = self._data.pop(k) + return (k, v) + + def pollLastEntry(self): + if not self._data: + return None + k = self.lastKey() + v = self._data.pop(k) + return (k, v) + + def entrySet(self): + return [(k, self._data[k]) for k in self._sorted_keys()] + + def forEach(self, action) -> None: + for k in self._sorted_keys(): + action(k, self._data[k]) + + def get(self, key): + return self._data.get(key) + + def getOrDefault(self, key, default): + return self._data.get(key, default) + + def headMap(self, to_key, inclusive: bool = False) -> 'TreeMap': + result = TreeMap(self._comparator) + for k in self._sorted_keys(): + cmp = self._comparator(k, to_key) if self._comparator else (k < to_key) + if cmp or (inclusive and (self._comparator(k, to_key) == 0 if self._comparator else k == to_key)): + result._data[k] = self._data[k] + elif not inclusive and (self._comparator(k, to_key) < 0 if self._comparator else k < to_key): + result._data[k] = self._data[k] + else: + break + return result + + def tailMap(self, from_key, inclusive: bool = True) -> 'TreeMap': + result = TreeMap(self._comparator) + started = False + for k in self._sorted_keys(): + cmp = self._comparator(k, from_key) if self._comparator else (k >= from_key) + if cmp or (inclusive and (self._comparator(k, from_key) == 0 if self._comparator else k == from_key)): + started = True + if started: + result._data[k] = self._data[k] + return result + + def subMap(self, from_key, to_key, from_inclusive: bool = True, to_inclusive: bool = False) -> 'TreeMap': + result = TreeMap(self._comparator) + for k in self._sorted_keys(): + cmp_from = self._comparator(k, from_key) if self._comparator else (k >= from_key if from_inclusive else k > from_key) + cmp_to = self._comparator(k, to_key) if self._comparator else (k <= to_key if to_inclusive else k < to_key) + if cmp_from and cmp_to: + result._data[k] = self._data[k] + return result + + def isEmpty(self) -> bool: + return len(self._data) == 0 + + def keySet(self): + return self._sorted_keys() + + def put(self, key, value): + old = self._data.get(key) + self._data[key] = value + return old + + def putAll(self, m) -> None: + if isinstance(m, TreeMap): + self._data.update(m._data) + else: + self._data.update(m) + + def putIfAbsent(self, key, value): + if key not in self._data: + self._data[key] = value + return None + return self._data[key] + + def remove(self, key): + return self._data.pop(key, None) + + def replace(self, key, old_value=None, new_value=None): + if new_value is None: + if key in self._data: + old = self._data[key] + self._data[key] = old_value + return old + return None + if key in self._data and self._data[key] == old_value: + self._data[key] = new_value + return True + return False + + def size(self) -> int: + return len(self._data) + + def values(self): + return [self._data[k] for k in self._sorted_keys()] + + def navigableKeySet(self): + return self._sorted_keys() + + def descendingKeySet(self): + return list(reversed(self._sorted_keys())) + + def descendingMap(self) -> 'TreeMap': + result = TreeMap(self._comparator) + for k in reversed(self._sorted_keys()): + result._data[k] = self._data[k] + return result + + def equals(self, other) -> bool: + if isinstance(other, TreeMap): + return self._data == other._data + return False + + def hashCode(self) -> int: + h = 0 + for k, v in self._data.items(): + h = (h + (hash(k) ^ hash(v))) & 0x7FFFFFFF + return h + + def toString(self) -> str: + items = ", ".join(f"{k}={v}" for k in self._data.items()) + return f"{{{items}}}" + + def __len__(self): + return len(self._data) + + def __getitem__(self, key): + return self._data[key] + + def __setitem__(self, key, value): + self._data[key] = value + + def __delitem__(self, key): + del self._data[key] + + def __iter__(self): + return iter(self._sorted_keys()) + + def __repr__(self): + return self.toString() + + def __eq__(self, other): + return self.equals(other) + + +# ============================================================ +# HashSet +# ============================================================ + +class HashSet(Stub): + """java.util.HashSet — backed by Python set""" + def __init__(self, c=None): + super().__init__() + if c is None: + self._data: set = set() + elif isinstance(c, _IterableABC): + self._data = set(c) + else: + self._data = set() + + def add(self, obj) -> bool: + if obj in self._data: + return False + self._data.add(obj) + return True + + def addAll(self, c) -> bool: + old_size = len(self._data) + if isinstance(c, HashSet): + self._data.update(c._data) + elif isinstance(c, set): + self._data.update(c) + else: + self._data.update(c) + return len(self._data) != old_size + + def clear(self) -> None: + self._data.clear() + + def clone(self) -> 'HashSet': + return HashSet(self._data) + + def contains(self, obj) -> bool: + return obj in self._data + + def containsAll(self, c) -> bool: + if isinstance(c, HashSet): + return all(x in self._data for x in c._data) + return all(x in self._data for x in c) + + def isEmpty(self) -> bool: + return len(self._data) == 0 + + def iterator(self) -> Iterator: + return Iterator(list(self._data)) + + def remove(self, obj) -> bool: + if obj in self._data: + self._data.remove(obj) + return True + return False + + def removeAll(self, c) -> bool: + old_size = len(self._data) + if isinstance(c, HashSet): + self._data.difference_update(c._data) + else: + self._data.difference_update(c) + return len(self._data) != old_size + + def retainAll(self, c) -> bool: + old_size = len(self._data) + if isinstance(c, HashSet): + self._data.intersection_update(c._data) + else: + self._data.intersection_update(c) + return len(self._data) != old_size + + def size(self) -> int: + return len(self._data) + + def toArray(self, a=None): + items = list(self._data) + if a is None: + return items + if len(a) < len(items): + return items + for i, v in enumerate(items): + a[i] = v + if len(items) < len(a): + a[len(items)] = None + return a + + def forEach(self, action) -> None: + for item in list(self._data): + action(item) + + def equals(self, other) -> bool: + if isinstance(other, HashSet): + return self._data == other._data + return False + + def hashCode(self) -> int: + h = 0 + for v in self._data: + h = (h + hash(v)) & 0x7FFFFFFF + return h + + def toString(self) -> str: + items = ", ".join(str(x) for x in self._data) + return f"[{items}]" + + def __len__(self): + return len(self._data) + + def __iter__(self): + return iter(self._data) + + def __contains__(self, obj): + return obj in self._data + + def __repr__(self): + return self.toString() + + def __eq__(self, other): + return self.equals(other) + + +# ============================================================ +# LinkedHashSet +# ============================================================ + +class LinkedHashSet(HashSet): + """java.util.LinkedHashSet — ordered set (preserves insertion order)""" + def __init__(self, c=None): + # dict keys preserve insertion order in Python 3.7+ + self._order: Dict[Any, None] = {} + if c is not None: + if isinstance(c, _IterableABC): + for item in c: + self._order[item] = None + self._data = set(self._order.keys()) + + def add(self, obj) -> bool: + if obj in self._order: + return False + self._order[obj] = None + self._data.add(obj) + return True + + def remove(self, obj) -> bool: + if obj in self._order: + del self._order[obj] + self._data.discard(obj) + return True + return False + + def clear(self) -> None: + self._order.clear() + self._data.clear() + + def iterator(self) -> Iterator: + return Iterator(list(self._order.keys())) + + def toArray(self, a=None): + items = list(self._order.keys()) + if a is None: + return items + if len(a) < len(items): + return items + for i, v in enumerate(items): + a[i] = v + if len(items) < len(a): + a[len(items)] = None + return a + + def forEach(self, action) -> None: + for item in list(self._order.keys()): + action(item) + + def __iter__(self): + return iter(self._order.keys()) + + +# ============================================================ +# TreeSet +# ============================================================ + +class TreeSet(Stub): + """java.util.TreeSet — sorted set""" + def __init__(self, comparator=None, c=None): + super().__init__() + self._data: set = set() + self._comparator = comparator + if c is not None: + if isinstance(c, _IterableABC): + self._data = set(c) + + def _sorted(self): + key_fn = self._comparator if self._comparator else None + return sorted(self._data, key=key_fn) + + def add(self, obj) -> bool: + if obj in self._data: + return False + self._data.add(obj) + return True + + def addAll(self, c) -> bool: + old_size = len(self._data) + if isinstance(c, TreeSet): + self._data.update(c._data) + else: + self._data.update(c) + return len(self._data) != old_size + + def ceiling(self, obj): + sorted_items = self._sorted() + for item in sorted_items: + if (self._comparator(item, obj) >= 0 if self._comparator else item >= obj): + return item + return None + + def floor(self, obj): + sorted_items = self._sorted() + for item in reversed(sorted_items): + if (self._comparator(item, obj) <= 0 if self._comparator else item <= obj): + return item + return None + + def higher(self, obj): + sorted_items = self._sorted() + for item in sorted_items: + if (self._comparator(item, obj) > 0 if self._comparator else item > obj): + return item + return None + + def lower(self, obj): + sorted_items = self._sorted() + for item in reversed(sorted_items): + if (self._comparator(item, obj) < 0 if self._comparator else item < obj): + return item + return None + + def clear(self) -> None: + self._data.clear() + + def clone(self) -> 'TreeSet': + return TreeSet(self._comparator, self._data) + + def comparator(self): + return self._comparator + + def contains(self, obj) -> bool: + return obj in self._data + + def containsAll(self, c) -> bool: + if isinstance(c, TreeSet): + return all(x in self._data for x in c._data) + return all(x in self._data for x in c) + + def first(self): + if not self._data: + raise NoSuchElementException() + return self._sorted()[0] + + def last(self): + if not self._data: + raise NoSuchElementException() + return self._sorted()[-1] + + def pollFirst(self): + if not self._data: + return None + val = self._sorted()[0] + self._data.discard(val) + return val + + def pollLast(self): + if not self._data: + return None + val = self._sorted()[-1] + self._data.discard(val) + return val + + def headSet(self, to_element, inclusive: bool = False) -> 'TreeSet': + result = TreeSet(self._comparator) + for item in self._data: + cmp = self._comparator(item, to_element) if self._comparator else (item < to_element) + if cmp or (inclusive and item == to_element): + result._data.add(item) + return result + + def tailSet(self, from_element, inclusive: bool = True) -> 'TreeSet': + result = TreeSet(self._comparator) + for item in self._data: + cmp = self._comparator(item, from_element) if self._comparator else (item > from_element) + if cmp or (inclusive and item == from_element): + result._data.add(item) + return result + + def subSet(self, from_element, to_element, + from_inclusive: bool = True, to_inclusive: bool = False) -> 'TreeSet': + result = TreeSet(self._comparator) + for item in self._data: + cmp_from = self._comparator(item, from_element) if self._comparator else ( + item >= from_element if from_inclusive else item > from_element) + cmp_to = self._comparator(item, to_element) if self._comparator else ( + item <= to_element if to_inclusive else item < to_element) + if cmp_from and cmp_to: + result._data.add(item) + return result + + def descendingIterator(self) -> Iterator: + return Iterator(reversed(self._sorted())) + + def descendingSet(self) -> 'TreeSet': + result = TreeSet(self._comparator) + result._data = set(self._data) + return result + + def isEmpty(self) -> bool: + return len(self._data) == 0 + + def iterator(self) -> Iterator: + return Iterator(self._sorted()) + + def remove(self, obj) -> bool: + if obj in self._data: + self._data.discard(obj) + return True + return False + + def removeAll(self, c) -> bool: + old_size = len(self._data) + if isinstance(c, TreeSet): + self._data.difference_update(c._data) + else: + self._data.difference_update(c) + return len(self._data) != old_size + + def retainAll(self, c) -> bool: + old_size = len(self._data) + if isinstance(c, TreeSet): + self._data.intersection_update(c._data) + else: + self._data.intersection_update(c) + return len(self._data) != old_size + + def size(self) -> int: + return len(self._data) + + def toArray(self, a=None): + items = self._sorted() + if a is None: + return items + if len(a) < len(items): + return items + for i, v in enumerate(items): + a[i] = v + if len(items) < len(a): + a[len(items)] = None + return a + + def forEach(self, action) -> None: + for item in self._sorted(): + action(item) + + def equals(self, other) -> bool: + if isinstance(other, TreeSet): + return self._data == other._data + return False + + def hashCode(self) -> int: + h = 0 + for v in self._data: + h = (h + hash(v)) & 0x7FFFFFFF + return h + + def toString(self) -> str: + items = ", ".join(str(x) for x in self._sorted()) + return f"[{items}]" + + def __len__(self): + return len(self._data) + + def __iter__(self): + return iter(self._sorted()) + + def __contains__(self, obj): + return obj in self._data + + def __repr__(self): + return self.toString() + + def __eq__(self, other): + return self.equals(other) + + +# ============================================================ +# Collections +# ============================================================ + +class Collections: + """java.util.Collections — static utility methods""" + EMPTY_LIST = [] + EMPTY_SET = set() + EMPTY_MAP = {} + + @staticmethod + def sort(data, key=None, reverse: bool = False) -> None: + if key is not None: + if isinstance(data, ArrayList): + data._data.sort(key=key, reverse=reverse) + elif isinstance(data, Vector): + data._data.sort(key=key, reverse=reverse) + else: + data.sort(key=key, reverse=reverse) + else: + data.sort(reverse=reverse) + + @staticmethod + def reverse(data) -> None: + if isinstance(data, ArrayList): + data._data.reverse() + elif isinstance(data, Vector): + data._data.reverse() + else: + data.reverse() + + @staticmethod + def shuffle(data, rnd: _typing.Optional['Random'] = None) -> None: + if isinstance(data, ArrayList): + lst = data._data + elif isinstance(data, Vector): + lst = data._data + else: + lst = data + if rnd: + _py_random.shuffle(lst) + else: + _py_random.shuffle(lst) + + @staticmethod + def swap(data, i: int, j: int) -> None: + if isinstance(data, ArrayList): + data._data[i], data._data[j] = data._data[j], data._data[i] + elif isinstance(data, Vector): + data._data[i], data._data[j] = data._data[j], data._data[i] + else: + data[i], data[j] = data[j], data[i] + + @staticmethod + def fill(data, obj) -> None: + if isinstance(data, ArrayList): + for i in range(len(data._data)): + data._data[i] = obj + elif isinstance(data, Vector): + for i in range(len(data._data)): + data._data[i] = obj + else: + for i in range(len(data)): + data[i] = obj + + @staticmethod + def copy(dest, src) -> None: + if isinstance(dest, ArrayList) and isinstance(src, ArrayList): + dest._data[:len(src._data)] = src._data[:] + elif isinstance(dest, Vector) and isinstance(src, Vector): + dest._data[:len(src._data)] = src._data[:] + else: + dest[:len(src)] = src[:] + + @staticmethod + def min(coll, comp=None): + if comp: + return min(coll, key=comp) + return min(coll) + + @staticmethod + def max(coll, comp=None): + if comp: + return max(coll, key=comp) + return max(coll) + + @staticmethod + def rotate(data, distance: int) -> None: + if isinstance(data, ArrayList): + lst = data._data + elif isinstance(data, Vector): + lst = data._data + else: + lst = data + n = len(lst) + if n == 0: + return + d = distance % n + lst[:] = lst[-d:] + lst[:-d] + + @staticmethod + def indexOfSubList(source, target) -> int: + if isinstance(source, ArrayList): + src = source._data + else: + src = list(source) + if isinstance(target, ArrayList): + tgt = target._data + else: + tgt = list(target) + for i in range(len(src) - len(tgt) + 1): + if src[i:i + len(tgt)] == tgt: + return i + return -1 + + @staticmethod + def lastIndexOfSubList(source, target) -> int: + if isinstance(source, ArrayList): + src = source._data + else: + src = list(source) + if isinstance(target, ArrayList): + tgt = target._data + else: + tgt = list(target) + for i in range(len(src) - len(tgt), -1, -1): + if src[i:i + len(tgt)] == tgt: + return i + return -1 + + @staticmethod + def replaceAll(data, old_val, new_val) -> bool: + if isinstance(data, ArrayList): + lst = data._data + elif isinstance(data, Vector): + lst = data._data + else: + lst = data + found = False + for i, v in enumerate(lst): + if v == old_val: + lst[i] = new_val + found = True + return found + + @staticmethod + def binarySearch(data, key): + if isinstance(data, ArrayList): + lst = data._data + else: + lst = list(data) + idx = _bisect.bisect_left(lst, key) + if idx < len(lst) and lst[idx] == key: + return idx + return -1 + + @staticmethod + def disjoint(c1, c2) -> bool: + set1 = set(c1) + set2 = set(c2) + return set1.isdisjoint(set2) + + @staticmethod + def frequency(c, obj) -> int: + count = 0 + for item in c: + if item == obj: + count += 1 + return count + + @staticmethod + def nCopies(n: int, obj) -> list: + return [obj] * n + + @staticmethod + def singleton(obj) -> set: + return {obj} + + @staticmethod + def singletonList(obj) -> list: + return [obj] + + @staticmethod + def singletonMap(key, value) -> dict: + return {key: value} + + @staticmethod + def unmodifiableList(data) -> list: + if isinstance(data, ArrayList): + return tuple(data._data) + return tuple(data) + + @staticmethod + def unmodifiableSet(data) -> frozenset: + if isinstance(data, HashSet): + return frozenset(data._data) + return frozenset(data) + + @staticmethod + def unmodifiableMap(data) -> dict: + if isinstance(data, HashMap): + return dict(data._data) + return dict(data) + + @staticmethod + def synchronizedList(data): + lock = _threading.Lock() + + class _SyncList: + def __init__(self, lst): + self._lock = lock + self._lst = lst + + def __getattr__(self, name): + with self._lock: + return getattr(self._lst, name) + + def add(self, obj): + with self._lock: + return self._lst.add(obj) + + def get(self, idx): + with self._lock: + return self._lst[idx] + + def set(self, idx, val): + with self._lock: + old = self._lst[idx] + self._lst[idx] = val + return old + + def remove(self, obj): + with self._lock: + return self._lst.remove(obj) + + def size(self): + with self._lock: + return len(self._lst) + + def __len__(self): + with self._lock: + return len(self._lst) + + def __getitem__(self, idx): + with self._lock: + return self._lst[idx] + + def __setitem__(self, idx, val): + with self._lock: + self._lst[idx] = val + + def __iter__(self): + with self._lock: + return iter(list(self._lst)) + + return _SyncList(data) + + @staticmethod + def synchronizedSet(data): + lock = _threading.Lock() + + class _SyncSet: + def __init__(self, s): + self._lock = lock + self._s = s + + def add(self, obj): + with self._lock: + return self._s.add(obj) + + def remove(self, obj): + with self._lock: + return self._s.remove(obj) + + def __contains__(self, obj): + with self._lock: + return obj in self._s + + def __iter__(self): + with self._lock: + return iter(list(self._s)) + + def __len__(self): + with self._lock: + return len(self._s) + + return _SyncSet(data) + + @staticmethod + def synchronizedMap(data): + lock = _threading.Lock() + + class _SyncMap: + def __init__(self, m): + self._lock = lock + self._m = m + + def put(self, k, v): + with self._lock: + return self._m.put(k, v) + + def get(self, k): + with self._lock: + return self._m.get(k) + + def remove(self, k): + with self._lock: + return self._m.remove(k) + + def __getitem__(self, k): + with self._lock: + return self._m[k] + + def __setitem__(self, k, v): + with self._lock: + self._m[k] = v + + def __contains__(self, k): + with self._lock: + return k in self._m + + def __len__(self): + with self._lock: + return len(self._m) + + def keys(self): + with self._lock: + return list(self._m.keys()) + + return _SyncMap(data) + + @staticmethod + def enumaration(c) -> Enumeration: + return Enumeration(c) + + @staticmethod + def list(enum: Enumeration) -> ArrayList: + items = [] + while enum.hasMoreElements(): + items.append(enum.nextElement()) + return ArrayList(items) + + @staticmethod + def newSetFromMap(m) -> HashSet: + class _SetFromMap(HashSet): + def __init__(self, backing_map): + super().__init__() + self._backing = backing_map + + def add(self, obj): + return self._backing.put(obj, True) is None + + def iterator(self): + return Iterator(self._backing.keySet()) + + def size(self): + return self._backing.size() + + def remove(self, obj): + return self._backing.remove(obj) is not None + + def contains(self, obj): + return self._backing.containsKey(obj) + + def clear(self): + self._backing.clear() + + return _SetFromMap(m) + + @staticmethod + def asLifoQueue(deque) -> 'Collections._LifoQueue': + class _LifoQueue: + def __init__(self, dq): + self._dq = dq + + def add(self, e): + self._dq.addFirst(e) + return True + + def offer(self, e): + return self.add(e) + + def remove(self): + if len(self._dq) == 0: + raise NoSuchElementException() + return self._dq.removeFirst() + + def poll(self): + return self._dq.pollFirst() + + def element(self): + if len(self._dq) == 0: + raise NoSuchElementException() + return self._dq.getFirst() + + def peek(self): + return self._dq.peekFirst() + + def size(self): + return self._dq.size() + + def isEmpty(self): + return self._dq.isEmpty() + + return _LifoQueue(deque) + + +# ============================================================ +# Arrays +# ============================================================ + +class Arrays: + """java.util.Arrays — static utility methods""" + @staticmethod + def asList(*args) -> ArrayList: + if len(args) == 1 and isinstance(args[0], (list, tuple)): + return ArrayList(args[0]) + return ArrayList(list(args)) + + @staticmethod + def sort(a, from_index: int = 0, to_index: int = None) -> None: + if to_index is None: + a.sort() + else: + a[from_index:to_index] = sorted(a[from_index:to_index]) + + @staticmethod + def parallelSort(a, from_index: int = 0, to_index: int = None) -> None: + Arrays.sort(a, from_index, to_index) + + @staticmethod + def binarySearch(a, key, from_index: int = 0, to_index: int = None) -> int: + if to_index is None: + lst = a + else: + lst = a[from_index:to_index] + idx = _bisect.bisect_left(lst, key) + if idx < len(lst) and lst[idx] == key: + return idx + from_index + return -(idx + from_index + 1) + + @staticmethod + def fill(a, val, from_index: int = 0, to_index: int = None) -> None: + if to_index is None: + for i in range(len(a)): + a[i] = val + else: + for i in range(from_index, to_index): + a[i] = val + + @staticmethod + def copyOf(original, new_length: int) -> list: + return list(original[:new_length]) + [None] * max(0, new_length - len(original)) + + @staticmethod + def copyOfRange(original, from_index: int, to_index: int) -> list: + return list(original[from_index:to_index]) + + @staticmethod + def equals(a, b) -> bool: + if len(a) != len(b): + return False + return all(x == y for x, y in zip(a, b)) + + @staticmethod + def deepEquals(a, b) -> bool: + if len(a) != len(b): + return False + return all(_deep_eq(x, y) for x, y in zip(a, b)) + + @staticmethod + def hashCode(a) -> int: + if a is None: + return 0 + h = 1 + for v in a: + h = (31 * h + hash(v)) & 0x7FFFFFFF + return h + + @staticmethod + def deepHashCode(a) -> int: + if a is None: + return 0 + h = 1 + for v in a: + if isinstance(v, (list, tuple)): + h = (31 * h + Arrays.deepHashCode(v)) & 0x7FFFFFFF + else: + h = (31 * h + hash(v)) & 0x7FFFFFFF + return h + + @staticmethod + def toString(a) -> str: + if a is None: + return "null" + return "[" + ", ".join(str(x) for x in a) + "]" + + @staticmethod + def deepToString(a) -> str: + if a is None: + return "null" + return "[" + ", ".join(_deep_str(x) for x in a) + "]" + + @staticmethod + def stream(a) -> 'Arrays._ArrayStream': + class _ArrayStream: + def __init__(self, arr): + self._arr = arr + self._idx = 0 + + def filter(self, pred): + return _ArrayStream([x for x in self._arr if pred(x)]) + + def map(self, func): + return _ArrayStream([func(x) for x in self._arr]) + + def forEach(self, action): + for x in self._arr: + action(x) + + def toArray(self): + return list(self._arr) + + def count(self): + return len(self._arr) + + return _ArrayStream(a) + + @staticmethod + def setAll(a, generator) -> None: + for i in range(len(a)): + a[i] = generator(i) + + @staticmethod + def parallelSetAll(a, generator) -> None: + Arrays.setAll(a, generator) + + @staticmethod + def spliterator(a) -> Iterator: + return Iterator(a) + + +def _deep_eq(x, y) -> bool: + if isinstance(x, (list, tuple)) and isinstance(y, (list, tuple)): + return Arrays.deepEquals(x, y) + return x == y + + +def _deep_str(x) -> str: + if isinstance(x, (list, tuple)): + return Arrays.deepToString(x) + return str(x) + + +# ============================================================ +# Date +# ============================================================ + +class Date(Stub): + """java.util.Date — wraps Python datetime""" + def __init__(self, *args): + super().__init__() + if len(args) == 0: + self._dt = _datetime.datetime.now() + elif len(args) == 1: + if isinstance(args[0], (int, float)): + self._dt = _datetime.datetime.fromtimestamp(args[0] / 1000.0) + elif isinstance(args[0], str): + self._dt = _datetime.datetime.fromisoformat(args[0]) + elif isinstance(args[0], _datetime.datetime): + self._dt = args[0] + elif isinstance(args[0], Date): + self._dt = args[0]._dt + else: + self._dt = _datetime.datetime.now() + elif len(args) >= 6: + year = args[0] - 1900 + month = args[1] + day = args[2] + hour = args[3] if len(args) > 3 else 0 + minute = args[4] if len(args) > 4 else 0 + second = args[5] if len(args) > 5 else 0 + self._dt = _datetime.datetime(year + 1900, month + 1, day, hour, minute, second) + else: + self._dt = _datetime.datetime.now() + + def getTime(self) -> int: + return int(self._dt.timestamp() * 1000) + + def setTime(self, time_millis: int) -> None: + self._dt = _datetime.datetime.fromtimestamp(time_millis / 1000.0) + + def before(self, when: 'Date') -> bool: + return self._dt < when._dt + + def after(self, when: 'Date') -> bool: + return self._dt > when._dt + + def compareTo(self, another: 'Date') -> int: + return (self._dt > another._dt) - (self._dt < another._dt) + + def equals(self, other) -> bool: + if isinstance(other, Date): + return self._dt == other._dt + return False + + def hashCode(self) -> int: + return hash(self._dt) & 0x7FFFFFFF + + def toString(self) -> str: + return self._dt.strftime("%a %b %d %H:%M:%S %z %Y") + + def clone(self) -> 'Date': + return Date(self._dt) + + def getYear(self) -> int: + return self._dt.year - 1900 + + def getMonth(self) -> int: + return self._dt.month - 1 + + def getDay(self) -> int: + return self._dt.weekday() + + def getHours(self) -> int: + return self._dt.hour + + def getMinutes(self) -> int: + return self._dt.minute + + def getSeconds(self) -> int: + return self._dt.second + + def getDate(self) -> int: + return self._dt.day + + def setYear(self, year: int) -> None: + self._dt = self._dt.replace(year=year + 1900) + + def setMonth(self, month: int) -> None: + self._dt = self._dt.replace(month=month + 1) + + def setDate(self, date: int) -> None: + self._dt = self._dt.replace(day=date) + + def setHours(self, hours: int) -> None: + self._dt = self._dt.replace(hour=hours) + + def setMinutes(self, minutes: int) -> None: + self._dt = self._dt.replace(minute=minutes) + + def setSeconds(self, seconds: int) -> None: + self._dt = self._dt.replace(second=seconds) + + def toGMTString(self) -> str: + return self._dt.strftime("%d %b %Y %H:%M:%S GMT") + + def toLocaleString(self) -> str: + return self._dt.strftime("%Y-%m-%d %H:%M:%S") + + @staticmethod + def parse(s: str) -> 'Date': + try: + return Date(_datetime.datetime.fromisoformat(s)) + except ValueError: + return Date() + + @staticmethod + def fromInstant(instant) -> 'Date': + return Date(instant.toEpochMilli()) + + def toInstant(self): + return self._dt + + def __str__(self): + return self.toString() + + def __repr__(self): + return f"Date({self.getTime()})" + + +# ============================================================ +# Calendar / GregorianCalendar +# ============================================================ + +class Calendar(Stub): + """java.util.Calendar — wraps Python datetime with Java field system""" + # Field constants + YEAR = 1 + MONTH = 2 + DAY_OF_MONTH = 5 + DAY_OF_YEAR = 6 + DAY_OF_WEEK = 7 + DAY_OF_WEEK_IN_MONTH = 8 + AM_PM = 9 + HOUR = 10 + HOUR_OF_DAY = 11 + MINUTE = 12 + SECOND = 13 + MILLISECOND = 14 + WEEK_OF_MONTH = 15 + WEEK_OF_YEAR = 16 + ERA = 17 + ZONE_OFFSET = 18 + DST_OFFSET = 19 + FIELD_COUNT = 20 + + # Day of week constants + SUNDAY = 1 + MONDAY = 2 + TUESDAY = 3 + WEDNESDAY = 4 + THURSDAY = 5 + FRIDAY = 6 + SATURDAY = 7 + + # Month constants + JANUARY = 0 + FEBRUARY = 1 + MARCH = 2 + APRIL = 3 + MAY = 4 + JUNE = 5 + JULY = 6 + AUGUST = 7 + SEPTEMBER = 8 + OCTOBER = 9 + NOVEMBER = 10 + DECEMBER = 11 + UNDECIMBER = 12 + + # AM/PM + AM = 0 + PM = 1 + + def __init__(self): + super().__init__() + self._dt = _datetime.datetime.now() + self._fields: Dict[int, int] = {} + self._is_set: Dict[int, bool] = {} + self._lenient = True + self._first_day_of_week = Calendar.SUNDAY + self._minimal_days_in_first_week = 1 + self._timezone = _datetime.timezone.utc + self._set_fields_from_dt() + + def _set_fields_from_dt(self) -> None: + self._fields[Calendar.YEAR] = self._dt.year + self._fields[Calendar.MONTH] = self._dt.month - 1 + self._fields[Calendar.DAY_OF_MONTH] = self._dt.day + self._fields[Calendar.DAY_OF_YEAR] = self._dt.timetuple().tm_yday + self._fields[Calendar.DAY_OF_WEEK] = self._dt.isoweekday() % 7 + 1 + self._fields[Calendar.HOUR] = self._dt.hour % 12 + self._fields[Calendar.HOUR_OF_DAY] = self._dt.hour + self._fields[Calendar.MINUTE] = self._dt.minute + self._fields[Calendar.SECOND] = self._dt.second + self._fields[Calendar.MILLISECOND] = self._dt.microsecond // 1000 + self._fields[Calendar.AM_PM] = Calendar.AM if self._dt.hour < 12 else Calendar.PM + self._fields[Calendar.WEEK_OF_YEAR] = self._dt.isocalendar()[1] + self._fields[Calendar.ERA] = 1 # AD = 1 + + def get(self, field: int) -> int: + return self._fields.get(field, 0) + + def set(self, field: int, value: int) -> None: + self._fields[field] = value + self._is_set[field] = True + + def setTime(self, date: 'Date') -> None: + self._dt = date._dt + self._set_fields_from_dt() + + def getTime(self) -> Date: + return Date(self._dt) + + def getTimeInMillis(self) -> int: + return int(self._dt.timestamp() * 1000) + + def setTimeInMillis(self, millis: int) -> None: + self._dt = _datetime.datetime.fromtimestamp(millis / 1000.0) + self._set_fields_from_dt() + + def add(self, field: int, amount: int) -> None: + if field == Calendar.YEAR: + self._dt = self._dt.replace(year=self._dt.year + amount) + elif field == Calendar.MONTH: + new_month = self._dt.month - 1 + amount + new_year = self._dt.year + new_month // 12 + new_month = new_month % 12 + try: + self._dt = self._dt.replace(year=new_year, month=new_month + 1) + except ValueError: + self._dt = self._dt.replace(year=new_year, month=new_month + 1, day=28) + elif field == Calendar.DAY_OF_MONTH: + self._dt += _datetime.timedelta(days=amount) + elif field == Calendar.HOUR_OF_DAY or field == Calendar.HOUR: + self._dt += _datetime.timedelta(hours=amount) + elif field == Calendar.MINUTE: + self._dt += _datetime.timedelta(minutes=amount) + elif field == Calendar.SECOND: + self._dt += _datetime.timedelta(seconds=amount) + elif field == Calendar.MILLISECOND: + self._dt += _datetime.timedelta(milliseconds=amount) + elif field == Calendar.WEEK_OF_YEAR or field == Calendar.WEEK_OF_MONTH: + self._dt += _datetime.timedelta(weeks=amount) + self._set_fields_from_dt() + + def roll(self, field: int, amount: int) -> None: + if field == Calendar.MONTH: + old_month = self._dt.month + new_month = ((old_month - 1 + amount) % 12) + 1 + try: + self._dt = self._dt.replace(month=new_month) + except ValueError: + self._dt = self._dt.replace(month=new_month, day=28) + elif field == Calendar.DAY_OF_MONTH: + import calendar as _cal + max_day = _cal.monthrange(self._dt.year, self._dt.month)[1] + new_day = ((self._dt.day - 1 + amount) % max_day) + 1 + self._dt = self._dt.replace(day=new_day) + else: + self.add(field, amount) + self._set_fields_from_dt() + + def before(self, when: 'Calendar') -> bool: + return self._dt < when._dt + + def after(self, when: 'Calendar') -> bool: + return self._dt > when._dt + + def compareTo(self, another: 'Calendar') -> int: + return (self._dt > another._dt) - (self._dt < another._dt) + + def equals(self, other) -> bool: + if isinstance(other, Calendar): + return self._dt == other._dt + return False + + def hashCode(self) -> int: + return hash(self._dt) & 0x7FFFFFFF + + def toString(self) -> str: + return str(self._dt) + + def isLenient(self) -> bool: + return self._lenient + + def setLenient(self, lenient: bool) -> None: + self._lenient = lenient + + def getFirstDayOfWeek(self) -> int: + return self._first_day_of_week + + def setFirstDayOfWeek(self, value: int) -> None: + self._first_day_of_week = value + + def getMinimalDaysInFirstWeek(self) -> int: + return self._minimal_days_in_first_week + + def setMinimalDaysInFirstWeek(self, value: int) -> None: + self._minimal_days_in_first_week = value + + def getActualMaximum(self, field: int) -> int: + import calendar as _cal + if field == Calendar.DAY_OF_MONTH: + return _cal.monthrange(self._dt.year, self._dt.month)[1] + if field == Calendar.DAY_OF_YEAR: + return 366 if self._dt.year % 4 == 0 and (self._dt.year % 100 != 0 or self._dt.year % 400 == 0) else 365 + if field == Calendar.MONTH: + return 11 + if field == Calendar.HOUR: + return 11 + if field == Calendar.HOUR_OF_DAY: + return 23 + if field == Calendar.MINUTE: + return 59 + if field == Calendar.SECOND: + return 59 + if field == Calendar.MILLISECOND: + return 999 + return 0 + + def getActualMinimum(self, field: int) -> int: + return 0 + + def getDisplayName(self, field: int, style: int, locale: 'Locale') -> str: + return str(self.get(field)) + + @staticmethod + def getInstance() -> 'GregorianCalendar': + return GregorianCalendar() + + +class GregorianCalendar(Calendar): + """java.util.GregorianCalendar""" + BC = 0 + AD = 1 + + def __init__(self, *args): + super().__init__() + if len(args) == 0: + self._dt = _datetime.datetime.now() + elif len(args) == 3: + year, month, day = args + self._dt = _datetime.datetime(year, month + 1, day) + elif len(args) >= 5: + year, month, day, hour, minute = args[:5] + second = args[5] if len(args) > 5 else 0 + self._dt = _datetime.datetime(year, month + 1, day, hour, minute, second) + else: + self._dt = _datetime.datetime.now() + self._set_fields_from_dt() + + def isLeapYear(self, year: int) -> bool: + return (year % 4 == 0 and year % 100 != 0) or year % 400 == 0 + + def getGreatestMinimum(self, field: int) -> int: + return self.getActualMinimum(field) + + def getLeastMaximum(self, field: int) -> int: + return self.getActualMaximum(field) + + def getMaximum(self, field: int) -> int: + if field == Calendar.DAY_OF_MONTH: + return 31 + if field == Calendar.DAY_OF_YEAR: + return 366 + if field == Calendar.MONTH: + return 11 + return self.getActualMaximum(field) + + def getMinimum(self, field: int) -> int: + return 0 + + +# ============================================================ +# UUID +# ============================================================ + +class UUID(Stub): + """java.util.UUID — wraps Python uuid module""" + def __init__(self, most_sig_bits: int, least_sig_bits: int): + super().__init__() + self._most_sig_bits = most_sig_bits & 0xFFFFFFFFFFFFFFFF + self._least_sig_bits = least_sig_bits & 0xFFFFFFFFFFFFFFFF + # Rebuild a Python UUID from the bits for string representation + hex_str = f"{self._most_sig_bits:016x}{self._least_sig_bits:016x}" + self._uuid = _uuid.UUID(hex_str) + + @staticmethod + def randomUUID() -> 'UUID': + u = _uuid.uuid4() + most = u.int >> 64 + least = u.int & 0xFFFFFFFFFFFFFFFF + return UUID(most, least) + + @staticmethod + def nameUUIDFromBytes(name: bytes) -> 'UUID': + u = _uuid.uuid3(_uuid.NAMESPACE_DNS, name.decode('utf-8', errors='replace')) + most = u.int >> 64 + least = u.int & 0xFFFFFFFFFFFFFFFF + return UUID(most, least) + + @staticmethod + def fromString(name: str) -> 'UUID': + u = _uuid.UUID(name) + most = u.int >> 64 + least = u.int & 0xFFFFFFFFFFFFFFFF + return UUID(most, least) + + def getMostSignificantBits(self) -> int: + return self._most_sig_bits + + def getLeastSignificantBits(self) -> int: + return self._least_sig_bits + + def version(self) -> int: + return self._uuid.version + + def variant(self) -> int: + return self._uuid.variant + + def timestamp(self) -> int: + if self.version() != 1: + raise UnsupportedOperationException("Not a time-based UUID") + return self._uuid.time + + def clockSequence(self) -> int: + if self.version() != 1: + raise UnsupportedOperationException("Not a time-based UUID") + return self._uuid.clock_seq + + def node(self) -> int: + if self.version() != 1: + raise UnsupportedOperationException("Not a time-based UUID") + return self._uuid.node + + def compareTo(self, other: 'UUID') -> int: + return (self._uuid.int > other._uuid.int) - (self._uuid.int < other._uuid.int) + + def equals(self, other) -> bool: + if isinstance(other, UUID): + return self._uuid == other._uuid + return False + + def hashCode(self) -> int: + return hash(self._uuid) & 0x7FFFFFFF + + def toString(self) -> str: + return str(self._uuid) + + def __str__(self): + return str(self._uuid) + + def __repr__(self): + return f"UUID({str(self._uuid)})" + + +# ============================================================ +# StringTokenizer +# ============================================================ + +class StringTokenizer(Stub): + """java.util.StringTokenizer — simple tokenizer""" + def __init__(self, s: str, delim: str = " \t\n\r\f", return_delims: bool = False): + super().__init__() + self._str = str(s) + self._delim = delim + self._return_delims = return_delims + self._tokens = self._tokenize() + self._index = 0 + + def _tokenize(self): + if self._return_delims: + tokens = [] + buf = "" + for ch in self._str: + if ch in self._delim: + if buf: + tokens.append(buf) + buf = "" + tokens.append(ch) + else: + buf += ch + if buf: + tokens.append(buf) + return tokens + import re as _re + pattern = f"[{_re.escape(self._delim)}]+" + return [t for t in _re.split(pattern, self._str) if t] + + def countTokens(self) -> int: + return len(self._tokens) + + def hasMoreTokens(self) -> bool: + return self._index < len(self._tokens) + + def nextToken(self, delim: str = None) -> str: + if delim is not None: + self._delim = delim + remaining = self._str[self._index:] + st = StringTokenizer(remaining, delim, self._return_delims) + self._tokens = st._tokens + self._index = 0 + if not self.hasMoreTokens(): + raise NoSuchElementException() + tok = self._tokens[self._index] + self._index += 1 + return tok + + def hasMoreElements(self) -> bool: + return self.hasMoreTokens() + + def nextElement(self): + return self.nextToken() + + def __iter__(self): + return self + + def __next__(self): + if not self.hasMoreTokens(): + raise StopIteration + return self.nextToken() + + +# ============================================================ +# Optional +# ============================================================ + +class Optional(Stub): + """java.util.Optional — wraps value or None""" + def __init__(self, value=None): + super().__init__() + self._value = value + + @staticmethod + def empty() -> 'Optional': + return Optional(None) + + @staticmethod + def of(value) -> 'Optional': + if value is None: + raise TypeError("value is null") + return Optional(value) + + @staticmethod + def ofNullable(value) -> 'Optional': + return Optional(value) + + def get(self): + if self._value is None: + raise NoSuchElementException("No value present") + return self._value + + def isPresent(self) -> bool: + return self._value is not None + + def isEmpty(self) -> bool: + return self._value is None + + def ifPresent(self, consumer) -> None: + if self._value is not None: + consumer(self._value) + + def ifPresentOrElse(self, action, empty_action) -> None: + if self._value is not None: + action(self._value) + else: + empty_action() + + def filter(self, predicate) -> 'Optional': + if self._value is None: + return self + return Optional.ofNullable(self._value) if predicate(self._value) else Optional.empty() + + def map(self, mapper) -> 'Optional': + if self._value is None: + return Optional.empty() + return Optional.ofNullable(mapper(self._value)) + + def flatMap(self, mapper) -> 'Optional': + if self._value is None: + return Optional.empty() + return mapper(self._value) + + def orElse(self, other): + return self._value if self._value is not None else other + + def orElseGet(self, supplier): + if self._value is not None: + return self._value + return supplier() + + def orElseThrow(self, exception_supplier=None): + if self._value is not None: + return self._value + if exception_supplier: + raise exception_supplier() + raise NoSuchElementException("No value present") + + def stream(self): + if self._value is not None: + return [self._value] + return [] + + def equals(self, other) -> bool: + if isinstance(other, Optional): + return self._value == other._value + return False + + def hashCode(self) -> int: + return hash(self._value) & 0x7FFFFFFF if self._value is not None else 0 + + def toString(self) -> str: + if self._value is None: + return "Optional.empty" + return f"Optional[{self._value}]" + + def __str__(self): + return self.toString() + + def __repr__(self): + return self.toString() + + def __bool__(self): + return self._value is not None + + +# ============================================================ +# Random +# ============================================================ + +class Random(Stub): + """java.util.Random — wraps Python random module""" + def __init__(self, seed: _typing.Optional[int] = None): + super().__init__() + self._rng = _py_random.Random(seed) + + def setSeed(self, seed: int) -> None: + self._rng.seed(seed) + + def nextInt(self, bound: _typing.Optional[int] = None) -> int: + if bound is None: + return self._rng.randint(-2147483648, 2147483647) + if bound <= 0: + raise IllegalArgumentException("bound must be positive") + return self._rng.randrange(0, bound) + + def nextLong(self) -> int: + return (self._rng.randint(-2147483648, 2147483647) << 32) | self._rng.randint(0, 0xFFFFFFFF) + + def nextBoolean(self) -> bool: + return self._rng.random() < 0.5 + + def nextFloat(self) -> float: + return self._rng.random() + + def nextDouble(self) -> float: + return self._rng.random() + + def nextGaussian(self) -> float: + return self._rng.gauss(0.0, 1.0) + + def nextBytes(self, bytes_arr: bytearray) -> None: + for i in range(len(bytes_arr)): + bytes_arr[i] = self._rng.randint(0, 255) + + def next(self, bits: int) -> int: + return self._rng.getrandbits(bits) & ((1 << bits) - 1) + + @staticmethod + def create() -> 'Random': + return Random() + + +# ============================================================ +# Properties +# ============================================================ + +class Properties(HashMap): + """java.util.Properties — extends Hashtable-like dict with load/store""" + def __init__(self, defaults: 'Properties' = None): + super().__init__() + self._defaults = defaults + + def setProperty(self, key: str, value: str) -> None: + self.put(str(key), str(value)) + + def getProperty(self, key: str, default_value: str = None) -> _typing.Optional[str]: + val = self._data.get(str(key)) + if val is not None: + return str(val) + if self._defaults is not None: + return self._defaults.getProperty(key, default_value) + return default_value + + def load(self, in_stream) -> None: + if isinstance(in_stream, (str, bytes)): + lines = in_stream.splitlines() if isinstance(in_stream, str) else in_stream.decode('utf-8').splitlines() + else: + lines = in_stream.read().splitlines() if hasattr(in_stream, 'read') else in_stream.splitlines() + for line in lines: + line = line.strip() + if not line or line.startswith('#') or line.startswith('!'): + continue + if '=' in line: + key, val = line.split('=', 1) + elif ':' in line: + key, val = line.split(':', 1) + else: + key = line + val = "" + key = key.strip() + val = val.strip() + self._data[key] = val + + def store(self, out_stream, comments: str = None) -> None: + lines = [] + if comments: + lines.append(f"#{comments}") + lines.append(f"# {_datetime.datetime.now().isoformat()}") + for k, v in self._data.items(): + escaped_val = str(v).replace("\\", "\\\\").replace(" ", "\\ ") + lines.append(f"{k}={escaped_val}") + content = "\n".join(lines) + "\n" + if isinstance(out_stream, _io.IOBase): + out_stream.write(content) + else: + out_stream.write(content) # type: ignore + + def list(self, out_stream) -> None: + for k, v in self._data.items(): + out_stream.write(f"{k}={v}\n") + + def propertyNames(self): + return Iterator(self._data.keys()) + + def stringPropertyNames(self) -> set: + names = set() + for k in self._data.keys(): + if isinstance(k, str): + names.add(k) + if self._defaults: + names.update(self._defaults.stringPropertyNames()) + return names + + def loadFromXML(self, in_stream) -> None: + import xml.etree.ElementTree as _ET + tree = _ET.parse(in_stream) + root = tree.getroot() + for entry in root.findall('entry'): + key = entry.get('key', '') + self._data[key] = entry.text or '' + + def storeToXML(self, out_stream, comment: str = None) -> None: + import xml.etree.ElementTree as _ET + root = _ET.Element('properties') + if comment: + c = _ET.SubElement(root, 'comment') + c.text = comment + for k, v in self._data.items(): + entry = _ET.SubElement(root, 'entry') + entry.set('key', str(k)) + entry.text = str(v) + tree = _ET.ElementTree(root) + tree.write(out_stream, xml_declaration=True, encoding='UTF-8') + + def get(self, key): + val = self._data.get(key) + if val is not None: + return val + return self._defaults.get(key) if self._defaults else None + + def put(self, key, value): + return super().put(str(key), str(value)) + + def toString(self) -> str: + items = ", ".join(f"{k}={v}" for k, v in self._data.items()) + return f"{{{items}}}" + + +# ============================================================ +# EnumSet +# ============================================================ + +class EnumSet(HashSet): + """java.util.EnumSet — simple implementation using set""" + def __init__(self, c=None): + super().__init__() + self._element_type = None + if c is not None: + if isinstance(c, EnumSet): + self._data = set(c._data) + self._element_type = c._element_type + elif isinstance(c, type): + self._element_type = c + elif isinstance(c, _IterableABC): + for item in c: + self._data.add(item) + if self._element_type is None: + self._element_type = item.__class__ + + @staticmethod + def allOf(element_type) -> 'EnumSet': + es = EnumSet() + es._element_type = element_type + if hasattr(element_type, '_values'): + for v in element_type._values(): + es._data.add(v) + elif hasattr(element_type, '__members__'): + for name, member in element_type.__members__.items(): + es._data.add(member) + return es + + @staticmethod + def noneOf(element_type) -> 'EnumSet': + es = EnumSet() + es._element_type = element_type + return es + + @staticmethod + def range(element_type, from_val, to_val) -> 'EnumSet': + es = EnumSet() + es._element_type = element_type + started = False + if hasattr(element_type, '_values'): + for v in element_type._values(): + if v == from_val: + started = True + if started: + es._data.add(v) + if v == to_val: + break + elif hasattr(element_type, '__members__'): + for name, member in element_type.__members__.items(): + if member == from_val: + started = True + if started: + es._data.add(member) + if member == to_val: + break + return es + + @staticmethod + def copyOf(es) -> 'EnumSet': + return EnumSet(es) + + def complementOf(self, other: 'EnumSet') -> 'EnumSet': + result = EnumSet.noneOf(self._element_type) + if self._element_type and hasattr(self._element_type, '_values'): + for v in self._element_type._values(): + if v not in other._data: + result._data.add(v) + return result + + +# ============================================================ +# EnumMap +# ============================================================ + +class EnumMap(HashMap): + """java.util.EnumMap — simple implementation using dict""" + def __init__(self, key_type=None, m=None): + super().__init__() + self._key_type = key_type + if m is not None: + if isinstance(m, EnumMap): + self._data.update(m._data) + self._key_type = m._key_type + elif isinstance(m, dict): + self._data.update(m) + else: + for k, v in m.items(): + self._data[k] = v + + def put(self, key, value): + if self._key_type is None: + self._key_type = key.__class__ + return super().put(key, value) + + def keySet(self): + return set(self._data.keys()) + + +# ============================================================ +# Objects +# ============================================================ + +class Objects: + """java.util.Objects — static helper methods""" + @staticmethod + def equals(a, b) -> bool: + return a == b + + @staticmethod + def deepEquals(a, b) -> bool: + return _deep_eq(a, b) + + @staticmethod + def hashCode(o) -> int: + return 0 if o is None else (hash(o) & 0x7FFFFFFF) + + @staticmethod + def hash(*values) -> int: + return Arrays.hashCode(values) + + @staticmethod + def toString(o, null_default: str = "null") -> str: + if o is None: + return null_default + return str(o) + + @staticmethod + def compare(a, b, cmp) -> int: + if cmp: + return cmp(a, b) + return (a > b) - (a < b) + + @staticmethod + def requireNonNull(obj, message: Any = None): + if obj is None: + if message is None: + raise TypeError("null") + raise TypeError(str(message) if not callable(message) else message.get()) + return obj + + @staticmethod + def nonNull(obj) -> bool: + return obj is not None + + @staticmethod + def isNull(obj) -> bool: + return obj is None + + @staticmethod + def requireNonNullElse(obj, default): + return obj if obj is not None else default + + @staticmethod + def requireNonNullElseGet(obj, supplier): + return obj if obj is not None else supplier() + + @staticmethod + def checkIndex(index: int, length: int) -> int: + if index < 0 or index >= length: + raise IndexError(f"Index {index} out of bounds [0, {length})") + return index + + @staticmethod + def checkFromToIndex(from_index: int, to_index: int, length: int) -> int: + if from_index < 0 or from_index > to_index or to_index > length: + raise IndexError(f"Range [{from_index}, {to_index}) out of bounds [0, {length})") + return from_index + + @staticmethod + def checkFromIndexSize(from_index: int, size: int, length: int) -> int: + if from_index < 0 or size < 0 or from_index + size > length: + raise IndexError(f"Range [{from_index}, {from_index + size}) out of bounds [0, {length})") + return from_index + + +# ============================================================ +# Locale +# ============================================================ + +class Locale(Stub): + """java.util.Locale — basic locale representation""" + ENGLISH = None + FRENCH = None + GERMAN = None + ITALIAN = None + JAPANESE = None + KOREAN = None + CHINESE = None + SIMPLIFIED_CHINESE = None + TRADITIONAL_CHINESE = None + FRANCE = None + GERMANY = None + ITALY = None + JAPAN = None + KOREA = None + CHINA = None + UK = None + US = None + CANADA = None + CANADA_FRENCH = None + ROOT = None + + def __init__(self, language: str = "", country: str = "", variant: str = ""): + super().__init__() + self._language = language + self._country = country + self._variant = variant + + @staticmethod + def getDefault() -> 'Locale': + return Locale("en", "US") + + @staticmethod + def setDefault(locale: 'Locale') -> None: + pass + + def getLanguage(self) -> str: + return self._language + + def getCountry(self) -> str: + return self._country + + def getVariant(self) -> str: + return self._variant + + def getDisplayLanguage(self, locale: 'Locale' = None) -> str: + return self._language + + def getDisplayCountry(self, locale: 'Locale' = None) -> str: + return self._country + + def getDisplayName(self, locale: 'Locale' = None) -> str: + parts = [self._language] + if self._country: + parts.append(self._country) + if self._variant: + parts.append(self._variant) + return "_".join(parts) + + def toString(self) -> str: + return self.getDisplayName() + + def toLanguageTag(self) -> str: + tag = self._language + if self._country: + tag += "-" + self._country + if self._variant: + tag += "-" + self._variant + return tag + + @staticmethod + def forLanguageTag(tag: str) -> 'Locale': + parts = tag.replace("-", "_").split("_") + lang = parts[0] if len(parts) > 0 else "" + country = parts[1] if len(parts) > 1 else "" + variant = parts[2] if len(parts) > 2 else "" + return Locale(lang, country, variant) + + def equals(self, other) -> bool: + if isinstance(other, Locale): + return (self._language == other._language and + self._country == other._country and + self._variant == other._variant) + return False + + def hashCode(self) -> int: + return hash((self._language, self._country, self._variant)) & 0x7FFFFFFF + + +# Initialize Locale constants +Locale.ENGLISH = Locale("en") +Locale.FRENCH = Locale("fr") +Locale.GERMAN = Locale("de") +Locale.ITALIAN = Locale("it") +Locale.JAPANESE = Locale("ja") +Locale.KOREAN = Locale("ko") +Locale.CHINESE = Locale("zh") +Locale.SIMPLIFIED_CHINESE = Locale("zh", "CN") +Locale.TRADITIONAL_CHINESE = Locale("zh", "TW") +Locale.FRANCE = Locale("fr", "FR") +Locale.GERMANY = Locale("de", "DE") +Locale.ITALY = Locale("it", "IT") +Locale.JAPAN = Locale("ja", "JP") +Locale.KOREA = Locale("ko", "KR") +Locale.CHINA = Locale("zh", "CN") +Locale.UK = Locale("en", "GB") +Locale.US = Locale("en", "US") +Locale.CANADA = Locale("en", "CA") +Locale.CANADA_FRENCH = Locale("fr", "CA") +Locale.ROOT = Locale("", "") + + +# ============================================================ +# BitSet +# ============================================================ + +class BitSet(Stub): + """java.util.BitSet — bit manipulation""" + def __init__(self, nbits: int = 0): + super().__init__() + if isinstance(nbits, int): + self._bits = 0 + elif isinstance(nbits, BitSet): + self._bits = nbits._bits + else: + self._bits = 0 + + def _check(self, bit_index: int) -> None: + if bit_index < 0: + raise IndexError(f"bitIndex < 0: {bit_index}") + + def get(self, bit_index: int) -> bool: + self._check(bit_index) + return bool((self._bits >> bit_index) & 1) + + def getRange(self, from_index: int, to_index: int) -> 'BitSet': + self._check(from_index) + mask = ((1 << (to_index - from_index)) - 1) << from_index + result = BitSet() + result._bits = (self._bits & mask) >> from_index + return result + + def set(self, bit_index: int, value: bool = True) -> None: + self._check(bit_index) + if value: + self._bits |= (1 << bit_index) + else: + self._bits &= ~(1 << bit_index) + + def setRange(self, from_index: int, to_index: int, value: bool = True) -> None: + self._check(from_index) + mask = ((1 << (to_index - from_index)) - 1) << from_index + if value: + self._bits |= mask + else: + self._bits &= ~mask + + def clear(self, bit_index: int = None) -> None: + if bit_index is None: + self._bits = 0 + else: + self._check(bit_index) + self._bits &= ~(1 << bit_index) + + def clearRange(self, from_index: int, to_index: int) -> None: + self.setRange(from_index, to_index, False) + + def flip(self, bit_index: int) -> None: + self._check(bit_index) + self._bits ^= (1 << bit_index) + + def flipRange(self, from_index: int, to_index: int) -> None: + self._check(from_index) + mask = ((1 << (to_index - from_index)) - 1) << from_index + self._bits ^= mask + + def cardinality(self) -> int: + return self._bits.bit_count() + + def intersects(self, bs: 'BitSet') -> bool: + return (self._bits & bs._bits) != 0 + + def and_(self, bs: 'BitSet') -> None: + self._bits &= bs._bits + + def or_(self, bs: 'BitSet') -> None: + self._bits |= bs._bits + + def xor(self, bs: 'BitSet') -> None: + self._bits ^= bs._bits + + def andNot(self, bs: 'BitSet') -> None: + self._bits &= ~bs._bits + + def size(self) -> int: + return self._bits.bit_length() + (8 - (self._bits.bit_length() % 8)) % 8 + + def length(self) -> int: + return self._bits.bit_length() + + def isEmpty(self) -> bool: + return self._bits == 0 + + def nextSetBit(self, from_index: int) -> int: + self._check(from_index) + bits = self._bits >> from_index + if bits == 0: + return -1 + return (bits & -bits).bit_length() - 1 + from_index + + def nextClearBit(self, from_index: int) -> int: + self._check(from_index) + bits = ~(self._bits >> from_index) + if bits == 0: + return -1 + return (bits & -bits).bit_length() - 1 + from_index + + def previousSetBit(self, from_index: int) -> int: + if from_index < 0: + return -1 + mask = (1 << (from_index + 1)) - 1 + bits = self._bits & mask + if bits == 0: + return -1 + return bits.bit_length() - 1 + + def previousClearBit(self, from_index: int) -> int: + if from_index < 0: + return -1 + mask = (1 << (from_index + 1)) - 1 + bits = (~self._bits) & mask + if bits == 0: + return -1 + return bits.bit_length() - 1 + + def toByteArray(self) -> bytearray: + if self._bits == 0: + return bytearray() + n_bytes = (self._bits.bit_length() + 7) // 8 + return bytearray(self._bits.to_bytes(n_bytes, 'little')) + + def toLongArray(self) -> list: + if self._bits == 0: + return [] + n_longs = (self._bits.bit_length() + 63) // 64 + result = [] + for i in range(n_longs): + result.append((self._bits >> (i * 64)) & 0xFFFFFFFFFFFFFFFF) + return result + + @staticmethod + def valueOf(bytes_or_longs) -> 'BitSet': + bs = BitSet() + if isinstance(bytes_or_longs, (bytes, bytearray)): + bs._bits = int.from_bytes(bytes_or_longs, 'little') + elif isinstance(bytes_or_longs, list): + for i, v in enumerate(bytes_or_longs): + bs._bits |= (v & 0xFFFFFFFFFFFFFFFF) << (i * 64) + return bs + + def stream(self): + bits = [] + i = 0 + while True: + idx = self.nextSetBit(i) + if idx < 0: + break + bits.append(idx) + i = idx + 1 + return bits + + def equals(self, other) -> bool: + if isinstance(other, BitSet): + return self._bits == other._bits + return False + + def hashCode(self) -> int: + return hash(self._bits) & 0x7FFFFFFF + + def toString(self) -> str: + bits = [] + i = 0 + while True: + idx = self.nextSetBit(i) + if idx < 0: + break + bits.append(str(idx)) + i = idx + 1 + return "{" + ", ".join(bits) + "}" + + def clone(self) -> 'BitSet': + return BitSet(self) + + def __repr__(self): + return self.toString() + + def __eq__(self, other): + return self.equals(other) + + +# ============================================================ +# PriorityQueue +# ============================================================ + +class PriorityQueue(Stub): + """java.util.PriorityQueue — using heapq""" + def __init__(self, initial_capacity: Any = None, comparator=None): + super().__init__() + self._heap: list = [] + self._comparator = comparator + if initial_capacity is not None and not isinstance(initial_capacity, (int, float)): + if isinstance(initial_capacity, _IterableABC): + for item in initial_capacity: + self._heap.append(item) + if comparator: + self._heap.sort(key=comparator) + else: + self._heap.sort() + + def _wrap_key(self, obj): + if self._comparator: + return (self._comparator(obj), obj) + return obj + + def add(self, obj) -> bool: + _heapq.heappush(self._heap, self._wrap_key(obj)) + return True + + def offer(self, obj) -> bool: + return self.add(obj) + + def peek(self): + return self._heap[0][1] if self._heap and self._comparator else (self._heap[0] if self._heap else None) + + def element(self): + val = self.peek() + if val is None: + raise NoSuchElementException() + return val + + def poll(self): + if not self._heap: + return None + val = _heapq.heappop(self._heap) + return val[1] if self._comparator else val + + def remove(self, obj) -> bool: + if self._comparator: + wrapped = self._wrap_key(obj) + for i, v in enumerate(self._heap): + if v == wrapped: + self._heap[i] = self._heap[-1] + self._heap.pop() + _heapq.heapify(self._heap) + return True + else: + for i, v in enumerate(self._heap): + if v == obj: + self._heap[i] = self._heap[-1] + self._heap.pop() + _heapq.heapify(self._heap) + return True + return False + + def size(self) -> int: + return len(self._heap) + + def isEmpty(self) -> bool: + return len(self._heap) == 0 + + def clear(self) -> None: + self._heap.clear() + + def comparator(self): + return self._comparator + + def iterator(self) -> Iterator: + return Iterator(list(self._heap)) + + def toArray(self, a=None): + if self._comparator: + items = sorted([v[1] for v in self._heap], key=self._comparator) + else: + items = sorted(self._heap) + if a is None: + return items + return items[:len(a)] + + def forEach(self, action) -> None: + for item in list(self._heap): + action(item) + + def toString(self) -> str: + items = ", ".join(str(x) for x in self._heap) + return f"[{items}]" + + def __len__(self): + return len(self._heap) + + def __repr__(self): + return self.toString() + + +# ============================================================ +# Vector +# ============================================================ + +class Vector(Stub): + """java.util.Vector — synchronized list""" + def __init__(self, initial_capacity: Any = None, capacity_increment: int = 0): + super().__init__() + if initial_capacity is None: + self._data = [] + elif isinstance(initial_capacity, int): + self._data = [] + elif isinstance(initial_capacity, _IterableABC): + self._data = list(initial_capacity) + else: + self._data = [] + self._capacity_increment = capacity_increment + self._lock = _threading.Lock() + + def _synchronized(self, func, *args, **kwargs): + with self._lock: + return func(*args, **kwargs) + + def add(self, obj) -> bool: + with self._lock: + self._data.append(obj) + return True + + def addAt(self, index: int, obj) -> None: + with self._lock: + self._data.insert(index, obj) + + def addAll(self, c) -> bool: + with self._lock: + if isinstance(c, Vector): + self._data.extend(c._data) + else: + self._data.extend(c) + return True + + def addAllAt(self, index: int, c) -> bool: + with self._lock: + if isinstance(c, Vector): + self._data[index:index] = c._data + else: + self._data[index:index] = list(c) + return True + + def addElement(self, obj) -> None: + self.add(obj) + + def capacity(self) -> int: + with self._lock: + return len(self._data) + + def clear(self) -> None: + with self._lock: + self._data.clear() + + def clone(self) -> 'Vector': + with self._lock: + return Vector(self._data) + + def contains(self, obj) -> bool: + with self._lock: + return obj in self._data + + def containsAll(self, c) -> bool: + with self._lock: + if isinstance(c, Vector): + return all(x in self._data for x in c._data) + return all(x in self._data for x in c) + + def copyInto(self, an_array: list) -> None: + with self._lock: + for i, v in enumerate(self._data): + an_array[i] = v + + def elementAt(self, index: int): + with self._lock: + return self._data[index] + + def elements(self) -> Enumeration: + with self._lock: + return Enumeration(list(self._data)) + + def ensureCapacity(self, min_capacity: int) -> None: + pass + + def firstElement(self): + with self._lock: + if not self._data: + raise NoSuchElementException() + return self._data[0] + + def forEach(self, action) -> None: + with self._lock: + for item in list(self._data): + action(item) + + def get(self, index: int): + with self._lock: + return self._data[index] + + def indexOf(self, obj, index: int = 0) -> int: + with self._lock: + try: + return self._data.index(obj, index) + except ValueError: + return -1 + + def insertElementAt(self, obj, index: int) -> None: + with self._lock: + self._data.insert(index, obj) + + def isEmpty(self) -> bool: + with self._lock: + return len(self._data) == 0 + + def iterator(self) -> Iterator: + with self._lock: + return Iterator(list(self._data)) + + def lastElement(self): + with self._lock: + if not self._data: + raise NoSuchElementException() + return self._data[-1] + + def lastIndexOf(self, obj, index: int = None) -> int: + with self._lock: + if index is None: + index = len(self._data) - 1 + for i in range(index, -1, -1): + if self._data[i] == obj: + return i + return -1 + + def listIterator(self, index: int = 0) -> ListIterator: + with self._lock: + li = ListIterator(list(self._data)) + li._index = index + return li + + def remove(self, obj) -> bool: + with self._lock: + if obj in self._data: + self._data.remove(obj) + return True + return False + + def removeAt(self, index: int): + with self._lock: + return self._data.pop(index) + + def removeAll(self, c) -> bool: + with self._lock: + if isinstance(c, Vector): + items = c._data + else: + items = list(c) + old_len = len(self._data) + self._data = [x for x in self._data if x not in items] + return len(self._data) != old_len + + def removeAllElements(self) -> None: + with self._lock: + self._data.clear() + + def removeElement(self, obj) -> bool: + return self.remove(obj) + + def removeElementAt(self, index: int) -> None: + with self._lock: + self._data.pop(index) + + def removeIf(self, predicate) -> bool: + with self._lock: + old_len = len(self._data) + self._data = [x for x in self._data if not predicate(x)] + return len(self._data) != old_len + + def replaceAll(self, operator) -> None: + with self._lock: + self._data = [operator(x) for x in self._data] + + def retainAll(self, c) -> bool: + with self._lock: + if isinstance(c, Vector): + items = set(c._data) + else: + items = set(c) + old_len = len(self._data) + self._data = [x for x in self._data if x in items] + return len(self._data) != old_len + + def set(self, index: int, obj): + with self._lock: + old = self._data[index] + self._data[index] = obj + return old + + def setElementAt(self, obj, index: int) -> None: + with self._lock: + self._data[index] = obj + + def setSize(self, new_size: int) -> None: + with self._lock: + while len(self._data) < new_size: + self._data.append(None) + while len(self._data) > new_size: + self._data.pop() + + def size(self) -> int: + with self._lock: + return len(self._data) + + def sort(self, key=None, reverse: bool = False) -> None: + with self._lock: + self._data.sort(key=key, reverse=reverse) + + def subList(self, from_index: int, to_index: int) -> 'Vector': + with self._lock: + return Vector(self._data[from_index:to_index]) + + def toArray(self, a=None): + with self._lock: + if a is None: + return list(self._data) + if len(a) < len(self._data): + return list(self._data) + for i, v in enumerate(self._data): + a[i] = v + if len(self._data) < len(a): + a[len(self._data)] = None + return a + + def toString(self) -> str: + with self._lock: + items = ", ".join(str(x) for x in self._data) + return f"[{items}]" + + def trimToSize(self) -> None: + pass + + def __len__(self): + with self._lock: + return len(self._data) + + def __getitem__(self, idx): + with self._lock: + return self._data[idx] + + def __setitem__(self, idx, val): + with self._lock: + self._data[idx] = val + + def __delitem__(self, idx): + with self._lock: + del self._data[idx] + + def __iter__(self): + with self._lock: + return iter(list(self._data)) + + def __repr__(self): + return self.toString() + + def __contains__(self, obj): + with self._lock: + return obj in self._data + + def __eq__(self, other): + if isinstance(other, Vector): + with self._lock: + return self._data == other._data + return False + + +# ============================================================ +# Stack +# ============================================================ + +class Stack(Vector): + """java.util.Stack — extends Vector""" + def __init__(self): + super().__init__() + + def push(self, item): + with self._lock: + self._data.append(item) + return item + + def pop(self): + with self._lock: + if not self._data: + raise EmptyStackException() + return self._data.pop() + + def peek(self): + with self._lock: + if not self._data: + raise EmptyStackException() + return self._data[-1] + + def empty(self) -> bool: + with self._lock: + return len(self._data) == 0 + + def search(self, obj) -> int: + with self._lock: + try: + idx = len(self._data) - 1 - self._data[::-1].index(obj) + return len(self._data) - idx + except ValueError: + return -1 + + def add(self, obj) -> bool: + self.push(obj) + return True + + def remove(self, obj) -> bool: + with self._lock: + if obj in self._data: + self._data.remove(obj) + return True + return False \ No newline at end of file diff --git a/android_pyapi/java/util_concurrent.py b/android_pyapi/java/util_concurrent.py new file mode 100644 index 0000000..fd2c16a --- /dev/null +++ b/android_pyapi/java/util_concurrent.py @@ -0,0 +1,2037 @@ +""" +Java util.concurrent standard library APIs implemented in Python. +java.util.concurrent package - Executors, ThreadPoolExecutor, CountDownLatch, etc. +""" + +from .._core import Stub +from .lang import RuntimeException +import threading as _threading +import concurrent.futures as _futures +import time as _time +import queue as _queue +import math as _py_math + +IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {}) +CancellationException = type("CancellationException", (RuntimeException,), {}) +ExecutionException = type("ExecutionException", (RuntimeException,), {}) +RejectedExecutionException = type("RejectedExecutionException", (RuntimeException,), {}) +TimeoutException = type("TimeoutException", (RuntimeException,), {}) +BrokenBarrierException = type("BrokenBarrierException", (RuntimeException,), {}) +CompletionException = type("CompletionException", (RuntimeException,), {}) + +__all__ = [ + "Executors", "ExecutorService", "Executor", "ExecutorCompletionService", + "ThreadPoolExecutor", "AbstractExecutorService", + "ScheduledExecutorService", "ScheduledThreadPoolExecutor", + "FutureTask", "Future", "RunnableFuture", "RunnableScheduledFuture", + "Callable", "CompletionService", "CompletionStage", + "CountDownLatch", "CyclicBarrier", "Semaphore", "Phaser", "Exchanger", + "TimeUnit", + "TimeoutException", "CancellationException", "ExecutionException", + "RejectedExecutionException", "BrokenBarrierException", + "CompletionException", + "ConcurrentHashMap", "CopyOnWriteArrayList", "CopyOnWriteArraySet", + "ConcurrentLinkedQueue", "ConcurrentLinkedDeque", + "DelayQueue", "SynchronousQueue", "LinkedBlockingQueue", + "ArrayBlockingQueue", "PriorityBlockingQueue", + "BlockingQueue", "BlockingDeque", + "AtomicBoolean", "AtomicInteger", "AtomicLong", "AtomicReference", + "AtomicIntegerArray", "AtomicLongArray", "AtomicReferenceArray", + "AtomicIntegerFieldUpdater", "AtomicLongFieldUpdater", + "AtomicReferenceFieldUpdater", + "AtomicMarkableReference", "AtomicStampedReference", + "DoubleAccumulator", "DoubleAdder", + "LongAccumulator", "LongAdder", + "Lock", "ReentrantLock", "ReentrantReadWriteLock", + "ReadWriteLock", "Condition", "LockSupport", + "AbstractQueuedSynchronizer", "AbstractQueuedLongSynchronizer", + "Flow", "SubmissionPublisher", + "RecursiveAction", "RecursiveTask", "ForkJoinPool", + "ForkJoinTask", "ForkJoinWorkerThread", + "CompletableFuture", +] + + +# ============================================================ +# Interfaces +# ============================================================ + +class Callable(Stub): + def call(self): + raise NotImplementedError + + +class Future(Stub): + def get(self, timeout=None, unit=None): + raise NotImplementedError + + def cancel(self, may_interrupt): + raise NotImplementedError + + def isCancelled(self): + raise NotImplementedError + + def isDone(self): + raise NotImplementedError + + +class RunnableFuture(Future): + def run(self): + raise NotImplementedError + + +class RunnableScheduledFuture(RunnableFuture): + def isPeriodic(self): + raise NotImplementedError + + +class CompletionService(Stub): + def submit(self, task): + raise NotImplementedError + + def take(self): + raise NotImplementedError + + def poll(self, timeout=0, unit=None): + raise NotImplementedError + + +class CompletionStage(Stub): + pass + + +class Executor(Stub): + def execute(self, command): + raise NotImplementedError + + +class ExecutorService(Executor): + def submit(self, task, *args): + raise NotImplementedError + + def shutdown(self): + raise NotImplementedError + + def shutdownNow(self): + raise NotImplementedError + + def isShutdown(self): + raise NotImplementedError + + def isTerminated(self): + raise NotImplementedError + + def awaitTermination(self, timeout, unit): + raise NotImplementedError + + def invokeAll(self, tasks): + raise NotImplementedError + + def invokeAny(self, tasks): + raise NotImplementedError + + +class ScheduledExecutorService(ExecutorService): + def schedule(self, command, delay, unit): + raise NotImplementedError + + def scheduleAtFixedRate(self, command, initial_delay, period, unit): + raise NotImplementedError + + def scheduleWithFixedDelay(self, command, initial_delay, delay, unit): + raise NotImplementedError + + +# ============================================================ +# Runnable +# ============================================================ + +class Runnable(Stub): + def run(self): + raise NotImplementedError + + +# ============================================================ +# FutureTask +# ============================================================ + +class FutureTask(RunnableFuture): + def __init__(self, callable_or_runnable, result=None): + super().__init__() + self._callable = callable_or_runnable if isinstance(callable_or_runnable, Callable) else None + self._runnable = callable_or_runnable if isinstance(callable_or_runnable, Runnable) else None + self._result = result + self._done = False + self._cancelled = False + self._exception = None + self._lock = _threading.RLock() + self._done_event = _threading.Event() + + def run(self): + if self._cancelled: + return + try: + if self._callable: + self._result = self._callable.call() + elif self._runnable: + self._runnable.run() + with self._lock: + self._done = True + self._done_event.set() + except Exception as e: + with self._lock: + self._exception = e + self._done = True + self._done_event.set() + + def get(self, timeout=None, unit=None): + if timeout is not None and unit is not None: + seconds = unit.toMillis(timeout) / 1000.0 + if not self._done_event.wait(seconds): + raise TimeoutException() + else: + self._done_event.wait() + with self._lock: + if self._exception: + raise ExecutionException(str(self._exception)) + return self._result + + def cancel(self, may_interrupt): + with self._lock: + if self._done: + return False + self._cancelled = True + self._done = True + self._done_event.set() + return True + + def isCancelled(self): + return self._cancelled + + def isDone(self): + return self._done + + def doneTask(self): + pass + + def set(self, v): + with self._lock: + self._result = v + self._done = True + self._done_event.set() + + def setException(self, ex): + with self._lock: + self._exception = ex + self._done = True + self._done_event.set() + + +# ============================================================ +# CompletableFuture +# ============================================================ + +class CompletableFuture(Future): + def __init__(self): + super().__init__() + self._result = None + self._exception = None + self._done = False + self._lock = _threading.RLock() + self._done_event = _threading.Event() + self._callbacks = [] + + def _run_callbacks(self): + for cb in self._callbacks: + try: + cb(self) + except Exception: + pass + + def complete(self, result): + with self._lock: + if self._done: + return self + self._result = result + self._done = True + self._done_event.set() + self._run_callbacks() + return self + + def completeExceptionally(self, ex): + with self._lock: + if self._done: + return self + self._exception = ex + self._done = True + self._done_event.set() + self._run_callbacks() + return self + + def cancel(self, may_interrupt): + with self._lock: + if self._done: + return False + self._cancelled = True + self._done = True + self._done_event.set() + self._run_callbacks() + return True + + def get(self, timeout=None, unit=None): + if timeout is not None and unit is not None: + seconds = unit.toMillis(timeout) / 1000.0 + if not self._done_event.wait(seconds): + raise TimeoutException() + else: + self._done_event.wait() + with self._lock: + if self._exception: + raise ExecutionException(str(self._exception)) + return self._result + + def join(self): + return self.get() + + def isDone(self): + return self._done + + def isCancelled(self): + return getattr(self, "_cancelled", False) + + def thenApply(self, fn): + future = CompletableFuture() + def cb(f): + try: + future.complete(fn(f.get())) + except Exception as e: + future.completeExceptionally(e) + self._callbacks.append(cb) + return future + + def thenAccept(self, fn): + future = CompletableFuture() + def cb(f): + try: + fn(f.get()) + future.complete(None) + except Exception as e: + future.completeExceptionally(e) + self._callbacks.append(cb) + return future + + def thenRun(self, action): + future = CompletableFuture() + def cb(f): + try: + action.run() + future.complete(None) + except Exception as e: + future.completeExceptionally(e) + self._callbacks.append(cb) + return future + + def thenCombine(self, other, fn): + future = CompletableFuture() + def cb(f): + try: + other_result = other.get() + future.complete(fn(f.get(), other_result)) + except Exception as e: + future.completeExceptionally(e) + self._callbacks.append(cb) + return future + + def thenCompose(self, fn): + future = CompletableFuture() + def cb(f): + try: + next_future = fn(f.get()) + future.complete(next_future.get()) + except Exception as e: + future.completeExceptionally(e) + self._callbacks.append(cb) + return future + + def exceptionally(self, fn): + future = CompletableFuture() + def cb(f): + try: + f.get() + future.complete(f._result) + except Exception as e: + try: + fallback = fn(e) + future.complete(fallback) + except Exception as e2: + future.completeExceptionally(e2) + self._callbacks.append(cb) + return future + + @staticmethod + def completedFuture(result): + f = CompletableFuture() + f.complete(result) + return f + + @staticmethod + def failedFuture(exception): + f = CompletableFuture() + f.completeExceptionally(exception) + return f + + @staticmethod + def supplyAsync(supplier, executor=None): + f = CompletableFuture() + def run(): + try: + f.complete(supplier.get()) + except Exception as e: + f.completeExceptionally(e) + t = _threading.Thread(target=run, daemon=True) + t.start() + return f + + @staticmethod + def runAsync(runnable, executor=None): + f = CompletableFuture() + def run(): + try: + runnable.run() + f.complete(None) + except Exception as e: + f.completeExceptionally(e) + t = _threading.Thread(target=run, daemon=True) + t.start() + return f + + @staticmethod + def allOf(*futures): + result = CompletableFuture() + def check_all(): + for f in futures: + f.get() + result.complete(None) + t = _threading.Thread(target=check_all, daemon=True) + t.start() + return result + + @staticmethod + def anyOf(*futures): + result = CompletableFuture() + def check_any(): + while True: + for f in futures: + if f.isDone(): + result.complete(f.get()) + return + _time.sleep(0.01) + t = _threading.Thread(target=check_any, daemon=True) + t.start() + return result + + +# ============================================================ +# Executors +# ============================================================ + +class Executors(Stub): + @staticmethod + def newCachedThreadPool(): + pool = ThreadPoolExecutor(0, _futures.ThreadPoolExecutor(max_workers=10)) + pool._executor._max_workers = None + return pool + + @staticmethod + def newFixedThreadPool(n_threads): + return ThreadPoolExecutor(n_threads, _futures.ThreadPoolExecutor(max_workers=n_threads)) + + @staticmethod + def newSingleThreadExecutor(): + return ThreadPoolExecutor(1, _futures.ThreadPoolExecutor(max_workers=1)) + + @staticmethod + def newScheduledThreadPool(core_pool_size): + return ScheduledThreadPoolExecutor(core_pool_size) + + @staticmethod + def newWorkStealingPool(parallelism=None): + return ThreadPoolExecutor(parallelism or 4, _futures.ThreadPoolExecutor(max_workers=parallelism or 4)) + + @staticmethod + def defaultThreadFactory(): + return _threading.Thread + + @staticmethod + def privilegedThreadFactory(): + return _threading.Thread + + @staticmethod + def callable(runnable, result=None): + class _Callable(Callable): + def call(self): + if runnable: + runnable.run() + return result + return _Callable() + + +# ============================================================ +# ThreadPoolExecutor +# ============================================================ + +class ThreadPoolExecutor(ExecutorService): + def __init__(self, core_pool_size, executor=None): + super().__init__() + self._executor = executor or _futures.ThreadPoolExecutor(max_workers=core_pool_size) + self._core_pool_size = core_pool_size + self._max_pool_size = core_pool_size + self._keep_alive_time = 60 + self._allow_core_thread_timeout = False + + def execute(self, command): + def _run(): + try: + command.run() + except Exception: + pass + self._executor.submit(_run) + + def submit(self, task, *args): + if isinstance(task, Callable): + future = FutureTask(task) + self._executor.submit(future.run) + return future + elif isinstance(task, Runnable): + future = FutureTask(task) + self._executor.submit(future.run) + return future + else: + future = FutureTask(task) + self._executor.submit(future.run) + return future + + def shutdown(self): + self._executor.shutdown(wait=False) + + def shutdownNow(self): + self._executor.shutdown(wait=False) + + def isShutdown(self): + return self._executor._shutdown + + def isTerminated(self): + return self._executor._shutdown + + def awaitTermination(self, timeout, unit): + seconds = unit.toMillis(timeout) / 1000.0 + self._executor.shutdown(wait=True) + + def getPoolSize(self): + return self._core_pool_size + + def getActiveCount(self): + return 0 + + def getTaskCount(self): + return 0 + + def getCompletedTaskCount(self): + return 0 + + def getLargestPoolSize(self): + return self._core_pool_size + + def setCorePoolSize(self, size): + self._core_pool_size = size + + def setMaximumPoolSize(self, size): + self._max_pool_size = size + + def setKeepAliveTime(self, time, unit): + self._keep_alive_time = unit.toMillis(time) / 1000.0 + + def prestartAllCoreThreads(self): + pass + + def prestartCoreThread(self): + pass + + def allowsCoreThreadTimeOut(self): + return self._allow_core_thread_timeout + + def setRejectedExecutionHandler(self, handler): + pass + + def getRejectedExecutionHandler(self): + return None + + +class AbstractExecutorService(ExecutorService): + pass + + +# ============================================================ +# ScheduledThreadPoolExecutor +# ============================================================ + +class ScheduledThreadPoolExecutor(ThreadPoolExecutor, ScheduledExecutorService): + def __init__(self, core_pool_size): + super().__init__(core_pool_size) + + def schedule(self, command, delay, unit): + future = FutureTask(command) + seconds = unit.toMillis(delay) / 1000.0 + t = _threading.Timer(seconds, future.run) + t.daemon = True + t.start() + return future + + def scheduleAtFixedRate(self, command, initial_delay, period, unit): + seconds = unit.toMillis(period) / 1000.0 + init_sec = unit.toMillis(initial_delay) / 1000.0 + def _run(): + _time.sleep(init_sec) + while True: + command.run() + _time.sleep(seconds) + t = _threading.Thread(target=_run, daemon=True) + t.start() + return FutureTask(command) + + def scheduleWithFixedDelay(self, command, initial_delay, delay, unit): + return self.scheduleAtFixedRate(command, initial_delay, delay, unit) + + +class ExecutorCompletionService(CompletionService): + def __init__(self, executor): + super().__init__() + self._executor = executor + self._queue = _queue.Queue() + + def submit(self, task): + future = self._executor.submit(task) + self._queue.put(future) + return future + + def take(self): + return self._queue.get() + + def poll(self, timeout=0, unit=None): + if unit is not None: + sec = unit.toMillis(timeout) / 1000.0 + else: + sec = timeout + try: + return self._queue.get(timeout=sec) + except _queue.Empty: + return None + + +# ============================================================ +# TimeUnit +# ============================================================ + +class TimeUnit(Stub): + NANOSECONDS = None + MICROSECONDS = None + MILLISECONDS = None + SECONDS = None + MINUTES = None + HOURS = None + DAYS = None + + def __init__(self, name, scale): + self._name = name + self._scale = scale # nanos per unit + + def convert(self, source_duration, source_unit): + return int(source_duration * source_unit._scale / self._scale) + + def toNanos(self, duration): + return int(duration * self._scale) + + def toMicros(self, duration): + return int(duration * self._scale // 1000) + + def toMillis(self, duration): + return int(duration * self._scale // 1_000_000) + + def toSeconds(self, duration): + return int(duration * self._scale // 1_000_000_000) + + def toMinutes(self, duration): + return self.toSeconds(duration) // 60 + + def toHours(self, duration): + return self.toMinutes(duration) // 60 + + def toDays(self, duration): + return self.toHours(duration) // 24 + + def sleep(self, timeout): + _time.sleep(self.toMillis(timeout) / 1000.0) + + def timedJoin(self, thread, timeout): + thread.join(self.toMillis(timeout) / 1000.0) + + def timedWait(self, obj, timeout): + return True + + def toString(self): + return self._name + + +TimeUnit.NANOSECONDS = TimeUnit("NANOSECONDS", 1) +TimeUnit.MICROSECONDS = TimeUnit("MICROSECONDS", 1000) +TimeUnit.MILLISECONDS = TimeUnit("MILLISECONDS", 1_000_000) +TimeUnit.SECONDS = TimeUnit("SECONDS", 1_000_000_000) +TimeUnit.MINUTES = TimeUnit("MINUTES", 60_000_000_000) +TimeUnit.HOURS = TimeUnit("HOURS", 3_600_000_000_000) +TimeUnit.DAYS = TimeUnit("DAYS", 86_400_000_000_000) + + +# ============================================================ +# CountDownLatch +# ============================================================ + +class CountDownLatch(Stub): + def __init__(self, count): + super().__init__() + self._count = count + self._condition = _threading.Condition() + + def await_(self, timeout=None, unit=None): + with self._condition: + if self._count == 0: + return True + if timeout is not None and unit is not None: + seconds = unit.toMillis(timeout) / 1000.0 + self._condition.wait(timeout=seconds) + return self._count == 0 + self._condition.wait() + return True + + def countDown(self): + with self._condition: + if self._count > 0: + self._count -= 1 + if self._count == 0: + self._condition.notify_all() + + def getCount(self): + return self._count + + def toString(self): + return f"CountDownLatch(count={self._count})" + + +# ============================================================ +# CyclicBarrier +# ============================================================ + +class CyclicBarrier(Stub): + def __init__(self, parties, barrier_action=None): + super().__init__() + self._parties = parties + self._barrier_action = barrier_action + self._count = parties + self._broken = False + self._lock = _threading.RLock() + self._condition = _threading.Condition() + + def await_(self, timeout=None, unit=None): + with self._condition: + if self._broken: + raise BrokenBarrierException() + self._count -= 1 + if self._count == 0: + if self._barrier_action: + try: + self._barrier_action.run() + except Exception: + self._broken = True + self._condition.notify_all() + raise BrokenBarrierException() + self._count = self._parties + self._condition.notify_all() + return 0 + if timeout is not None and unit is not None: + seconds = unit.toMillis(timeout) / 1000.0 + self._condition.wait(timeout=seconds) + if self._count > 0: + self._broken = True + raise BrokenBarrierException() + else: + self._condition.wait() + return self._count + + def getNumberWaiting(self): + return self._parties - self._count + + def getParties(self): + return self._parties + + def isBroken(self): + return self._broken + + def reset(self): + with self._condition: + self._broken = False + self._count = self._parties + self._condition.notify_all() + + +# ============================================================ +# Semaphore +# ============================================================ + +class Semaphore(Stub): + def __init__(self, permits, fair=False): + super().__init__() + self._sem = _threading.Semaphore(permits) if not fair else _threading.Semaphore(permits) + self._fair = fair + self._permits = permits + self._lock = _threading.Lock() + + def acquire(self): + self._sem.acquire() + + def acquireUninterruptibly(self): + self._sem.acquire() + + def release(self): + self._sem.release() + + def tryAcquire(self, timeout=None, unit=None): + if timeout is not None and unit is not None: + seconds = unit.toMillis(timeout) / 1000.0 + return self._sem.acquire(blocking=True, timeout=seconds) + return self._sem.acquire(blocking=False) + + def availablePermits(self): + return self._sem._value + + def drainPermits(self): + with self._lock: + val = self._sem._value + for _ in range(val): + self._sem.acquire(blocking=False) + return val + + def getQueueLength(self): + return 0 + + def hasQueuedThreads(self): + return False + + +# ============================================================ +# Phaser (stub) +# ============================================================ + +class Phaser(Stub): + def __init__(self, parties=0): + super().__init__() + self._parties = parties + self._phase = 0 + self._arrived = 0 + + def register(self): + self._parties += 1 + + def arrive(self): + self._arrived += 1 + return self._phase + + def arriveAndDeregister(self): + self._arrived += 1 + self._parties -= 1 + return self._phase + + def arriveAndAwaitAdvance(self): + self._arrived += 1 + if self._arrived >= self._parties: + self._phase += 1 + self._arrived = 0 + return self._phase + + def awaitAdvance(self, phase): + return self._phase + + def getPhase(self): + return self._phase + + def getArrivedParties(self): + return self._arrived + + def getRegisteredParties(self): + return self._parties + + def getUnarrivedParties(self): + return self._parties - self._arrived + + def isTerminated(self): + return False + + def forceTermination(self): + pass + + +# ============================================================ +# Exchanger +# ============================================================ + +class Exchanger(Stub): + def __init__(self): + super().__init__() + self._lock = _threading.Lock() + self._item = None + self._other_ready = _threading.Event() + + def exchange(self, x, timeout=None, unit=None): + with self._lock: + if self._item is None: + self._item = x + self._other_ready.set() + else: + result = self._item + self._item = x + self._other_ready.set() + return result + if timeout is not None and unit is not None: + seconds = unit.toMillis(timeout) / 1000.0 + self._other_ready.wait(timeout=seconds) + else: + self._other_ready.wait() + with self._lock: + result = self._item + self._item = None + return result + + +# ============================================================ +# ConcurrentHashMap +# ============================================================ + +class ConcurrentHashMap(Stub): + def __init__(self, initial_capacity=16): + super().__init__() + self._map = {} + self._lock = _threading.RLock() + + def put(self, key, value): + with self._lock: + self._map[key] = value + return None + + def get(self, key): + with self._lock: + return self._map.get(key) + + def containsKey(self, key): + with self._lock: + return key in self._map + + def containsValue(self, value): + with self._lock: + return value in self._map.values() + + def size(self): + with self._lock: + return len(self._map) + + def isEmpty(self): + with self._lock: + return len(self._map) == 0 + + def remove(self, key): + with self._lock: + return self._map.pop(key, None) + + def clear(self): + with self._lock: + self._map.clear() + + def keySet(self): + with self._lock: + return set(self._map.keys()) + + def values(self): + with self._lock: + return list(self._map.values()) + + def entrySet(self): + with self._lock: + return set(self._map.items()) + + def putAll(self, m): + with self._lock: + if hasattr(m, "_map"): + self._map.update(m._map) + elif isinstance(m, dict): + self._map.update(m) + + def putIfAbsent(self, key, value): + with self._lock: + if key not in self._map: + self._map[key] = value + return None + return self._map[key] + + def getOrDefault(self, key, default): + with self._lock: + return self._map.get(key, default) + + def forEach(self, action): + with self._lock: + for k, v in self._map.items(): + action(k, v) + + +# ============================================================ +# CopyOnWriteArrayList / CopyOnWriteArraySet +# ============================================================ + +class CopyOnWriteArrayList(Stub): + def __init__(self, *args): + super().__init__() + self._list = [] + self._lock = _threading.RLock() + if args and isinstance(args[0], (list, tuple)): + self._list = list(args[0]) + + def add(self, e): + with self._lock: + self._list = list(self._list) + self._list.append(e) + return True + + def get(self, index): + return self._list[index] + + def set(self, index, element): + with self._lock: + old = self._list[index] + self._list = list(self._list) + self._list[index] = element + return old + + def remove(self, e): + with self._lock: + new_list = list(self._list) + try: + new_list.remove(e) + self._list = new_list + return True + except ValueError: + return False + + def size(self): + return len(self._list) + + def isEmpty(self): + return len(self._list) == 0 + + def contains(self, e): + return e in self._list + + def iterator(self): + return iter(list(self._list)) + + def toArray(self): + return list(self._list) + + def clear(self): + with self._lock: + self._list = [] + + +class CopyOnWriteArraySet(Stub): + def __init__(self): + super().__init__() + self._backend = CopyOnWriteArrayList() + + def add(self, e): + if self._backend.contains(e): + return False + return self._backend.add(e) + + def remove(self, e): + return self._backend.remove(e) + + def contains(self, e): + return self._backend.contains(e) + + def size(self): + return self._backend.size() + + def isEmpty(self): + return self._backend.isEmpty() + + def iterator(self): + return self._backend.iterator() + + +# ============================================================ +# BlockingQueue / LinkedBlockingQueue / ArrayBlockingQueue +# ============================================================ + +class BlockingQueue(Stub): + pass + + +class LinkedBlockingQueue(BlockingQueue): + def __init__(self, capacity=None): + super().__init__() + self._queue = _queue.Queue(maxsize=capacity if capacity else 0) + + def put(self, item): + self._queue.put(item) + + def take(self): + return self._queue.get() + + def offer(self, item, timeout=None, unit=None): + if timeout is not None and unit is not None: + seconds = unit.toMillis(timeout) / 1000.0 + try: + self._queue.put(item, timeout=seconds) + return True + except _queue.Full: + return False + try: + self._queue.put_nowait(item) + return True + except _queue.Full: + return False + + def poll(self, timeout=None, unit=None): + if timeout is not None and unit is not None: + seconds = unit.toMillis(timeout) / 1000.0 + try: + return self._queue.get(timeout=seconds) + except _queue.Empty: + return None + try: + return self._queue.get_nowait() + except _queue.Empty: + return None + + def size(self): + return self._queue.qsize() + + def isEmpty(self): + return self._queue.empty() + + def remainingCapacity(self): + return self._queue.maxsize - self._queue.qsize() + + def clear(self): + while not self._queue.empty(): + try: + self._queue.get_nowait() + except _queue.Empty: + break + + def contains(self, item): + return item in list(self._queue.queue) + + +class ArrayBlockingQueue(LinkedBlockingQueue): + def __init__(self, capacity, fair=False): + super().__init__(capacity) + + +class PriorityBlockingQueue(BlockingQueue): + def __init__(self, capacity=None): + super().__init__() + self._heap = [] + self._lock = _threading.RLock() + self._not_empty = _threading.Condition(self._lock) + + def put(self, item): + with self._lock: + _queue.heappush(self._heap, item) + self._not_empty.notify() + + def take(self): + with self._lock: + while not self._heap: + self._not_empty.wait() + return _queue.heappop(self._heap) + + def offer(self, item, timeout=None, unit=None): + self.put(item) + return True + + def poll(self, timeout=None, unit=None): + with self._lock: + if not self._heap: + return None + return _queue.heappop(self._heap) + + def size(self): + with self._lock: + return len(self._heap) + + def isEmpty(self): + with self._lock: + return len(self._heap) == 0 + + def clear(self): + with self._lock: + self._heap = [] + + +class SynchronousQueue(BlockingQueue): + def __init__(self, fair=False): + super().__init__() + self._exchange = _queue.Queue(maxsize=1) + + def put(self, item): + self._exchange.put(item) + + def take(self): + return self._exchange.get() + + def offer(self, item, timeout=None, unit=None): + try: + self._exchange.put_nowait(item) + return True + except _queue.Full: + return False + + def poll(self, timeout=None, unit=None): + try: + return self._exchange.get_nowait() + except _queue.Empty: + return None + + +class DelayQueue(BlockingQueue): + def __init__(self): + super().__init__() + self._queue = [] + + def put(self, item): + _queue.heappush(self._queue, item) + + def take(self): + while True: + if self._queue: + item = self._queue[0] + delay = item.getDelay(TimeUnit.MILLISECONDS) + if delay <= 0: + return _queue.heappop(self._queue) + _time.sleep(delay / 1000.0) + else: + _time.sleep(0.1) + + +class ConcurrentLinkedQueue(Stub): + def __init__(self): + super().__init__() + self._queue = _queue.Queue() + + def add(self, item): + self._queue.put(item) + return True + + def offer(self, item): + self._queue.put_nowait(item) + return True + + def poll(self): + try: + return self._queue.get_nowait() + except _queue.Empty: + return None + + def peek(self): + try: + item = self._queue.get_nowait() + self._queue.put_nowait(item) + return item + except _queue.Empty: + return None + + def size(self): + return self._queue.qsize() + + def isEmpty(self): + return self._queue.empty() + + def contains(self, item): + return item in list(self._queue.queue) + + +class ConcurrentLinkedDeque(ConcurrentLinkedQueue): + def addFirst(self, item): + self._queue.put(item) + + def addLast(self, item): + self._queue.put(item) + + def pollFirst(self): + return self.poll() + + def pollLast(self): + return self.poll() + + +class BlockingDeque(BlockingQueue): + pass + + +# ============================================================ +# Atomic classes +# ============================================================ + +class AtomicBoolean(Stub): + def __init__(self, initial=False): + super().__init__() + self._value = initial + self._lock = _threading.Lock() + + def get(self): + with self._lock: + return self._value + + def set(self, new_value): + with self._lock: + self._value = new_value + + def compareAndSet(self, expect, update): + with self._lock: + if self._value == expect: + self._value = update + return True + return False + + def getAndSet(self, new_value): + with self._lock: + old = self._value + self._value = new_value + return old + + def toString(self): + return str(self._value) + + +class AtomicInteger(Stub): + def __init__(self, initial=0): + super().__init__() + self._value = int(initial) + self._lock = _threading.Lock() + + def get(self): + with self._lock: + return self._value + + def set(self, new_value): + with self._lock: + self._value = int(new_value) + + def getAndSet(self, new_value): + with self._lock: + old = self._value + self._value = int(new_value) + return old + + def compareAndSet(self, expect, update): + with self._lock: + if self._value == expect: + self._value = int(update) + return True + return False + + def weakCompareAndSet(self, expect, update): + return self.compareAndSet(expect, update) + + def getAndIncrement(self): + with self._lock: + old = self._value + self._value += 1 + return old + + def getAndDecrement(self): + with self._lock: + old = self._value + self._value -= 1 + return old + + def getAndAdd(self, delta): + with self._lock: + old = self._value + self._value += delta + return old + + def incrementAndGet(self): + with self._lock: + self._value += 1 + return self._value + + def decrementAndGet(self): + with self._lock: + self._value -= 1 + return self._value + + def addAndGet(self, delta): + with self._lock: + self._value += delta + return self._value + + def lazySet(self, new_value): + with self._lock: + self._value = int(new_value) + + def updateAndGet(self, func): + with self._lock: + self._value = func(self._value) + return self._value + + def accumulateAndGet(self, x, func): + with self._lock: + self._value = func(self._value, x) + return self._value + + def intValue(self): + return self.get() + + def longValue(self): + return self.get() + + def floatValue(self): + return float(self.get()) + + def doubleValue(self): + return float(self.get()) + + def toString(self): + return str(self._value) + + +class AtomicLong(AtomicInteger): + pass + + +class AtomicReference(Stub): + def __init__(self, initial=None): + super().__init__() + self._value = initial + self._lock = _threading.Lock() + + def get(self): + with self._lock: + return self._value + + def set(self, new_value): + with self._lock: + self._value = new_value + + def compareAndSet(self, expect, update): + with self._lock: + if self._value == expect: + self._value = update + return True + return False + + def getAndSet(self, new_value): + with self._lock: + old = self._value + self._value = new_value + return old + + def getAndUpdate(self, func): + with self._lock: + old = self._value + self._value = func(old) + return old + + def updateAndGet(self, func): + with self._lock: + self._value = func(self._value) + return self._value + + def accumulateAndGet(self, x, func): + with self._lock: + self._value = func(self._value, x) + return self._value + + +class AtomicIntegerArray(Stub): + def __init__(self, length_or_array): + super().__init__() + if isinstance(length_or_array, int): + self._array = [0] * length_or_array + else: + self._array = list(length_or_array) + + def get(self, i): + return self._array[i] + + def set(self, i, new_value): + self._array[i] = new_value + + def compareAndSet(self, i, expect, update): + if self._array[i] == expect: + self._array[i] = update + return True + return False + + def getAndAdd(self, i, delta): + old = self._array[i] + self._array[i] += delta + return old + + def addAndGet(self, i, delta): + self._array[i] += delta + return self._array[i] + + def length(self): + return len(self._array) + + +class AtomicLongArray(AtomicIntegerArray): + pass + + +class AtomicReferenceArray(Stub): + def __init__(self, length_or_array): + super().__init__() + if isinstance(length_or_array, int): + self._array = [None] * length_or_array + else: + self._array = list(length_or_array) + + def get(self, i): + return self._array[i] + + def set(self, i, new_value): + self._array[i] = new_value + + def compareAndSet(self, i, expect, update): + if self._array[i] == expect: + self._array[i] = update + return True + return False + + def length(self): + return len(self._array) + + +class AtomicIntegerFieldUpdater(Stub): + @staticmethod + def newUpdater(tclass, field_name): + return AtomicIntegerFieldUpdater() + + def get(self, obj): + return 0 + + def set(self, obj, new_value): + pass + + def compareAndSet(self, obj, expect, update): + return True + + +class AtomicLongFieldUpdater(AtomicIntegerFieldUpdater): + pass + + +class AtomicReferenceFieldUpdater(Stub): + @staticmethod + def newUpdater(tclass, vclass, field_name): + return AtomicReferenceFieldUpdater() + + def get(self, obj): + return None + + def set(self, obj, new_value): + pass + + def compareAndSet(self, obj, expect, update): + return True + + +class AtomicMarkableReference(Stub): + def __init__(self, initial_ref, initial_mark): + super().__init__() + self._ref = initial_ref + self._mark = initial_mark + + def getReference(self): + return self._ref + + def isMarked(self): + return self._mark + + def compareAndSet(self, expected_ref, new_ref, expected_mark, new_mark): + if self._ref == expected_ref and self._mark == expected_mark: + self._ref = new_ref + self._mark = new_mark + return True + return False + + def attemptMark(self, expected_ref, new_mark): + if self._ref == expected_ref: + self._mark = new_mark + return True + return False + + +class AtomicStampedReference(Stub): + def __init__(self, initial_ref, initial_stamp): + super().__init__() + self._ref = initial_ref + self._stamp = initial_stamp + + def getReference(self): + return self._ref + + def getStamp(self): + return self._stamp + + def compareAndSet(self, expected_ref, new_ref, expected_stamp, new_stamp): + if self._ref == expected_ref and self._stamp == expected_stamp: + self._ref = new_ref + self._stamp = new_stamp + return True + return False + + def attemptStamp(self, expected_ref, new_stamp): + if self._ref == expected_ref: + self._stamp = new_stamp + return True + return False + + def set(self, new_ref, new_stamp): + self._ref = new_ref + self._stamp = new_stamp + + +class DoubleAccumulator(Stub): + def __init__(self, accumulator_function, identity): + super().__init__() + self._value = identity + self._func = accumulator_function + + def accumulate(self, x): + self._value = self._func(self._value, x) + + def get(self): + return self._value + + def reset(self): + self._value = 0.0 + + +class DoubleAdder(Stub): + def __init__(self): + super().__init__() + self._value = 0.0 + + def add(self, x): + self._value += x + + def sum(self): + return self._value + + def reset(self): + self._value = 0.0 + + def doubleValue(self): + return self._value + + def toString(self): + return str(self._value) + + +class LongAccumulator(Stub): + def __init__(self, accumulator_function, identity): + super().__init__() + self._value = identity + self._func = accumulator_function + + def accumulate(self, x): + self._value = self._func(self._value, x) + + def get(self): + return self._value + + def reset(self): + self._value = 0 + + +class LongAdder(Stub): + def __init__(self): + super().__init__() + self._value = 0 + + def add(self, x): + self._value += x + + def sum(self): + return self._value + + def reset(self): + self._value = 0 + + def intValue(self): + return self._value + + def longValue(self): + return self._value + + def toString(self): + return str(self._value) + + +# ============================================================ +# ReentrantLock +# ============================================================ + +class Lock(Stub): + def lock(self): + raise NotImplementedError + + def lockInterruptibly(self): + raise NotImplementedError + + def tryLock(self, timeout=None, unit=None): + raise NotImplementedError + + def unlock(self): + raise NotImplementedError + + def newCondition(self): + raise NotImplementedError + + +class ReentrantLock(Lock): + def __init__(self, fair=False): + super().__init__() + self._lock = _threading.RLock() if not fair else _threading.RLock() + + def lock(self): + self._lock.acquire() + + def lockInterruptibly(self): + self._lock.acquire() + + def tryLock(self, timeout=None, unit=None): + if timeout is not None and unit is not None: + seconds = unit.toMillis(timeout) / 1000.0 + return self._lock.acquire(timeout=seconds) + return self._lock.acquire(blocking=False) + + def unlock(self): + self._lock.release() + + def newCondition(self): + return Condition() + + def getHoldCount(self): + return 1 if self._lock._is_owned() else 0 + + def isHeldByCurrentThread(self): + return self._lock._is_owned() + + def isLocked(self): + return True + + def getQueueLength(self): + return 0 + + def hasQueuedThreads(self): + return False + + def getOwner(self): + return _threading.current_thread() if self.isHeldByCurrentThread() else None + + +# ============================================================ +# ReadWriteLock +# ============================================================ + +class ReadWriteLock(Stub): + def readLock(self): + raise NotImplementedError + + def writeLock(self): + raise NotImplementedError + + +class ReentrantReadWriteLock(ReadWriteLock): + class ReadLock(Lock): + def __init__(self, rw_lock): + super().__init__() + self._rw_lock = rw_lock + + def lock(self): + self._rw_lock._read_lock.acquire() + + def unlock(self): + self._rw_lock._read_lock.release() + + def tryLock(self, timeout=None, unit=None): + return self._rw_lock._read_lock.acquire(blocking=False) + + class WriteLock(Lock): + def __init__(self, rw_lock): + super().__init__() + self._rw_lock = rw_lock + + def lock(self): + self._rw_lock._write_lock.acquire() + + def unlock(self): + self._rw_lock._write_lock.release() + + def tryLock(self, timeout=None, unit=None): + return self._rw_lock._write_lock.acquire(blocking=False) + + def __init__(self, fair=False): + super().__init__() + self._read_lock_obj = _threading.RLock() + self._write_lock_obj = _threading.Lock() + self._read_lock = ReentrantReadWriteLock.ReadLock(self) + self._write_lock = ReentrantReadWriteLock.WriteLock(self) + + def readLock(self): + return self._read_lock + + def writeLock(self): + return self._write_lock + + +class Condition(Stub): + def __init__(self): + super().__init__() + self._cond = _threading.Condition() + + def await_(self, timeout=None, unit=None): + if timeout is not None and unit is not None: + seconds = unit.toMillis(timeout) / 1000.0 + with self._cond: + return self._cond.wait(timeout=seconds) + with self._cond: + self._cond.wait() + + def awaitUninterruptibly(self): + with self._cond: + self._cond.wait() + + def awaitNanos(self, nanos_timeout): + seconds = nanos_timeout / 1_000_000_000.0 + with self._cond: + self._cond.wait(timeout=seconds) + return 0 + + def awaitUntil(self, deadline): + remaining = (deadline - _time.time()) * 1000 + if remaining > 0: + self.await_(remaining, TimeUnit.MILLISECONDS) + + def signal(self): + with self._cond: + self._cond.notify() + + def signalAll(self): + with self._cond: + self._cond.notify_all() + + +class LockSupport(Stub): + @staticmethod + def park(): + _time.sleep(1) + + @staticmethod + def parkNanos(nanos): + _time.sleep(nanos / 1_000_000_000.0) + + @staticmethod + def parkUntil(deadline): + remaining = deadline - _time.time() + if remaining > 0: + _time.sleep(remaining) + + @staticmethod + def unpark(thread): + pass + + +# ============================================================ +# AbstractQueuedSynchronizer (stubs) +# ============================================================ + +class AbstractQueuedSynchronizer(Stub): + def __init__(self): + super().__init__() + self._state = 0 + + def getState(self): + return self._state + + def setState(self, state): + self._state = state + + def compareAndSetState(self, expect, update): + if self._state == expect: + self._state = update + return True + return False + + def acquire(self, arg): + pass + + def acquireInterruptibly(self, arg): + pass + + def tryAcquire(self, arg): + return True + + def tryRelease(self, arg): + return True + + def release(self, arg): + return True + + def acquireShared(self, arg): + pass + + def releaseShared(self, arg): + return True + + def tryAcquireShared(self, arg): + return 0 + + def tryReleaseShared(self, arg): + return True + + def hasQueuedThreads(self): + return False + + def getQueueLength(self): + return 0 + + +class AbstractQueuedLongSynchronizer(AbstractQueuedSynchronizer): + pass + + +# ============================================================ +# Flow / SubmissionPublisher (stubs) +# ============================================================ + +class Flow(Stub): + class Publisher(Stub): + def subscribe(self, subscriber): + pass + + class Subscriber(Stub): + def onSubscribe(self, subscription): + pass + + def onNext(self, item): + pass + + def onError(self, throwable): + pass + + def onComplete(self): + pass + + class Subscription(Stub): + def request(self, n): + pass + + def cancel(self): + pass + + class Processor(Stub): + pass + + +class SubmissionPublisher(Flow.Publisher): + def __init__(self): + super().__init__() + self._subscribers = [] + + def subscribe(self, subscriber): + self._subscribers.append(subscriber) + + def submit(self, item): + for sub in self._subscribers: + sub.onNext(item) + return 1 + + def close(self): + for sub in self._subscribers: + sub.onComplete() + + +# ============================================================ +# ForkJoinPool / ForkJoinTask (stubs) +# ============================================================ + +class ForkJoinPool(Stub): + def __init__(self, parallelism=None): + super().__init__() + self._parallelism = parallelism or _py_math.ceil(_threading._count / 2) + self._pool = _futures.ThreadPoolExecutor(max_workers=self._parallelism) + + def execute(self, task): + self._pool.submit(task.run) + + def submit(self, task): + future = FutureTask(task) + self._pool.submit(future.run) + return future + + def invoke(self, task): + return task.run() + + def shutdown(self): + self._pool.shutdown(wait=False) + + +class ForkJoinTask(Future): + def fork(self): + return self + + def join(self): + return None + + def invoke(self): + return None + + def adapt(self, callable_or_runnable): + return ForkJoinTask() + + +class RecursiveAction(ForkJoinTask): + def compute(self): + raise NotImplementedError + + def run(self): + self.compute() + + +class RecursiveTask(ForkJoinTask): + def compute(self): + raise NotImplementedError + + def run(self): + self.compute() + + +class ForkJoinWorkerThread(Stub): + def __init__(self, pool): + super().__init__() + self._pool = pool + + def getPool(self): + return self._pool \ No newline at end of file diff --git a/android_pyapi/java/util_regex.py b/android_pyapi/java/util_regex.py new file mode 100644 index 0000000..53e9b7b --- /dev/null +++ b/android_pyapi/java/util_regex.py @@ -0,0 +1,287 @@ +""" +Java regex standard library APIs implemented in Python. +java.util.regex package - Pattern, Matcher, MatchResult, PatternSyntaxException. +""" + +from .._core import Stub +from .io import IOException +from .lang import RuntimeException +import re as _re + +IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {}) +IllegalStateException = type("IllegalStateException", (RuntimeException,), {}) + +__all__ = [ + "Pattern", "Matcher", "MatchResult", "PatternSyntaxException", +] + + +# ============================================================ +# PatternSyntaxException +# ============================================================ + +class PatternSyntaxException(IllegalArgumentException): + def __init__(self, desc, regex, index): + super().__init__(f"{desc}: {regex} at index {index}") + self._desc = desc + self._regex = regex + self._index = index + + def getDescription(self): + return self._desc + + def getPattern(self): + return self._regex + + def getIndex(self): + return self._index + + def getMessage(self): + return f"{self._desc} near index {self._index}: {self._regex}" + + +# ============================================================ +# MatchResult +# ============================================================ + +class MatchResult(Stub): + def start(self, group=None): + raise NotImplementedError + + def end(self, group=None): + raise NotImplementedError + + def group(self, group=None): + raise NotImplementedError + + def groupCount(self): + raise NotImplementedError + + +# ============================================================ +# Matcher +# ============================================================ + +class Matcher(MatchResult): + def __init__(self, pattern, input_str): + super().__init__() + self._pattern = pattern + self._input = input_str + self._re_pattern = pattern._pattern + self._match = None + self._region_start = 0 + self._region_end = len(input_str) + self._transparent_bounds = False + self._anchoring_bounds = True + self._last_match = None + + def matches(self): + self._match = self._re_pattern.fullmatch(self._input, self._region_start, self._region_end) + self._last_match = self._match + return self._match is not None + + def find(self, start=None): + if start is not None: + self._match = self._re_pattern.search(self._input, start, self._region_end) + else: + if self._match is None: + self._match = self._re_pattern.search(self._input, self._region_start, self._region_end) + else: + pos = self._match.end() + self._match = self._re_pattern.search(self._input, pos, self._region_end) + if self._match: + self._last_match = self._match + return self._match is not None + + def lookingAt(self): + self._match = self._re_pattern.match(self._input, self._region_start, self._region_end) + self._last_match = self._match + return self._match is not None + + def start(self, group=0): + if self._match is None: + raise IllegalStateException("No match available") + if group == 0: + return self._match.start() + return self._match.start(group) + + def end(self, group=0): + if self._match is None: + raise IllegalStateException("No match available") + if group == 0: + return self._match.end() + return self._match.end(group) + + def group(self, group=0): + if self._match is None: + raise IllegalStateException("No match available") + if isinstance(group, str): + return self._match.group(group) + return self._match.group(group) + + def groupCount(self): + return self._re_pattern.groups + + def replaceAll(self, replacement): + return self._re_pattern.sub(replacement, self._input) + + def replaceFirst(self, replacement): + return self._re_pattern.sub(replacement, self._input, count=1) + + def appendReplacement(self, sb, replacement): + if self._match is None: + raise IllegalStateException("No match available") + self._append_pos = getattr(self, '_append_pos', 0) + sb.append(self._input[self._append_pos:self._match.start()]) + sb.append(self._re_pattern.sub(replacement, self._match.group(), count=1)) + self._append_pos = self._match.end() + return self + + def appendTail(self, sb): + self._append_pos = getattr(self, '_append_pos', 0) + sb.append(self._input[self._append_pos:]) + return sb + + def reset(self, input_str=None): + if input_str is not None: + self._input = input_str + self._region_end = len(input_str) + self._match = None + self._last_match = None + return self + + def region(self, start, end): + self._region_start = start + self._region_end = end + return self + + def regionStart(self): + return self._region_start + + def regionEnd(self): + return self._region_end + + def hasTransparentBounds(self): + return self._transparent_bounds + + def hasAnchoringBounds(self): + return self._anchoring_bounds + + def useAnchoringBounds(self, value): + self._anchoring_bounds = value + return self + + def useTransparentBounds(self, value): + self._transparent_bounds = value + return self + + def hitEnd(self): + return self._match is not None and self._match.end() >= self._region_end + + def requireEnd(self): + return self._match is not None and not self.hitEnd() + + def toMatchResult(self): + result = Matcher(self._pattern, self._input) + result._match = self._match + result._last_match = self._last_match + return result + + def pattern(self): + return self._pattern + + def toString(self): + return f"Matcher[pattern={self._pattern.pattern()}]" + + def namedGroups(self): + return self._re_pattern.groupindex + + +class IllegalStateException(RuntimeException): + pass + + +# ============================================================ +# Pattern +# ============================================================ + +class Pattern(Stub): + CANON_EQ = 128 + CASE_INSENSITIVE = 2 + COMMENTS = 4 + DOTALL = 32 + LITERAL = 16 + MULTILINE = 8 + UNICODE_CASE = 64 + UNICODE_CHARACTER_CLASS = 256 + UNIX_LINES = 1 + + _re_flags_map = { + 0: 0, # default + 2: _re.IGNORECASE, + 8: _re.MULTILINE, + 32: _re.DOTALL, + 64: _re.UNICODE, + 4: _re.VERBOSE, + } + + def __init__(self, regex, flags=0): + super().__init__() + self._regex = str(regex) + self._flags = flags + re_flags = 0 + for java_flag, py_flag in self._re_flags_map.items(): + if flags & java_flag: + re_flags |= py_flag + try: + self._pattern = _re.compile(self._regex, re_flags) + except _re.error as e: + raise PatternSyntaxException(str(e), self._regex, e.pos if hasattr(e, 'pos') else 0) + + @staticmethod + def compile(regex, flags=0): + return Pattern(regex, flags) + + def matcher(self, input_str): + return Matcher(self, input_str) + + def split(self, input_str, limit=0): + if limit <= 0: + parts = self._pattern.split(str(input_str)) + if limit == 0: + while parts and parts[-1] == "": + parts.pop() + else: + parts = self._pattern.split(str(input_str), maxsplit=limit - 1) + while len(parts) < limit: + parts.append("") + return parts + + def splitAsStream(self, input_str): + return iter(self.split(input_str)) + + @staticmethod + def matches(regex, input_str): + return bool(_re.fullmatch(regex, str(input_str))) + + @staticmethod + def quote(s): + return _re.escape(str(s)) + + def flags(self): + return self._flags + + def pattern(self): + return self._regex + + def toString(self): + return self._regex + + def predicate(self): + return lambda s: bool(self._pattern.fullmatch(str(s))) + + def asPredicate(self): + return self.predicate() + + def asMatchPredicate(self): + return lambda s: bool(self._pattern.fullmatch(str(s))) \ No newline at end of file diff --git a/android_pyapi/java/util_zip.py b/android_pyapi/java/util_zip.py new file mode 100644 index 0000000..034616c --- /dev/null +++ b/android_pyapi/java/util_zip.py @@ -0,0 +1,697 @@ +""" +Java zip standard library APIs implemented in Python. +java.util.zip package - ZipFile, ZipEntry, GZIP, CRC, Deflater, Inflater. +""" + +from .._core import Stub +from .io import IOException, Closeable, Flushable +import zipfile as _zipfile +import gzip as _gzip +import zlib as _zlib +import io as _pyio +import os as _os +from datetime import datetime as _datetime + +__all__ = [ + "ZipFile", "ZipEntry", "ZipOutputStream", "ZipInputStream", + "GZIPInputStream", "GZIPOutputStream", + "CRC32", "CheckedInputStream", "CheckedOutputStream", + "Adler32", + "DataFormatException", "ZipException", + "Deflater", "Inflater", + "DeflaterOutputStream", "InflaterInputStream", +] + + +# ============================================================ +# Exception classes +# ============================================================ + +class ZipException(IOException): + pass + +class DataFormatException(Exception): + pass + + +# ============================================================ +# CRC32 +# ============================================================ + +class CRC32(Stub): + def __init__(self): + super().__init__() + self._value = 0 + + def getValue(self): + return self._value + + def reset(self): + self._value = 0 + + def update(self, b, off=None, length=None): + if isinstance(b, int): + self._value = _zlib.crc32(bytes([b & 0xFF]), self._value) & 0xFFFFFFFF + elif isinstance(b, (bytes, bytearray)): + if off is not None and length is not None: + self._value = _zlib.crc32(bytes(b[off:off+length]), self._value) & 0xFFFFFFFF + else: + self._value = _zlib.crc32(bytes(b), self._value) & 0xFFFFFFFF + + +# ============================================================ +# Adler32 +# ============================================================ + +class Adler32(Stub): + def __init__(self): + super().__init__() + self._value = 1 + + def getValue(self): + return self._value + + def reset(self): + self._value = 1 + + def update(self, b, off=None, length=None): + if isinstance(b, int): + self._value = _zlib.adler32(bytes([b & 0xFF]), self._value) & 0xFFFFFFFF + elif isinstance(b, (bytes, bytearray)): + if off is not None and length is not None: + self._value = _zlib.adler32(bytes(b[off:off+length]), self._value) & 0xFFFFFFFF + else: + self._value = _zlib.adler32(bytes(b), self._value) & 0xFFFFFFFF + + +# ============================================================ +# CheckedInputStream / CheckedOutputStream +# ============================================================ + +class CheckedInputStream(Closeable): + def __init__(self, inp, cksum): + super().__init__() + self._in = inp + self._cksum = cksum + + def read(self, b=None, off=None, length=None): + if b is None: + result = self._in.read() + if result >= 0: + self._cksum.update(result) + return result + if off is None: + off = 0 + if length is None: + length = len(b) + result = self._in.read(b, off, length) + if result > 0: + self._cksum.update(b[off:off+result]) + return result + + def getChecksum(self): + return self._cksum + + def close(self): + self._in.close() + + def skip(self, n): + return self._in.skip(n) + + +class CheckedOutputStream(Closeable, Flushable): + def __init__(self, out, cksum): + super().__init__() + self._out = out + self._cksum = cksum + + def write(self, b, off=None, length=None): + if isinstance(b, int): + self._out.write(b) + self._cksum.update(b) + else: + if off is not None and length is not None: + data = bytes(b[off:off+length]) + else: + data = bytes(b) + self._out.write(data) + self._cksum.update(data) + + def getChecksum(self): + return self._cksum + + def flush(self): + self._out.flush() + + def close(self): + self._out.close() + + +# ============================================================ +# ZipEntry +# ============================================================ + +class ZipEntry(Stub): + STORED = 0 + DEFLATED = 8 + + def __init__(self, name): + super().__init__() + self._name = name + self._method = ZipEntry.DEFLATED + self._size = 0 + self._compressed_size = 0 + self._crc = 0 + self._comment = "" + self._time = 0 + self._extra = b"" + self._is_directory = name.endswith("/") + + def getName(self): + return self._name + + def getMethod(self): + return self._method + + def setMethod(self, method): + self._method = method + + def getSize(self): + return self._size + + def setSize(self, size): + self._size = size + + def getCompressedSize(self): + return self._compressed_size + + def setCompressedSize(self, size): + self._compressed_size = size + + def getCrc(self): + return self._crc + + def setCrc(self, crc): + self._crc = crc + + def getComment(self): + return self._comment + + def setComment(self, comment): + self._comment = comment + + def getTime(self): + return self._time + + def setTime(self, time): + self._time = time + + def getExtra(self): + return self._extra + + def setExtra(self, extra): + self._extra = extra + + def isDirectory(self): + return self._is_directory + + def toString(self): + return self._name + + def __str__(self): + return self._name + + +# ============================================================ +# ZipFile +# ============================================================ + +class ZipFile(Closeable): + OPEN_READ = 1 + OPEN_DELETE = 2 + + def __init__(self, file, mode="r"): + super().__init__() + if isinstance(file, str): + path = file + else: + path = file.getPath() + self._path = path + self._mode = mode + try: + self._zfile = _zipfile.ZipFile(path, mode) + except Exception as e: + raise ZipException(str(e)) + + def entries(self): + return iter(self._zfile.infolist()) + + def getEntry(self, name): + try: + info = self._zfile.getinfo(name) + entry = ZipEntry(info.filename) + entry.setMethod(info.compress_type) + entry.setSize(info.file_size) + entry.setCompressedSize(info.compress_size) + entry.setCrc(info.CRC) + entry.setTime(int(_datetime(*info.date_time).timestamp() * 1000) if info.date_time else 0) + return entry + except KeyError: + return None + + def getInputStream(self, entry): + try: + data = self._zfile.read(entry.getName() if isinstance(entry, ZipEntry) else entry) + from ..io import ByteArrayInputStream + return ByteArrayInputStream(data) + except Exception as e: + raise ZipException(str(e)) + + def close(self): + self._zfile.close() + + def size(self): + return len(self._zfile.namelist()) + + def getName(self): + return self._path + + def getComment(self): + return "" + + +# ============================================================ +# ZipOutputStream +# ============================================================ + +class ZipOutputStream(Closeable, Flushable): + STORED = 0 + DEFLATED = 8 + + def __init__(self, out): + super().__init__() + self._out = out + self._zfile = _zipfile.ZipFile(out, "w", _zipfile.ZIP_DEFLATED) + self._method = ZipOutputStream.DEFLATED + self._level = -1 + self._comment = "" + + def putNextEntry(self, entry): + zi = _zipfile.ZipInfo(entry.getName() if isinstance(entry, ZipEntry) else str(entry)) + if hasattr(entry, 'getTime') and entry.getTime(): + dt = _datetime.fromtimestamp(entry.getTime() / 1000.0) + zi.date_time = dt.timetuple()[:6] + self._zfile.writestr(zi, b"") + + def closeEntry(self): + pass + + def write(self, b, off=None, length=None): + if off is not None and length is not None: + self._zfile._zout.write(bytes(b[off:off+length])) + else: + self._zfile._zout.write(bytes(b) if not isinstance(b, (bytes, bytearray)) else b) + + def finish(self): + self._zfile.close() + + def close(self): + self._zfile.close() + + def setMethod(self, method): + self._method = method + + def setLevel(self, level): + self._level = level + + def setComment(self, comment): + self._comment = comment + + def flush(self): + self._zfile._zout.flush() if hasattr(self._zfile._zout, 'flush') else None + + +# ============================================================ +# ZipInputStream +# ============================================================ + +class ZipInputStream(Closeable): + def __init__(self, inp): + super().__init__() + self._inp = inp + self._zfile = _zipfile.ZipFile(inp) + self._entries = iter(self._zfile.infolist()) + self._current_entry = None + self._current_data = b"" + self._current_pos = 0 + + def getNextEntry(self): + try: + info = next(self._entries) + entry = ZipEntry(info.filename) + entry.setMethod(info.compress_type) + entry.setSize(info.file_size) + entry.setCompressedSize(info.compress_size) + entry.setCrc(info.CRC) + self._current_entry = info + self._current_data = self._zfile.read(info) + self._current_pos = 0 + return entry + except StopIteration: + self._current_entry = None + self._current_data = b"" + return None + + def read(self, b=None, off=None, length=None): + if self._current_entry is None: + return -1 + avail = len(self._current_data) - self._current_pos + if avail <= 0: + return -1 + if b is None: + val = self._current_data[self._current_pos] + self._current_pos += 1 + return val + if off is None: + off = 0 + if length is None: + length = len(b) + n = min(length, avail) + if isinstance(b, bytearray): + b[off:off+n] = self._current_data[self._current_pos:self._current_pos+n] + self._current_pos += n + return n + + def closeEntry(self): + self._current_entry = None + self._current_data = b"" + + def available(self): + if self._current_entry is None: + return 0 + return len(self._current_data) - self._current_pos + + def close(self): + self._zfile.close() + + +# ============================================================ +# GZIPInputStream +# ============================================================ + +class GZIPInputStream(Closeable): + def __init__(self, inp, size=512): + super().__init__() + self._inp = inp + self._gzip_file = _gzip.GzipFile(fileobj=_pyio.BufferedReader(inp) if hasattr(inp, 'read') else inp) + + def read(self, b=None, off=None, length=None): + if b is None: + data = self._gzip_file.read(1) + return data[0] if data else -1 + if off is None: + off = 0 + if length is None: + length = len(b) + data = self._gzip_file.read(length) + if not data: + return -1 + n = len(data) + if isinstance(b, bytearray): + b[off:off+n] = data + else: + ba = bytearray(b) + ba[off:off+n] = data + b[:] = bytes(ba) + return n + + def close(self): + self._gzip_file.close() + + +# ============================================================ +# GZIPOutputStream +# ============================================================ + +class GZIPOutputStream(Closeable, Flushable): + def __init__(self, out, size=512): + super().__init__() + self._out = out + self._gzip_file = _gzip.GzipFile(fileobj=out, mode="wb") + + def write(self, b, off=None, length=None): + if isinstance(b, int): + self._gzip_file.write(bytes([b & 0xFF])) + elif isinstance(b, (bytes, bytearray)): + if off is not None and length is not None: + self._gzip_file.write(bytes(b[off:off+length])) + else: + self._gzip_file.write(bytes(b)) + + def finish(self): + self._gzip_file.close() + + def close(self): + self._gzip_file.close() + + def flush(self): + self._gzip_file.flush() + + +# ============================================================ +# Deflater +# ============================================================ + +class Deflater(Stub): + BEST_COMPRESSION = 9 + BEST_SPEED = 1 + DEFAULT_COMPRESSION = -1 + DEFAULT_STRATEGY = 0 + FILTERED = 1 + HUFFMAN_ONLY = 2 + NO_COMPRESSION = 0 + NO_FLUSH = 0 + SYNC_FLUSH = 2 + FULL_FLUSH = 3 + + def __init__(self, level=-1, nowrap=False): + super().__init__() + self._level = level + self._nowrap = nowrap + self._compress = _zlib.compressobj(level=level if level >= 0 else 6, + method=_zlib.DEFLATED, + wbits=-_zlib.MAX_WBITS if nowrap else _zlib.MAX_WBITS) + self._input_buffer = b"" + self._finished = False + + def setInput(self, data, off=0, length=-1): + if length < 0: + length = len(data) - off + self._input_buffer = bytes(data[off:off+length]) + + def needsInput(self): + return len(self._input_buffer) == 0 + + def setDictionary(self, dictionary): + pass + + def getTotalIn(self): + return len(self._input_buffer) + + def getTotalOut(self): + return 0 + + def deflate(self, output, off=0, length=-1): + if length < 0: + length = len(output) - off + data = self._compress.compress(self._input_buffer) + self._input_buffer = b"" + n = min(len(data), length) + if isinstance(output, bytearray): + output[off:off+n] = data[:n] + else: + ba = bytearray(output) + ba[off:off+n] = data[:n] + output[:] = bytes(ba) + return n + + def finish(self): + self._finished = True + + def finished(self): + return self._finished + + def end(self): + pass + + def getAdler(self): + return 1 + + def reset(self): + self._compress = _zlib.compressobj(level=self._level if self._level >= 0 else 6, + method=_zlib.DEFLATED, + wbits=-_zlib.MAX_WBITS if self._nowrap else _zlib.MAX_WBITS) + self._input_buffer = b"" + self._finished = False + + +# ============================================================ +# Inflater +# ============================================================ + +class Inflater(Stub): + def __init__(self, nowrap=False): + super().__init__() + self._nowrap = nowrap + wbits = -_zlib.MAX_WBITS if nowrap else _zlib.MAX_WBITS + self._decompress = _zlib.decompressobj(wbits) + self._input_buffer = b"" + self._finished = False + + def setInput(self, data, off=0, length=-1): + if length < 0: + length = len(data) - off + self._input_buffer = bytes(data[off:off+length]) + + def needsInput(self): + return len(self._input_buffer) == 0 + + def setDictionary(self, dictionary): + pass + + def getTotalIn(self): + return len(self._input_buffer) + + def getTotalOut(self): + return 0 + + def inflate(self, output, off=0, length=-1): + if length < 0: + length = len(output) - off + try: + data = self._decompress.decompress(self._input_buffer) + self._input_buffer = b"" + n = min(len(data), length) + if isinstance(output, bytearray): + output[off:off+n] = data[:n] + else: + ba = bytearray(output) + ba[off:off+n] = data[:n] + output[:] = bytes(ba) + return n + except _zlib.error as e: + raise DataFormatException(str(e)) + + def finished(self): + return self._finished + + def end(self): + pass + + def getAdler(self): + return 1 + + def needsDictionary(self): + return False + + def reset(self): + wbits = -_zlib.MAX_WBITS if self._nowrap else _zlib.MAX_WBITS + self._decompress = _zlib.decompressobj(wbits) + self._input_buffer = b"" + self._finished = False + + +# ============================================================ +# DeflaterOutputStream +# ============================================================ + +class DeflaterOutputStream(Closeable, Flushable): + def __init__(self, out, deflater=None, size=512): + super().__init__() + self._out = out + self._deflater = deflater or Deflater() + self._buffer = bytearray(size) + + def write(self, b, off=None, length=None): + if isinstance(b, int): + self._out.write(bytes([b & 0xFF])) + else: + if off is not None and length is not None: + self._out.write(bytes(b[off:off+length])) + else: + self._deflater.setInput(bytes(b) if isinstance(b, (bytes, bytearray)) else bytes(b)) + while not self._deflater.needsInput(): + n = self._deflater.deflate(self._buffer) + if n > 0: + self._out.write(bytes(self._buffer[:n])) + + def finish(self): + self._deflater.finish() + while not self._deflater.finished(): + n = self._deflater.deflate(self._buffer) + if n > 0: + self._out.write(bytes(self._buffer[:n])) + + def close(self): + self.finish() + self._deflater.end() + self._out.close() + + def flush(self): + self._out.flush() + + +# ============================================================ +# InflaterInputStream +# ============================================================ + +class InflaterInputStream(Closeable): + def __init__(self, inp, inflater=None, size=512): + super().__init__() + self._in = inp + self._inflater = inflater or Inflater() + self._buffer = bytearray(size) + + def read(self, b=None, off=None, length=None): + if b is None: + buf = bytearray(1) + n = self._read_from_inflater(buf, 0, 1) + return buf[0] if n > 0 else -1 + if off is None: + off = 0 + if length is None: + length = len(b) + return self._read_from_inflater(b, off, length) + + def _read_from_inflater(self, b, off, length): + while not self._inflater.finished(): + if self._inflater.needsInput(): + data = self._in.read(self._buffer) + if data is None or data == -1 or data == 0: + break + if isinstance(data, int): + break + self._inflater.setInput(data) + try: + n = self._inflater.inflate(b, off, length) + if n > 0: + return n + except DataFormatException: + break + return -1 + + def available(self): + return 0 + + def close(self): + self._inflater.end() + self._in.close() + + def mark(self, readlimit): + pass + + def reset(self): + raise IOException("mark/reset not supported") + + def markSupported(self): + return False \ No newline at end of file diff --git a/android_pyapi/org/__init__.py b/android_pyapi/org/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/android_pyapi/org/__pycache__/__init__.cpython-310.pyc b/android_pyapi/org/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0e9bda88aaaa381f1a819799a0470a88cee04f9f GIT binary patch literal 154 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 E0avi1tpET3 literal 0 HcmV?d00001 diff --git a/android_pyapi/org/json.py b/android_pyapi/org/json.py new file mode 100644 index 0000000..140a80c --- /dev/null +++ b/android_pyapi/org/json.py @@ -0,0 +1,858 @@ +""" +Java JSON standard library APIs implemented in Python. +org.json package - JSONObject, JSONArray, JSONTokener, JSONStringer, JSONWriter, etc. +""" + +from .._core import Stub +import json as _json + +__all__ = [ + "JSONObject", "JSONArray", "JSONTokener", + "JSONStringer", "JSONWriter", "JSONException", "JSONPointer", + "JSONPointerBuilder", +] + + +# ============================================================ +# JSONException +# ============================================================ + +class JSONException(Exception): + def __init__(self, *args): + if len(args) == 1 and isinstance(args[0], Exception): + super().__init__(str(args[0])) + self._cause = args[0] + else: + super().__init__(*args) + self._cause = None + + def getCause(self): + return self._cause + + +# ============================================================ +# JSONObject.NULL +# ============================================================ + +class _JSONNull(Stub): + def __init__(self): + super().__init__() + + def equals(self, other): + return other is None or isinstance(other, _JSONNull) + + def hashCode(self): + return 0 + + def toString(self): + return "null" + + +# ============================================================ +# JSONObject +# ============================================================ + +class JSONObject(Stub): + NULL = _JSONNull() + + def __init__(self, *args): + super().__init__() + self._map = {} + if len(args) == 1: + arg = args[0] + if isinstance(arg, str): + tokener = JSONTokener(arg) + obj = tokener.nextValue() + if isinstance(obj, JSONObject): + self._map = obj._map + else: + raise JSONException("String is not a JSONObject") + elif isinstance(arg, dict): + for k, v in arg.items(): + self._map[str(k)] = JSONObject._wrap(v) + elif isinstance(arg, JSONObject): + names = None + self._map = dict(arg._map) + + def _wrap(val): + if val is None: + return JSONObject.NULL + if isinstance(val, (bool, int, float)): + return val + if isinstance(val, str): + return val + if isinstance(val, (list, tuple)): + arr = JSONArray() + for item in val: + arr.put(JSONObject._wrap(item)) + return arr + if isinstance(val, dict): + obj = JSONObject() + for k, v in val.items(): + obj.put(str(k), JSONObject._wrap(v)) + return obj + if isinstance(val, JSONObject) or isinstance(val, JSONArray): + return val + return val + + def put(self, key, value): + self._map[str(key)] = JSONObject._wrap(value) + return self + + def accumulate(self, key, value): + k = str(key) + current = self._map.get(k) + if current is None: + arr = JSONArray() + arr.put(value) + self._map[k] = arr + elif isinstance(current, JSONArray): + current.put(value) + else: + arr = JSONArray() + arr.put(current) + arr.put(value) + self._map[k] = arr + return self + + def get(self, key): + k = str(key) + if k not in self._map: + raise JSONException(f"JSONObject[\"{k}\"] not found") + val = self._map[k] + if val is JSONObject.NULL: + raise JSONException(f"JSONObject[\"{k}\"] is null") + return val + + def opt(self, key, default=None): + k = str(key) + val = self._map.get(k) + if val is None or val is JSONObject.NULL: + return default + return val + + def getString(self, key): + val = self.get(key) + if isinstance(val, str): + return val + raise JSONException(f"JSONObject[\"{key}\"] is not a string") + + def getInt(self, key): + val = self.get(key) + if isinstance(val, int): + return val + if isinstance(val, float): + return int(val) + raise JSONException(f"JSONObject[\"{key}\"] is not an int") + + def getLong(self, key): + val = self.get(key) + if isinstance(val, int): + return val + if isinstance(val, float): + return int(val) + raise JSONException(f"JSONObject[\"{key}\"] is not a long") + + def getDouble(self, key): + val = self.get(key) + if isinstance(val, (int, float)): + return float(val) + raise JSONException(f"JSONObject[\"{key}\"] is not a double") + + def getBoolean(self, key): + val = self.get(key) + if isinstance(val, bool): + return val + if val == "true": + return True + if val == "false": + return False + raise JSONException(f"JSONObject[\"{key}\"] is not a boolean") + + def getJSONArray(self, key): + val = self.get(key) + if isinstance(val, JSONArray): + return val + raise JSONException(f"JSONObject[\"{key}\"] is not a JSONArray") + + def getJSONObject(self, key): + val = self.get(key) + if isinstance(val, JSONObject): + return val + raise JSONException(f"JSONObject[\"{key}\"] is not a JSONObject") + + def optString(self, key, default=""): + val = self.opt(key) + if val is None or val is JSONObject.NULL: + return default + return str(val) + + def optInt(self, key, default=0): + val = self.opt(key) + if val is None or val is JSONObject.NULL: + return default + if isinstance(val, int): + return val + if isinstance(val, float): + return int(val) + try: + return int(val) + except (ValueError, TypeError): + return default + + def optLong(self, key, default=0): + return self.optInt(key, default) + + def optDouble(self, key, default=0.0): + val = self.opt(key) + if val is None or val is JSONObject.NULL: + return default + if isinstance(val, (int, float)): + return float(val) + try: + return float(val) + except (ValueError, TypeError): + return default + + def optBoolean(self, key, default=False): + val = self.opt(key) + if val is None or val is JSONObject.NULL: + return default + if isinstance(val, bool): + return val + if isinstance(val, str): + return val.lower() == "true" + return default + + def optJSONArray(self, key): + val = self.opt(key) + if isinstance(val, JSONArray): + return val + return None + + def optJSONObject(self, key): + val = self.opt(key) + if isinstance(val, JSONObject): + return val + return None + + def has(self, key): + return str(key) in self._map + + def remove(self, key): + k = str(key) + if k in self._map: + del self._map[k] + + def keys(self): + return iter(self._map.keys()) + + def names(self): + if not self._map: + return None + arr = JSONArray() + for k in self._map: + arr.put(k) + return arr + + def length(self): + return len(self._map) + + def toString(self, indent_factor=None): + if indent_factor is None: + return self._to_json_string() + return self._to_json_pretty(indent_factor) + + def _to_json_string(self): + parts = ["{"] + for i, (k, v) in enumerate(self._map.items()): + parts.append('"' + k + '": ' + JSONObject._value_to_string(v)) + if i < len(self._map) - 1: + parts.append(", ") + parts.append("}") + return "".join(parts) + + def _to_json_pretty(self, indent): + parts = ["{"] + for i, (k, v) in enumerate(self._map.items()): + parts.append("\n" + " " * indent + '"' + k + '": ' + JSONObject._value_to_string(v)) + if i < len(self._map) - 1: + parts.append(",") + parts.append("\n}") + return "".join(parts) + + def _value_to_string(val): + if val is None or val is JSONObject.NULL: + return "null" + if isinstance(val, bool): + return "true" if val else "false" + if isinstance(val, (int, float)): + return str(val) + if isinstance(val, str): + return _json.dumps(val) + if isinstance(val, JSONObject): + return val._to_json_string() + if isinstance(val, JSONArray): + return val._to_json_string() + return str(val) + + def toMap(self): + result = {} + for k, v in self._map.items(): + if isinstance(v, JSONObject): + result[k] = v.toMap() + elif isinstance(v, JSONArray): + result[k] = v.toList() + elif v is JSONObject.NULL: + result[k] = None + else: + result[k] = v + return result + + def write(self, writer): + writer._write(self._to_json_string()) + + def toJSONArray(self, names): + if names is None or names.length() == 0: + return None + arr = JSONArray() + for i in range(names.length()): + arr.put(self.opt(names.getString(i))) + return arr + + def hashCode(self): + return hash(frozenset(self._map.items())) + + def equals(self, other): + if isinstance(other, JSONObject): + return self._map == other._map + return False + + +# ============================================================ +# JSONArray +# ============================================================ + +class JSONArray(Stub): + def __init__(self, *args): + super().__init__() + self._list = [] + if len(args) == 1: + arg = args[0] + if isinstance(arg, str): + tokener = JSONTokener(arg) + val = tokener.nextValue() + if isinstance(val, JSONArray): + self._list = val._list + else: + raise JSONException("String is not a JSONArray") + elif isinstance(arg, (list, tuple)): + for item in arg: + self.put(JSONObject._wrap(item)) + + def put(self, *args): + if len(args) == 1: + self._list.append(JSONObject._wrap(args[0])) + elif len(args) == 2: + index, value = args + while len(self._list) <= index: + self._list.append(None) + self._list[index] = JSONObject._wrap(value) + return self + + def get(self, index): + if index < 0 or index >= len(self._list): + raise JSONException(f"JSONArray[{index}] not found") + val = self._list[index] + if val is JSONObject.NULL: + raise JSONException(f"JSONArray[{index}] is null") + return val + + def getString(self, index): + val = self.get(index) + if isinstance(val, str): + return val + raise JSONException(f"JSONArray[{index}] is not a string") + + def getInt(self, index): + val = self.get(index) + if isinstance(val, int): + return val + if isinstance(val, float): + return int(val) + raise JSONException(f"JSONArray[{index}] is not an int") + + def getLong(self, index): + val = self.get(index) + if isinstance(val, int): + return val + if isinstance(val, float): + return int(val) + raise JSONException(f"JSONArray[{index}] is not a long") + + def getDouble(self, index): + val = self.get(index) + if isinstance(val, (int, float)): + return float(val) + raise JSONException(f"JSONArray[{index}] is not a double") + + def getBoolean(self, index): + val = self.get(index) + if isinstance(val, bool): + return val + if val == "true": + return True + if val == "false": + return False + raise JSONException(f"JSONArray[{index}] is not a boolean") + + def getJSONArray(self, index): + val = self.get(index) + if isinstance(val, JSONArray): + return val + raise JSONException(f"JSONArray[{index}] is not a JSONArray") + + def getJSONObject(self, index): + val = self.get(index) + if isinstance(val, JSONObject): + return val + raise JSONException(f"JSONArray[{index}] is not a JSONObject") + + def opt(self, index, default=None): + if index < 0 or index >= len(self._list): + return default + val = self._list[index] + if val is JSONObject.NULL: + return default + return val + + def optString(self, index, default=""): + val = self.opt(index) + if val is None: + return default + return str(val) + + def optInt(self, index, default=0): + val = self.opt(index) + if val is None: + return default + if isinstance(val, int): + return val + if isinstance(val, float): + return int(val) + try: + return int(val) + except (ValueError, TypeError): + return default + + def optLong(self, index, default=0): + return self.optInt(index, default) + + def optDouble(self, index, default=0.0): + val = self.opt(index) + if val is None: + return default + if isinstance(val, (int, float)): + return float(val) + try: + return float(val) + except (ValueError, TypeError): + return default + + def optBoolean(self, index, default=False): + val = self.opt(index) + if val is None: + return default + if isinstance(val, bool): + return val + if isinstance(val, str): + return val.lower() == "true" + return default + + def optJSONArray(self, index): + val = self.opt(index) + if isinstance(val, JSONArray): + return val + return None + + def optJSONObject(self, index): + val = self.opt(index) + if isinstance(val, JSONObject): + return val + return None + + def remove(self, index): + if 0 <= index < len(self._list): + return self._list.pop(index) + return None + + def length(self): + return len(self._list) + + def isNull(self, index): + if 0 <= index < len(self._list): + return self._list[index] is JSONObject.NULL or self._list[index] is None + return True + + def toString(self, indent_factor=None): + if indent_factor is None: + return self._to_json_string() + return self._to_json_pretty(indent_factor) + + def _to_json_string(self): + parts = ["["] + for i, v in enumerate(self._list): + parts.append(JSONObject._value_to_string(v)) + if i < len(self._list) - 1: + parts.append(", ") + parts.append("]") + return "".join(parts) + + def _to_json_pretty(self, indent): + parts = ["["] + for i, v in enumerate(self._list): + parts.append("\n" + " " * indent + JSONObject._value_to_string(v)) + if i < len(self._list) - 1: + parts.append(",") + parts.append("\n]") + return "".join(parts) + + def toList(self): + result = [] + for v in self._list: + if isinstance(v, JSONObject): + result.append(v.toMap()) + elif isinstance(v, JSONArray): + result.append(v.toList()) + elif v is JSONObject.NULL: + result.append(None) + else: + result.append(v) + return result + + def join(self, separator): + parts = [] + for v in self._list: + parts.append(JSONObject._value_to_string(v)) + return separator.join(parts) + + +# ============================================================ +# JSONTokener +# ============================================================ + +class JSONTokener(Stub): + def __init__(self, source): + super().__init__() + if hasattr(source, "read"): + self._source = source.read() + else: + self._source = str(source) + self._index = 0 + + def nextValue(self): + self._skipWhitespace() + if self._index >= len(self._source): + raise JSONException("Unexpected end of input") + ch = self._source[self._index] + if ch == "{": + return self._readObject() + if ch == "[": + return self._readArray() + if ch == '"': + return self._readString() + if ch == "'": + return self._readString("'") + if ch == "t" or ch == "f": + return self._readLiteral() + if ch == "n": + return self._readNull() + return self._readNumber() + + def _skipWhitespace(self): + while self._index < len(self._source) and self._source[self._index] in " \t\n\r": + self._index += 1 + + def _readObject(self): + self._index += 1 # skip { + obj = JSONObject() + self._skipWhitespace() + if self._index < len(self._source) and self._source[self._index] == "}": + self._index += 1 + return obj + while True: + self._skipWhitespace() + key = self.nextValue() + self._skipWhitespace() + if self._index < len(self._source) and self._source[self._index] == ":": + self._index += 1 + self._skipWhitespace() + val = self.nextValue() + obj.put(str(key), val) + self._skipWhitespace() + if self._index < len(self._source) and self._source[self._index] == ",": + self._index += 1 + elif self._index < len(self._source) and self._source[self._index] == "}": + self._index += 1 + return obj + else: + raise JSONException("Expected ',' or '}' in object") + + def _readArray(self): + self._index += 1 # skip [ + arr = JSONArray() + self._skipWhitespace() + if self._index < len(self._source) and self._source[self._index] == "]": + self._index += 1 + return arr + while True: + self._skipWhitespace() + val = self.nextValue() + arr.put(val) + self._skipWhitespace() + if self._index < len(self._source) and self._source[self._index] == ",": + self._index += 1 + elif self._index < len(self._source) and self._source[self._index] == "]": + self._index += 1 + return arr + else: + raise JSONException("Expected ',' or ']' in array") + + def _readString(self, quote='"'): + self._index += 1 # skip quote + result = [] + while self._index < len(self._source): + ch = self._source[self._index] + if ch == "\\": + self._index += 1 + if self._index >= len(self._source): + raise JSONException("Unterminated string escape") + esc = self._source[self._index] + if esc == '"': + result.append('"') + elif esc == "\\": + result.append("\\") + elif esc == "/": + result.append("/") + elif esc == "b": + result.append("\b") + elif esc == "f": + result.append("\f") + elif esc == "n": + result.append("\n") + elif esc == "r": + result.append("\r") + elif esc == "t": + result.append("\t") + elif esc == "u": + hex_str = self._source[self._index+1:self._index+5] + result.append(chr(int(hex_str, 16))) + self._index += 4 + else: + result.append(esc) + self._index += 1 + elif ch == quote: + self._index += 1 + return "".join(result) + else: + result.append(ch) + self._index += 1 + raise JSONException("Unterminated string") + + def _readLiteral(self): + for lit in ("true", "false"): + if self._source[self._index:self._index+len(lit)] == lit: + self._index += len(lit) + return lit == "true" + raise JSONException(f"Unexpected literal at {self._index}") + + def _readNull(self): + if self._source[self._index:self._index+4] == "null": + self._index += 4 + return JSONObject.NULL + raise JSONException(f"Unexpected token at {self._index}") + + def _readNumber(self): + start = self._index + while self._index < len(self._source) and self._source[self._index] in "-+0123456789.eE": + self._index += 1 + num_str = self._source[start:self._index] + if "." in num_str or "e" in num_str or "E" in num_str: + return float(num_str) + return int(num_str) + + def nextString(self, quote='"'): + return self._readString(quote) + + def nextChar(self, c): + self._skipWhitespace() + if self._index < len(self._source) and self._source[self._index] == c: + self._index += 1 + return c + raise JSONException(f"Expected '{c}'") + + def nextTo(self, delimiter): + start = self._index + while self._index < len(self._source) and self._source[self._index] not in delimiter: + self._index += 1 + return self._source[start:self._index] + + def skipPast(self, text): + idx = self._source.find(text, self._index) + if idx >= 0: + self._index = idx + len(text) + + def skipTo(self, c): + idx = self._source.find(c, self._index) + if idx >= 0: + self._index = idx + return idx + return -1 + + def back(self): + self._index -= 1 + + def more(self): + self._skipWhitespace() + return self._index < len(self._source) + + def readString(self): + return self._readString() + + +# ============================================================ +# JSONWriter +# ============================================================ + +class JSONWriter(Stub): + def __init__(self, writer): + super().__init__() + self._writer = writer + self._stack = [] + self._in_object = False + self._need_comma = False + + def _write(self, s): + self._writer.write(s) + + def array(self): + self._beforeValue() + self._stack.append(("array", False)) + self._write("[") + return self + + def endArray(self): + self._write("]") + self._stack.pop() + return self + + def object(self): + self._beforeValue() + self._stack.append(("object", False)) + self._write("{") + return self + + def endObject(self): + self._write("}") + self._stack.pop() + return self + + def key(self, s): + if not self._stack or self._stack[-1][0] != "object": + raise JSONException("Can't set key outside object") + self._beforeKey() + self._write('"' + s + '":') + return self + + def value(self, v): + self._beforeValue() + self._write(JSONObject._value_to_string(v)) + return self + + def _beforeValue(self): + if self._stack and self._stack[-1][0] == "object": + raise JSONException("Expected key in object") + + def _beforeKey(self): + if self._stack and self._stack[-1][1]: + self._write(",") + self._stack[-1] = (self._stack[-1][0], True) + + +# ============================================================ +# JSONStringer +# ============================================================ + +class JSONStringer(JSONWriter): + def __init__(self): + from io import StringIO + super().__init__(StringIO()) + + def toString(self): + return self._writer.getvalue() + + +# ============================================================ +# JSONPointer +# ============================================================ + +class JSONPointer(Stub): + def __init__(self, pointer): + super().__init__() + if not pointer or pointer == "": + self._tokens = [] + elif pointer.startswith("#"): + pointer = pointer[1:] + pointer = pointer.replace("~1", "/").replace("~0", "~") + import urllib.parse + pointer = urllib.parse.unquote(pointer) + self._tokens = pointer.split("/")[1:] if len(pointer) > 1 else [] + else: + self._tokens = pointer.split("/")[1:] if len(pointer) > 0 else [] + + def query(self, root): + current = root + for token in self._tokens: + token = token.replace("~1", "/").replace("~0", "~") + if isinstance(current, JSONObject): + current = current.get(token) + elif isinstance(current, JSONArray): + try: + idx = int(token) + current = current.get(idx) + except (ValueError, IndexError): + raise JSONException(f"Invalid index: {token}") + else: + raise JSONException(f"Cannot index into {type(current)}") + return current + + def queryFrom(self, root): + return self.query(root) + + def toString(self): + return "#/" + "/".join(t.replace("~", "~0").replace("/", "~1") for t in self._tokens) + + def hashCode(self): + return hash(tuple(self._tokens)) + + def equals(self, other): + if isinstance(other, JSONPointer): + return self._tokens == other._tokens + return False + + +# ============================================================ +# JSONPointerBuilder +# ============================================================ + +class JSONPointerBuilder(Stub): + def __init__(self): + super().__init__() + self._tokens = [] + + def append(self, token): + self._tokens.append(str(token)) + return self + + def build(self): + return JSONPointer("#/" + "/".join(t.replace("~", "~0").replace("/", "~1") for t in self._tokens)) \ No newline at end of file