shuiyuPyLab/Android-pyApi
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
690022cea350ca9026c9f4784802217b70d4f522
Android-pyApi/android_pyapi/android/view_window.py
T
shuiyu1123 a51854455b feat: 大规模扩充至212个模块/175K行代码 — 覆盖android/java/javax/org/dalvik全包 
- android/ 167个模块 (app/content/os/view/widget/graphics/media/hardware/net/telephony/provider等)
- java/ 35个模块 (lang/io/util/net/nio/security/crypto/sql/beans/rmi/awt等)
- javax/ 4个模块 (net/crypto/security/sql)
- org/ 5个模块 (json/w3c_dom/xml_sax/xml_pull/apache_http)
- dalvik/ 1个模块 (system)
- ~3053个类/接口，方法签名完全对齐Android SDK
- 桌面跨平台运行 (Windows/macOS/Linux)
- 修复所有导入错误和Python关键字冲突
2026-06-24 14:15:56 +00:00

969 lines
31 KiB
Python
Raw Blame History

"""
Android Window 组件 — Window, WindowManager, WindowManager.LayoutParams,
PhoneWindow, Window.Callback, WindowMetrics, SplashScreen,
WindowContext, WindowManagerGlobal 等
方法签名完全对齐 Android SDK
"""
from __future__ import annotations
from typing import Any, Callable, Dict, List, Optional, Tuple
from .._core import Stub, AndroidOnlyError
from ..java.lang import RuntimeException
IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {})
__all__ = [
"Window", "WindowManager", "PhoneWindow", "WindowMetrics",
"WindowMetricsCalculator", "SplashScreen", "SplashScreenView",
"SplashScreenManager", "WindowContext", "WindowContextController",
"WindowHideScrollCaptureTarget", "WindowLayoutBuilder",
"WindowLayoutObserver", "WindowManagerGlobal", "WindowManagerPolicy",
"WindowProviderService",
]
# ═══════════════════════════════════════════════════════════════
# 窗口常量
# ═══════════════════════════════════════════════════════════════
TYPE_BASE_APPLICATION = 1
TYPE_APPLICATION = 2
TYPE_APPLICATION_STARTING = 3
TYPE_APPLICATION_PANEL = 1000
TYPE_APPLICATION_MEDIA = 1001
TYPE_APPLICATION_SUB_PANEL = 1002
TYPE_APPLICATION_ABOVE_SUB_PANEL = 1003
TYPE_APPLICATION_ATTACHED_DIALOG = 1004
TYPE_STATUS_BAR = 2000
TYPE_SEARCH_BAR = 2001
TYPE_PHONE = 2002
TYPE_SYSTEM_ALERT = 2003
TYPE_KEYGUARD = 2004
TYPE_TOAST = 2005
TYPE_SYSTEM_OVERLAY = 2006
TYPE_PRIORITY_PHONE = 2007
TYPE_SYSTEM_DIALOG = 2008
TYPE_KEYGUARD_DIALOG = 2009
TYPE_SYSTEM_ERROR = 2010
TYPE_INPUT_METHOD = 2011
TYPE_INPUT_METHOD_DIALOG = 2012
TYPE_WALLPAPER = 2013
TYPE_STATUS_BAR_PANEL = 2014
TYPE_SECURE_SYSTEM_OVERLAY = 2015
TYPE_DRAG = 2016
TYPE_STATUS_BAR_SUBSCEEN = 2017
TYPE_POINTER = 2018
TYPE_NAVIGATION_BAR = 2019
TYPE_VOLUME_OVERLAY = 2020
TYPE_BOOT_PROGRESS = 2021
TYPE_NAVIGATION_BAR_PANEL = 2024
TYPE_APPLICATION_OVERLAY = 2025
TYPE_UNIVERSE_BACKGROUND = 2026
TYPE_DISPLAY_OVERLAY = 2027
TYPE_MAGNIFICATION_OVERLAY = 2028
TYPE_INPUT_CONSUMER = 2029
TYPE_ACCESSIBILITY_OVERLAY = 2030
TYPE_ACCESSIBILITY_MAGNIFICATION_OVERLAY = 2031
TYPE_NOTIFICATION_SHADE = 2032
TYPE_STATUS_BAR_ADDITIONAL_INFO = 2033
TYPE_KEYGUARD_SCRIM = 2034
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 = 0x01000000
FLAG_HARDWARE_ACCELERATED = 0x10000000
FLAG_LOCAL_FOCUS_MODE = 0x10000000
FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS = 0x80000000
FLAG_TRANSLUCENT_STATUS = 0x04000000
FLAG_TRANSLUCENT_NAVIGATION = 0x08000000
FLAG_BLUR_BEHIND = 0x00000004
FLAG_DIM_BEHIND = 0x00000002
FEATURE_NO_TITLE = 1
FEATURE_INDETERMINATE_PROGRESS = 5
FEATURE_PROGRESS = 2
FEATURE_CUSTOM_TITLE = 7
FEATURE_LEFT_ICON = 3
FEATURE_RIGHT_ICON = 4
FEATURE_ACTION_BAR = 8
FEATURE_ACTION_BAR_OVERLAY = 9
FEATURE_ACTION_MODE_OVERLAY = 10
FEATURE_CONTENT_TRANSITIONS = 12
FEATURE_ACTIVITY_TRANSITIONS = 13
SOFT_INPUT_ADJUST_NOTHING = 0x00000030
SOFT_INPUT_ADJUST_PAN = 0x00000020
SOFT_INPUT_ADJUST_RESIZE = 0x00000010
SOFT_INPUT_ADJUST_UNSPECIFIED = 0x00000000
SOFT_INPUT_STATE_ALWAYS_HIDDEN = 0x00000003
SOFT_INPUT_STATE_ALWAYS_VISIBLE = 0x00000005
SOFT_INPUT_STATE_HIDDEN = 0x00000002
SOFT_INPUT_STATE_UNCHANGED = 0x00000001
SOFT_INPUT_STATE_VISIBLE = 0x00000004
SOFT_INPUT_MASK_ADJUST = 0x000000F0
SOFT_INPUT_MASK_STATE = 0x0000000F
SOFT_INPUT_IS_FORWARD_NAVIGATION = 0x10000000
ROTATION_0 = 0
ROTATION_90 = 1
ROTATION_180 = 2
ROTATION_270 = 3
LAYOUT_IN_DISPLAY_CUTOUT_MODE_DEFAULT = 0
LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES = 1
LAYOUT_IN_DISPLAY_CUTOUT_MODE_NEVER = 2
LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS = 3
# ═══════════════════════════════════════════════════════════════
# WindowManager.LayoutParams
# ═══════════════════════════════════════════════════════════════
class WindowManager:
"""WindowManager — 窗口管理器接口"""
class LayoutParams(Stub):
"""WindowManager.LayoutParams — 窗口布局参数"""
TYPE_BASE_APPLICATION = TYPE_BASE_APPLICATION
TYPE_APPLICATION = TYPE_APPLICATION
TYPE_APPLICATION_PANEL = TYPE_APPLICATION_PANEL
TYPE_APPLICATION_MEDIA = TYPE_APPLICATION_MEDIA
TYPE_APPLICATION_SUB_PANEL = TYPE_APPLICATION_SUB_PANEL
TYPE_STATUS_BAR = TYPE_STATUS_BAR
TYPE_SYSTEM_ALERT = TYPE_SYSTEM_ALERT
TYPE_KEYGUARD = TYPE_KEYGUARD
TYPE_TOAST = TYPE_TOAST
TYPE_SYSTEM_OVERLAY = TYPE_SYSTEM_OVERLAY
TYPE_INPUT_METHOD = TYPE_INPUT_METHOD
TYPE_WALLPAPER = TYPE_WALLPAPER
TYPE_APPLICATION_OVERLAY = TYPE_APPLICATION_OVERLAY
TYPE_ACCESSIBILITY_OVERLAY = TYPE_ACCESSIBILITY_OVERLAY
FLAG_NOT_FOCUSABLE = FLAG_NOT_FOCUSABLE
FLAG_NOT_TOUCHABLE = FLAG_NOT_TOUCHABLE
FLAG_KEEP_SCREEN_ON = FLAG_KEEP_SCREEN_ON
FLAG_FULLSCREEN = FLAG_FULLSCREEN
FLAG_SECURE = FLAG_SECURE
FLAG_SHOW_WHEN_LOCKED = FLAG_SHOW_WHEN_LOCKED
FLAG_TURN_SCREEN_ON = FLAG_TURN_SCREEN_ON
FLAG_DISMISS_KEYGUARD = FLAG_DISMISS_KEYGUARD
FLAG_TRANSLUCENT_STATUS = FLAG_TRANSLUCENT_STATUS
FLAG_TRANSLUCENT_NAVIGATION = FLAG_TRANSLUCENT_NAVIGATION
FLAG_HARDWARE_ACCELERATED = FLAG_HARDWARE_ACCELERATED
FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS = FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS
SOFT_INPUT_ADJUST_NOTHING = SOFT_INPUT_ADJUST_NOTHING
SOFT_INPUT_ADJUST_PAN = SOFT_INPUT_ADJUST_PAN
SOFT_INPUT_ADJUST_RESIZE = SOFT_INPUT_ADJUST_RESIZE
SOFT_INPUT_MASK_ADJUST = SOFT_INPUT_MASK_ADJUST
SOFT_INPUT_MASK_STATE = SOFT_INPUT_MASK_STATE
def __init__(self, w: int = -1, h: int = -1,
type_: int = TYPE_APPLICATION,
flags: int = 0, format: int = -1):
super().__init__()
self.width = w
self.height = h
self.type = type_
self.flags = flags
self.format = format
self.x = 0
self.y = 0
self.horizontalMargin = 0.0
self.verticalMargin = 0.0
self.alpha = 1.0
self.dimAmount = 0.0
self.screenOrientation = ROTATION_0
self.softInputMode = SOFT_INPUT_ADJUST_NOTHING
self.gravity = 0
self.windowAnimations = 0
self.token: Any = None
self.packageName: str = ""
self.title: str = ""
self.windowManager: Any = None
self.buttonBrightness = -1.0
self.screenBrightness = -1.0
self.rotationAnimation = 0
self.layoutInDisplayCutoutMode = LAYOUT_IN_DISPLAY_CUTOUT_MODE_DEFAULT
self.preferredDisplayModeId = 0
self.colorMode = 0
self.fitInsetsTypes = 0
self.fitInsetsSides = 0
self.wideColorGamut = False
self.captionMode = 0
def setTitle(self, title: str):
self.title = title
def getTitle(self) -> str:
return self.title
def setGravity(self, gravity: int):
self.gravity = gravity
def getGravity(self) -> int:
return self.gravity
def setSoftInputMode(self, mode: int):
self.softInputMode = mode
def getSoftInputMode(self) -> int:
return self.softInputMode
def setFlags(self, flags: int, mask: int):
self.flags = (self.flags & ~mask) | (flags & mask)
def getFlags(self) -> int:
return self.flags
def toString(self) -> str:
return (f"LayoutParams({self.width}x{self.height}, "
f"type={self.type}, flags=0x{self.flags:08x})")
def equals(self, other: Any) -> bool:
return self is other
def hashCode(self) -> int:
return id(self) & 0x7FFFFFFF
def __init__(self):
super().__init__()
def addView(self, view: Any, params: LayoutParams):
raise AndroidOnlyError("WindowManager.addView() is not available on desktop")
def updateViewLayout(self, view: Any, params: LayoutParams):
raise AndroidOnlyError("WindowManager.updateViewLayout() is not available on desktop")
def removeView(self, view: Any):
raise AndroidOnlyError("WindowManager.removeView() is not available on desktop")
def removeViewImmediate(self, view: Any):
raise AndroidOnlyError("WindowManager.removeViewImmediate() is not available on desktop")
def getDefaultDisplay(self) -> Any:
return None
def getCurrentWindowMetrics(self) -> "WindowMetrics":
return WindowMetrics(width=1920, height=1080)
def getMaximumWindowMetrics(self) -> "WindowMetrics":
return WindowMetrics(width=1920, height=1080)
def toString(self) -> str:
return "WindowManager"
def equals(self, other: Any) -> bool:
return self is other
def hashCode(self) -> int:
return id(self) & 0x7FFFFFFF
# ═══════════════════════════════════════════════════════════════
# Window.Callback
# ═══════════════════════════════════════════════════════════════
class Window:
"""Window — 窗口基类"""
class Callback(Stub):
"""Window.Callback — 窗口回调"""
def onWindowAttributesChanged(self, attrs: Any):
pass
def onWindowFocusChanged(self, hasFocus: bool):
pass
def dispatchKeyEvent(self, event: Any) -> bool:
return False
def dispatchTouchEvent(self, event: Any) -> bool:
return False
def dispatchTrackballEvent(self, event: Any) -> bool:
return False
def dispatchGenericMotionEvent(self, event: Any) -> bool:
return False
def onContentChanged(self):
pass
def toString(self) -> str:
return f"Window.Callback@{hex(id(self))}"
def equals(self, other: Any) -> bool:
return self is other
def hashCode(self) -> int:
return id(self) & 0x7FFFFFFF
class OnFrameMetricsAvailableListener(Stub):
"""Window.OnFrameMetricsAvailableListener — 帧指标监听器"""
def onFrameMetricsAvailable(self, window: "Window", frameMetrics: Any,
dropCountSinceLastInvocation: int):
pass
def toString(self) -> str:
return f"OnFrameMetricsAvailableListener@{hex(id(self))}"
def equals(self, other: Any) -> bool:
return self is other
def hashCode(self) -> int:
return id(self) & 0x7FFFFFFF
class OnRestrictedCaptionAreaChangedListener(Stub):
"""Window.OnRestrictedCaptionAreaChangedListener — 受限标题区域变化监听器"""
def onRestrictedCaptionAreaChanged(self, rect: Any):
pass
def toString(self) -> str:
return f"OnRestrictedCaptionAreaChangedListener@{hex(id(self))}"
def equals(self, other: Any) -> bool:
return self is other
def hashCode(self) -> int:
return id(self) & 0x7FFFFFFF
def __init__(self, context: Any = None):
super().__init__()
self._context = context
self._callback: Optional[Window.Callback] = None
self._window_manager = WindowManager()
self._features: Dict[int, bool] = {}
self._local_features: Dict[int, bool] = {}
self._decor: Any = None
self._container: Any = None
self._attributes = WindowManager.LayoutParams()
self._is_active = False
def getContext(self) -> Any:
return self._context
def getCallback(self) -> Optional[Callback]:
return self._callback
def setCallback(self, callback: Callback):
self._callback = callback
def getWindowManager(self) -> WindowManager:
return self._window_manager
def setWindowManager(self, wm: WindowManager, pm: Any, appName: str = ""):
self._window_manager = wm
def getAttributes(self) -> WindowManager.LayoutParams:
return self._attributes
def setAttributes(self, attrs: WindowManager.LayoutParams):
self._attributes = attrs
def addFlags(self, flags: int):
self._attributes.flags |= flags
def clearFlags(self, flags: int):
self._attributes.flags &= ~flags
def setFlags(self, flags: int, mask: int):
self._attributes.setFlags(flags, mask)
def setGravity(self, gravity: int):
self._attributes.setGravity(gravity)
def setSoftInputMode(self, mode: int):
self._attributes.setSoftInputMode(mode)
def setTitle(self, title: str):
self._attributes.setTitle(title)
def setType(self, type_: int):
self._attributes.type = type_
def setFormat(self, format: int):
self._attributes.format = format
def setWindowAnimations(self, resId: int):
self._attributes.windowAnimations = resId
def requestFeature(self, featureId: int) -> bool:
self._features[featureId] = True
return True
def hasFeature(self, featureId: int) -> bool:
return self._features.get(featureId, False)
def isActive(self) -> bool:
return self._is_active
def setContainer(self, container: Any):
self._container = container
def getContainer(self) -> Any:
return self._container
def makeActive(self):
self._is_active = True
def makeInactive(self):
self._is_active = False
def getDecorView(self) -> Any:
return self._decor
def setDecorView(self, view: Any):
self._decor = view
def injectInputEvent(self, event: Any):
pass
def superDispatchKeyEvent(self, event: Any) -> bool:
return False
def superDispatchTouchEvent(self, event: Any) -> bool:
return False
def superDispatchTrackballEvent(self, event: Any) -> bool:
return False
def superDispatchGenericMotionEvent(self, event: Any) -> bool:
return False
def toString(self) -> str:
return f"Window(active={self._is_active})"
def equals(self, other: Any) -> bool:
return self is other
def hashCode(self) -> int:
return id(self) & 0x7FFFFFFF
# ═══════════════════════════════════════════════════════════════
# PhoneWindow
# ═══════════════════════════════════════════════════════════════
class PhoneWindow(Window):
"""PhoneWindow — 电话窗口"""
def __init__(self, context: Any = None):
super().__init__(context=context)
self._is_phone = True
self._status_bar_color = 0
self._navigation_bar_color = 0
self._is_status_bar_visible = True
self._is_navigation_bar_visible = True
def setStatusBarColor(self, color: int):
self._status_bar_color = color
def getStatusBarColor(self) -> int:
return self._status_bar_color
def setNavigationBarColor(self, color: int):
self._navigation_bar_color = color
def getNavigationBarColor(self) -> int:
return self._navigation_bar_color
def setStatusBarVisibility(self, visible: bool):
self._is_status_bar_visible = visible
def setNavigationBarVisibility(self, visible: bool):
self._is_navigation_bar_visible = visible
def isStatusBarVisible(self) -> bool:
return self._is_status_bar_visible
def isNavigationBarVisible(self) -> bool:
return self._is_navigation_bar_visible
def toString(self) -> str:
return f"PhoneWindow(statusBar={self._is_status_bar_visible})"
# ═══════════════════════════════════════════════════════════════
# WindowContentFrameStats / WindowFrameStats
# ═══════════════════════════════════════════════════════════════
class WindowContentFrameStats(Stub):
"""WindowContentFrameStats — 窗口内容帧统计"""
def __init__(self):
super().__init__()
self._frames_count = 0
self._dropped_count = 0
self._total_duration_ns = 0
def getFramesCount(self) -> int:
return self._frames_count
def getDroppedCount(self) -> int:
return self._dropped_count
def getTotalDurationNanos(self) -> int:
return self._total_duration_ns
def toString(self) -> str:
return f"WindowContentFrameStats(frames={self._frames_count}, dropped={self._dropped_count})"
class WindowFrameStats(Stub):
"""WindowFrameStats — 窗口帧统计"""
def __init__(self):
super().__init__()
self._frames_count = 0
self._jank_count = 0
self._percentile_95 = 0.0
self._percentile_99 = 0.0
def getFramesCount(self) -> int:
return self._frames_count
def getJankCount(self) -> int:
return self._jank_count
def getP95DurationMillis(self) -> float:
return self._percentile_95
def getP99DurationMillis(self) -> float:
return self._percentile_99
def toString(self) -> str:
return f"WindowFrameStats(frames={self._frames_count}, jank={self._jank_count})"
# ═══════════════════════════════════════════════════════════════
# WindowMetrics
# ═══════════════════════════════════════════════════════════════
class WindowMetrics(Stub):
"""WindowMetrics — 窗口指标"""
def __init__(self, width: int = 0, height: int = 0,
densityDpi: int = 320, density: float = 2.0,
scaledDensity: float = 2.0, xdpi: float = 320.0,
ydpi: float = 320.0):
super().__init__()
self._width = width
self._height = height
self._density_dpi = densityDpi
self._density = density
self._scaled_density = scaledDensity
self._xdpi = xdpi
self._ydpi = ydpi
def getWidth(self) -> int:
return self._width
def getHeight(self) -> int:
return self._height
def getDensityDpi(self) -> int:
return self._density_dpi
def getDensity(self) -> float:
return self._density
def getScaledDensity(self) -> float:
return self._scaled_density
def getXdpi(self) -> float:
return self._xdpi
def getYdpi(self) -> float:
return self._ydpi
def getBounds(self) -> Any:
return (0, 0, self._width, self._height)
def toString(self) -> str:
return f"WindowMetrics({self._width}x{self._height})"
def equals(self, other: Any) -> bool:
if not isinstance(other, WindowMetrics):
return False
return self._width == other._width and self._height == other._height
def hashCode(self) -> int:
return hash((self._width, self._height)) & 0x7FFFFFFF
class WindowMetricsCalculator(Stub):
"""WindowMetricsCalculator — 窗口指标计算器"""
@staticmethod
def getOrCreate() -> "WindowMetricsCalculator":
return WindowMetricsCalculator()
def computeCurrentWindowMetrics(self, context: Any) -> WindowMetrics:
return WindowMetrics(width=1920, height=1080)
def computeMaximumWindowMetrics(self, context: Any) -> WindowMetrics:
return WindowMetrics(width=1920, height=1080)
def toString(self) -> str:
return "WindowMetricsCalculator"
class WindowMetricsCalculatorDecorator(Stub):
"""WindowMetricsCalculatorDecorator — 窗口指标装饰器"""
def __init__(self, base: Optional[WindowMetricsCalculator] = None):
super().__init__()
self._base = base
def computeCurrentWindowMetrics(self, context: Any) -> WindowMetrics:
if self._base:
return self._base.computeCurrentWindowMetrics(context)
return WindowMetrics(width=1920, height=1080)
def computeMaximumWindowMetrics(self, context: Any) -> WindowMetrics:
if self._base:
return self._base.computeMaximumWindowMetrics(context)
return WindowMetrics(width=1920, height=1080)
# ═══════════════════════════════════════════════════════════════
# SplashScreen / SplashScreenView / SplashScreenManager
# ═══════════════════════════════════════════════════════════════
class SplashScreen(Stub):
"""SplashScreen — 启动屏"""
SPLASH_SCREEN_STYLE_SOLID_COLOR = 0
SPLASH_SCREEN_STYLE_ICON = 1
SPLASH_SCREEN_STYLE_ANIMATED_ICON = 2
def __init__(self):
super().__init__()
self._icon: Any = None
self._background_color: int = 0
self._animation_duration: int = 0
self._style = SplashScreen.SPLASH_SCREEN_STYLE_SOLID_COLOR
def setSplashScreenIcon(self, icon: Any):
self._icon = icon
def getSplashScreenIcon(self) -> Any:
return self._icon
def setBackgroundColor(self, color: int):
self._background_color = color
def getBackgroundColor(self) -> int:
return self._background_color
def setAnimationDuration(self, duration: int):
self._animation_duration = duration
def getAnimationDuration(self) -> int:
return self._animation_duration
def setStyle(self, style: int):
self._style = style
def getStyle(self) -> int:
return self._style
def toString(self) -> str:
return f"SplashScreen(style={self._style})"
class SplashScreenView(Stub):
"""SplashScreenView — 启动屏视图"""
def __init__(self):
super().__init__()
self._visible = False
self._icon: Any = None
self._branding_image: Any = None
def isVisible(self) -> bool:
return self._visible
def setVisible(self, visible: bool):
self._visible = visible
def getIconView(self) -> Any:
return self._icon
def getBrandingImageView(self) -> Any:
return self._branding_image
def remove(self):
self._visible = False
def toString(self) -> str:
return f"SplashScreenView(visible={self._visible})"
class SplashScreenManager(Stub):
"""SplashScreenManager — 启动屏管理器"""
def __init__(self):
super().__init__()
self._splash_screens: Dict[Any, SplashScreen] = {}
def getSplashScreen(self, activity: Any) -> Optional[SplashScreen]:
return self._splash_screens.get(id(activity))
def installSplashScreen(self, activity: Any) -> SplashScreen:
screen = SplashScreen()
self._splash_screens[id(activity)] = screen
return screen
def uninstallSplashScreen(self, activity: Any):
self._splash_screens.pop(id(activity), None)
def toString(self) -> str:
return f"SplashScreenManager(screens={len(self._splash_screens)})"
# ═══════════════════════════════════════════════════════════════
# WindowContext / WindowContextController
# ═══════════════════════════════════════════════════════════════
class WindowContext(Stub):
"""WindowContext — 窗口上下文"""
def __init__(self, context: Any = None, windowType: int = TYPE_APPLICATION):
super().__init__()
self._base_context = context
self._window_type = windowType
self._resources: Any = None
def getBaseContext(self) -> Any:
return self._base_context
def getWindowType(self) -> int:
return self._window_type
def getResources(self) -> Any:
return self._resources
def setResources(self, resources: Any):
self._resources = resources
def toString(self) -> str:
return f"WindowContext(type={self._window_type})"
class WindowContextController(Stub):
"""WindowContextController — 窗口上下文控制器"""
def __init__(self, windowContext: Optional[WindowContext] = None):
super().__init__()
self._window_context = windowContext
def attachToDisplay(self, displayId: int):
pass
def detach(self):
pass
def toString(self) -> str:
return f"WindowContextController(ctx={self._window_context})"
# ═══════════════════════════════════════════════════════════════
# WindowHideScrollCaptureTarget
# ═══════════════════════════════════════════════════════════════
class WindowHideScrollCaptureTarget(Stub):
"""WindowHideScrollCaptureTarget — 窗口隐藏滚动捕获目标"""
def __init__(self, view: Any = None):
super().__init__()
self._view = view
def getView(self) -> Any:
return self._view
def toString(self) -> str:
return f"WindowHideScrollCaptureTarget(view={self._view})"
# ═══════════════════════════════════════════════════════════════
# WindowLayoutBuilder / WindowLayoutObserver
# ═══════════════════════════════════════════════════════════════
class WindowLayoutBuilder(Stub):
"""WindowLayoutBuilder — 窗口布局构建器"""
def __init__(self):
super().__init__()
self._width = 0
self._height = 0
self._gravity = 0
self._x = 0
self._y = 0
self._horizontal_margin = 0.0
self._vertical_margin = 0.0
def setWidth(self, width: int) -> "WindowLayoutBuilder":
self._width = width
return self
def setHeight(self, height: int) -> "WindowLayoutBuilder":
self._height = height
return self
def setGravity(self, gravity: int) -> "WindowLayoutBuilder":
self._gravity = gravity
return self
def setPosition(self, x: int, y: int) -> "WindowLayoutBuilder":
self._x = x
self._y = y
return self
def build(self) -> WindowManager.LayoutParams:
params = WindowManager.LayoutParams(w=self._width, h=self._height)
params.gravity = self._gravity
params.x = self._x
params.y = self._y
return params
def toString(self) -> str:
return f"WindowLayoutBuilder({self._width}x{self._height})"
class WindowLayoutObserver(Stub):
"""WindowLayoutObserver — 窗口布局观察者"""
def onLayoutChanged(self, layout: WindowManager.LayoutParams):
pass
def toString(self) -> str:
return f"WindowLayoutObserver@{hex(id(self))}"
# ═══════════════════════════════════════════════════════════════
# WindowManagerGlobal / WindowManagerPolicy / WindowProviderService
# ═══════════════════════════════════════════════════════════════
class WindowManagerGlobal(Stub):
"""WindowManagerGlobal — 全局窗口管理器"""
_instance: Optional["WindowManagerGlobal"] = None
@staticmethod
def getInstance() -> "WindowManagerGlobal":
if WindowManagerGlobal._instance is None:
WindowManagerGlobal._instance = WindowManagerGlobal()
return WindowManagerGlobal._instance
def __init__(self):
super().__init__()
self._views: Dict[int, Any] = {}
self._params: Dict[int, WindowManager.LayoutParams] = {}
self._next_id = 0
def addView(self, view: Any, params: WindowManager.LayoutParams):
vid = id(view)
self._views[vid] = view
self._params[vid] = params
def updateViewLayout(self, view: Any, params: WindowManager.LayoutParams):
vid = id(view)
if vid in self._params:
self._params[vid] = params
def removeView(self, view: Any):
vid = id(view)
self._views.pop(vid, None)
self._params.pop(vid, None)
def getWindowViews(self) -> List[Any]:
return list(self._views.values())
def getViewCount(self) -> int:
return len(self._views)
def toString(self) -> str:
return f"WindowManagerGlobal(views={len(self._views)})"
def equals(self, other: Any) -> bool:
return self is other
def hashCode(self) -> int:
return id(self) & 0x7FFFFFFF
class WindowManagerPolicy(Stub):
"""WindowManagerPolicy — 窗口管理器策略"""
WINDOW_MODE_FULLSCREEN = 0
WINDOW_MODE_FREEFORM = 1
WINDOW_MODE_SPLIT_SCREEN = 2
WINDOW_MODE_PINNED = 3
def __init__(self):
super().__init__()
def isKeyguardLocked(self) -> bool:
return False
def isKeyguardSecure(self) -> bool:
return False
def isScreenOn(self) -> bool:
return True
def toString(self) -> str:
return "WindowManagerPolicy"
class WindowProviderService(Stub):
"""WindowProviderService — 窗口提供者服务"""
SERVICE_INTERFACE = "android.window.WindowProviderService"
def __init__(self):
super().__init__()
def onCreateWindowProvider(self):
pass
def onWindowProviderAttached(self):
pass
def onWindowProviderDetached(self):
pass
def toString(self) -> str:
return f"WindowProviderService@{hex(id(self))}"
def equals(self, other: Any) -> bool:
return self is other
def hashCode(self) -> int:
return id(self) & 0x7FFFFFFF
Reference in new issue View Git Blame Copy Permalink