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关键字冲突
This commit is contained in:
shuiyu1123 committed
1 parent
506f9ac725
commit
a51854455b
128 files changed
+100571
-3
No files matched your search
@@ -0,0 +1,721 @@
|
||||
"""
|
||||
Android dalvik.system APIs implemented in Python.
|
||||
dalvik.system package - DexClassLoader, PathClassLoader, DexFile, VMRuntime, VMDebug, etc.
|
||||
Desktop stub implementation.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from .._core import Stub, AndroidOnlyError
|
||||
import sys as _sys
|
||||
import os as _os
|
||||
from typing import List, Optional
|
||||
|
||||
__all__ = [
|
||||
"DexClassLoader", "PathClassLoader", "BaseDexClassLoader",
|
||||
"DexFile", "InMemoryDexClassLoader",
|
||||
"VMRuntime", "VMDebug",
|
||||
"CloseGuard", "PotentialDeadlockError",
|
||||
"BlockGuard",
|
||||
]
|
||||
|
||||
|
||||
# ============================================================
|
||||
# BaseDexClassLoader
|
||||
# ============================================================
|
||||
|
||||
class BaseDexClassLoader(Stub):
|
||||
"""
|
||||
dalvik.system.BaseDexClassLoader
|
||||
A class loader that loads classes from DEX files.
|
||||
"""
|
||||
|
||||
def __init__(self, dex_path: str = "", optimized_dir: str = None,
|
||||
library_search_path: str = None, parent: Any = None):
|
||||
super().__init__()
|
||||
self._dex_path = dex_path
|
||||
self._optimized_dir = optimized_dir
|
||||
self._library_search_path = library_search_path
|
||||
self._parent = parent or type.__subclasses__
|
||||
self._loaded_classes = set()
|
||||
self._assertion_status = {}
|
||||
self._default_assertion_status = False
|
||||
|
||||
def loadClass(self, name: str, resolve: bool = True) -> Optional[type]:
|
||||
"""Loads a class by name."""
|
||||
# Try to find the class in the Python path
|
||||
parts = name.split(".")
|
||||
module_name = ".".join(parts[:-1])
|
||||
class_name = parts[-1]
|
||||
try:
|
||||
if module_name:
|
||||
module = __import__(module_name, fromlist=[class_name])
|
||||
cls = getattr(module, class_name, None)
|
||||
else:
|
||||
cls = globals().get(class_name) or __builtins__.get(class_name)
|
||||
if cls:
|
||||
self._loaded_classes.add(name)
|
||||
return cls
|
||||
return None
|
||||
except (ImportError, AttributeError):
|
||||
return None
|
||||
|
||||
def findClass(self, name: str) -> Optional[type]:
|
||||
"""Finds a class by name."""
|
||||
return self.loadClass(name)
|
||||
|
||||
def findResource(self, name: str) -> Optional[str]:
|
||||
"""Finds a resource by name."""
|
||||
path = _os.path.join(self._dex_path or "", name)
|
||||
if _os.path.exists(path):
|
||||
return path
|
||||
return None
|
||||
|
||||
def findResources(self, name: str) -> List[str]:
|
||||
"""Finds all resources by name."""
|
||||
result = []
|
||||
r = self.findResource(name)
|
||||
if r:
|
||||
result.append(r)
|
||||
return result
|
||||
|
||||
def getParent(self):
|
||||
return self._parent
|
||||
|
||||
def getPackage(self, name: str):
|
||||
"""Gets a package by name."""
|
||||
return None
|
||||
|
||||
def setClassAssertionStatus(self, class_name: str, enabled: bool):
|
||||
self._assertion_status[class_name] = enabled
|
||||
|
||||
def setDefaultAssertionStatus(self, enabled: bool):
|
||||
self._default_assertion_status = enabled
|
||||
|
||||
def setPackageAssertionStatus(self, package_name: str, enabled: bool):
|
||||
pass
|
||||
|
||||
def clearAssertionStatus(self):
|
||||
self._assertion_status = {}
|
||||
self._default_assertion_status = False
|
||||
|
||||
def toString(self) -> str:
|
||||
return f"BaseDexClassLoader@{hex(id(self))}[dex={self._dex_path}]"
|
||||
|
||||
def equals(self, other) -> bool:
|
||||
return self is other
|
||||
|
||||
def hashCode(self) -> int:
|
||||
return hash(self) & 0x7FFFFFFF
|
||||
|
||||
|
||||
# ============================================================
|
||||
# DexClassLoader
|
||||
# ============================================================
|
||||
|
||||
class DexClassLoader(BaseDexClassLoader):
|
||||
"""
|
||||
dalvik.system.DexClassLoader
|
||||
A class loader that loads classes from .jar and .apk files.
|
||||
"""
|
||||
|
||||
def __init__(self, dex_path: str = "", optimized_dir: str = None,
|
||||
library_search_path: str = None, parent: Any = None):
|
||||
super().__init__(dex_path, optimized_dir, library_search_path, parent)
|
||||
|
||||
def loadClass(self, name: str, resolve: bool = True) -> Optional[type]:
|
||||
return super().loadClass(name, resolve)
|
||||
|
||||
def findClass(self, name: str) -> Optional[type]:
|
||||
return super().findClass(name)
|
||||
|
||||
def getParent(self):
|
||||
return super().getParent()
|
||||
|
||||
def getResourceAsStream(self, name: str):
|
||||
"""Returns an input stream for reading a resource."""
|
||||
path = self.findResource(name)
|
||||
if path:
|
||||
return open(path, 'rb')
|
||||
return None
|
||||
|
||||
def getResources(self, name: str):
|
||||
"""Returns an enumeration of URLs for a resource."""
|
||||
return iter(self.findResources(name))
|
||||
|
||||
def toString(self) -> str:
|
||||
return f"DexClassLoader@{hex(id(self))}[dex={self._dex_path}]"
|
||||
|
||||
|
||||
# ============================================================
|
||||
# PathClassLoader
|
||||
# ============================================================
|
||||
|
||||
class PathClassLoader(BaseDexClassLoader):
|
||||
"""
|
||||
dalvik.system.PathClassLoader
|
||||
A class loader for loading classes from the file system.
|
||||
"""
|
||||
|
||||
def __init__(self, dex_path: str = "", parent: Any = None,
|
||||
library_search_path: str = None):
|
||||
super().__init__(dex_path, None, library_search_path, parent)
|
||||
|
||||
def loadClass(self, name: str, resolve: bool = True) -> Optional[type]:
|
||||
return super().loadClass(name, resolve)
|
||||
|
||||
def findClass(self, name: str) -> Optional[type]:
|
||||
return super().findClass(name)
|
||||
|
||||
def getParent(self):
|
||||
return super().getParent()
|
||||
|
||||
def toString(self) -> str:
|
||||
return f"PathClassLoader@{hex(id(self))}[dex={self._dex_path}]"
|
||||
|
||||
|
||||
# ============================================================
|
||||
# InMemoryDexClassLoader
|
||||
# ============================================================
|
||||
|
||||
class InMemoryDexClassLoader(BaseDexClassLoader):
|
||||
"""
|
||||
dalvik.system.InMemoryDexClassLoader
|
||||
A class loader that loads classes from in-memory DEX buffers.
|
||||
"""
|
||||
|
||||
def __init__(self, dex_buffers: List, parent: Any = None):
|
||||
super().__init__("", None, None, parent)
|
||||
self._dex_buffers = dex_buffers
|
||||
|
||||
def loadClass(self, name: str, resolve: bool = True) -> Optional[type]:
|
||||
return super().loadClass(name, resolve)
|
||||
|
||||
def findClass(self, name: str) -> Optional[type]:
|
||||
return super().findClass(name)
|
||||
|
||||
def toString(self) -> str:
|
||||
return f"InMemoryDexClassLoader@{hex(id(self))}[buffers={len(self._dex_buffers)}]"
|
||||
|
||||
|
||||
# ============================================================
|
||||
# DexFile
|
||||
# ============================================================
|
||||
|
||||
class DexFile(Stub):
|
||||
"""
|
||||
dalvik.system.DexFile
|
||||
Represents a single DEX file.
|
||||
"""
|
||||
|
||||
def __init__(self, file_name: str = None):
|
||||
super().__init__()
|
||||
self._file_name = file_name
|
||||
self._closed = False
|
||||
|
||||
@staticmethod
|
||||
def loadDex(source_path: str, output_path: str, flags: int = 0) -> "DexFile":
|
||||
return DexFile(source_path)
|
||||
|
||||
def loadClass(self, name: str, loader: Any = None) -> Optional[type]:
|
||||
"""Loads a class from this DEX file."""
|
||||
parts = name.split(".")
|
||||
try:
|
||||
module = __import__(".".join(parts[:-1]), fromlist=[parts[-1]])
|
||||
return getattr(module, parts[-1], None)
|
||||
except (ImportError, AttributeError):
|
||||
return None
|
||||
|
||||
def loadClassBinaryName(self, name: str, loader: Any = None) -> Optional[type]:
|
||||
"""Loads a class using binary (internal) name format."""
|
||||
java_name = name.replace("/", ".")
|
||||
return self.loadClass(java_name, loader)
|
||||
|
||||
def getName(self) -> str:
|
||||
return self._file_name or ""
|
||||
|
||||
def close(self):
|
||||
self._closed = True
|
||||
|
||||
def entries(self):
|
||||
"""Returns an enumeration of class names."""
|
||||
return iter([])
|
||||
|
||||
def getEntryCount(self) -> int:
|
||||
return 0
|
||||
|
||||
@staticmethod
|
||||
def isDexOptNeeded(source_path: str) -> bool:
|
||||
return False
|
||||
|
||||
def toString(self) -> str:
|
||||
return f"DexFile@{hex(id(self))}[file={self._file_name}]"
|
||||
|
||||
def equals(self, other) -> bool:
|
||||
return self is other
|
||||
|
||||
def hashCode(self) -> int:
|
||||
return hash(self) & 0x7FFFFFFF
|
||||
|
||||
|
||||
# ============================================================
|
||||
# VMRuntime
|
||||
# ============================================================
|
||||
|
||||
class VMRuntime(Stub):
|
||||
"""
|
||||
dalvik.system.VMRuntime
|
||||
Provides access to Dalvik/ART VM runtime features.
|
||||
"""
|
||||
|
||||
_runtime = None
|
||||
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self._target_sdk_version = 0
|
||||
self._jit_compiler_filter = "speed"
|
||||
self._large_heap_class = None
|
||||
self._large_heap_size = 0
|
||||
self._native_allocation_count = 0
|
||||
self._disabled_compat_changes = []
|
||||
|
||||
@staticmethod
|
||||
def getRuntime() -> "VMRuntime":
|
||||
if VMRuntime._runtime is None:
|
||||
VMRuntime._runtime = VMRuntime()
|
||||
return VMRuntime._runtime
|
||||
|
||||
def is64Bit(self) -> bool:
|
||||
import struct
|
||||
return struct.calcsize("P") == 8
|
||||
|
||||
def setTargetSdkVersion(self, version: int):
|
||||
self._target_sdk_version = version
|
||||
|
||||
def getTargetSdkVersion(self) -> int:
|
||||
return self._target_sdk_version
|
||||
|
||||
def startJitCompilation(self):
|
||||
pass
|
||||
|
||||
def endJitCompilation(self):
|
||||
pass
|
||||
|
||||
def concurrentGC(self, enable: bool):
|
||||
pass
|
||||
|
||||
def enableGcLogging(self, enable: bool):
|
||||
pass
|
||||
|
||||
def vmInstructionSet(self) -> str:
|
||||
import platform
|
||||
machine = platform.machine()
|
||||
if machine in ("x86_64", "amd64"):
|
||||
return "x86_64"
|
||||
elif machine in ("i386", "i686"):
|
||||
return "x86"
|
||||
elif machine in ("aarch64", "arm64"):
|
||||
return "arm64"
|
||||
elif machine.startswith("arm"):
|
||||
return "arm"
|
||||
return machine
|
||||
|
||||
def isVm64(self) -> bool:
|
||||
return self.is64Bit()
|
||||
|
||||
def getExprOpts(self) -> str:
|
||||
return ""
|
||||
|
||||
def setExprOpts(self, opts: str):
|
||||
pass
|
||||
|
||||
def registerAppInfo(self, app_name: str, app_data_dir: str):
|
||||
pass
|
||||
|
||||
def getDetachThreadTimeout(self) -> int:
|
||||
return 0
|
||||
|
||||
def setDetachThreadTimeout(self, timeout_ms: int):
|
||||
pass
|
||||
|
||||
def setDisabledCompatChanges(self, changes: List[int]):
|
||||
self._disabled_compat_changes = list(changes)
|
||||
|
||||
def isBootClassPathOnDisk(self) -> bool:
|
||||
return True
|
||||
|
||||
def isJavaDebuggable(self) -> bool:
|
||||
return False
|
||||
|
||||
def getJitCompilerFilter(self) -> str:
|
||||
return self._jit_compiler_filter
|
||||
|
||||
def setJitCompilerFilter(self, filter_: str):
|
||||
self._jit_compiler_filter = filter_
|
||||
|
||||
def getLargeHeapClass(self) -> str:
|
||||
return self._large_heap_class
|
||||
|
||||
def setLargeHeapClass(self, class_name: str):
|
||||
self._large_heap_class = class_name
|
||||
|
||||
def getLargeHeapSize(self) -> int:
|
||||
return self._large_heap_size
|
||||
|
||||
def setLargeHeapSize(self, size: int):
|
||||
self._large_heap_size = size
|
||||
|
||||
def registerNativeAllocation(self, bytes_: int):
|
||||
self._native_allocation_count += bytes_
|
||||
|
||||
def registerNativeFree(self, bytes_: int):
|
||||
self._native_allocation_count -= bytes_
|
||||
|
||||
def toString(self) -> str:
|
||||
return f"VMRuntime@{hex(id(self))}[64bit={self.is64Bit()}]"
|
||||
|
||||
def equals(self, other) -> bool:
|
||||
return self is other
|
||||
|
||||
def hashCode(self) -> int:
|
||||
return hash(self) & 0x7FFFFFFF
|
||||
|
||||
|
||||
# ============================================================
|
||||
# VMDebug
|
||||
# ============================================================
|
||||
|
||||
class VMDebug(Stub):
|
||||
"""
|
||||
dalvik.system.VMDebug
|
||||
Provides debug features for the VM.
|
||||
"""
|
||||
TRACE_COUNT_ALLOCS: int = 1
|
||||
TRACE_COUNT_ALLOCS_SYSTEM_ONLY: int = 2
|
||||
TRACE_COUNT_ALLOCS_ALL: int = 3
|
||||
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self._alloc_count = 0
|
||||
self._alloc_size = 0
|
||||
self._freed_count = 0
|
||||
self._freed_size = 0
|
||||
|
||||
@staticmethod
|
||||
def startCountingAllocations():
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def stopCountingAllocations():
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def getGlobalAllocCount() -> int:
|
||||
return 0
|
||||
|
||||
@staticmethod
|
||||
def getGlobalAllocSize() -> int:
|
||||
return 0
|
||||
|
||||
@staticmethod
|
||||
def getGlobalFreedCount() -> int:
|
||||
return 0
|
||||
|
||||
@staticmethod
|
||||
def getGlobalFreedSize() -> int:
|
||||
return 0
|
||||
|
||||
@staticmethod
|
||||
def getLoadedClasses() -> int:
|
||||
return 0
|
||||
|
||||
@staticmethod
|
||||
def printLoadedClasses(count: int):
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def isDebuggerConnected() -> bool:
|
||||
return False
|
||||
|
||||
@staticmethod
|
||||
def isDebuggingEnabled() -> bool:
|
||||
return False
|
||||
|
||||
@staticmethod
|
||||
def resetAllocCount():
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def getThreadAllocCount() -> int:
|
||||
return 0
|
||||
|
||||
@staticmethod
|
||||
def getThreadAllocSize() -> int:
|
||||
return 0
|
||||
|
||||
@staticmethod
|
||||
def threadCpuTimeNanos() -> int:
|
||||
import time
|
||||
return int(time.time() * 1e9)
|
||||
|
||||
@staticmethod
|
||||
def startEmulatorTracing():
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def stopEmulatorTracing():
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def startMethodTracing(filename: str = None, buffer_size: int = 0, flags: int = 0, sampling_interval: int = 0):
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def stopMethodTracing():
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def getMethodTracingMode() -> int:
|
||||
return 0
|
||||
|
||||
@staticmethod
|
||||
def getRuntimeStat(stat_name: str) -> str:
|
||||
return ""
|
||||
|
||||
@staticmethod
|
||||
def getRuntimeStatValue(stat_name: str, value: int) -> int:
|
||||
return 0
|
||||
|
||||
@staticmethod
|
||||
def resolveClassLinkageError(cls: type):
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def crash():
|
||||
raise RuntimeError("VMDebug.crash() called")
|
||||
|
||||
@staticmethod
|
||||
def dumpReferenceTables():
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def setAllocTrackerStackDepth(depth: int):
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def attachAgent(agent: str, options: str = None, class_loader: Any = None):
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def startAllocCounting():
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def stopAllocCounting():
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def getGlobalExternalAllocCount() -> int:
|
||||
return 0
|
||||
|
||||
@staticmethod
|
||||
def getGlobalExternalAllocSize() -> int:
|
||||
return 0
|
||||
|
||||
@staticmethod
|
||||
def getGlobalExternalFreedCount() -> int:
|
||||
return 0
|
||||
|
||||
@staticmethod
|
||||
def getGlobalExternalFreedSize() -> int:
|
||||
return 0
|
||||
|
||||
@staticmethod
|
||||
def setAllocationLimit(limit: int):
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def setGlobalCpuLimit(limit: int):
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def setThreadCpuLimit(limit: int):
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def setMethodTracingPriority(priority: int):
|
||||
pass
|
||||
|
||||
def toString(self) -> str:
|
||||
return f"VMDebug@{hex(id(self))}"
|
||||
|
||||
def equals(self, other) -> bool:
|
||||
return self is other
|
||||
|
||||
def hashCode(self) -> int:
|
||||
return hash(self) & 0x7FFFFFFF
|
||||
|
||||
|
||||
# ============================================================
|
||||
# CloseGuard
|
||||
# ============================================================
|
||||
|
||||
class CloseGuard(Stub):
|
||||
"""
|
||||
dalvik.system.CloseGuard
|
||||
Reports when resources are not closed properly.
|
||||
"""
|
||||
REPORTER = None
|
||||
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self._open = False
|
||||
self._reported = False
|
||||
|
||||
@staticmethod
|
||||
def get() -> "CloseGuard":
|
||||
return CloseGuard()
|
||||
|
||||
def open(self, closer: str):
|
||||
"""Marks this guard as open."""
|
||||
self._open = True
|
||||
|
||||
def close(self):
|
||||
"""Marks this guard as closed."""
|
||||
self._open = False
|
||||
|
||||
def warnIfOpen(self):
|
||||
"""Warns if the guard is still open."""
|
||||
if self._open and not self._reported:
|
||||
self._reported = True
|
||||
|
||||
@staticmethod
|
||||
def setEnabled(enabled: bool):
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def getReporter():
|
||||
return CloseGuard.REPORTER
|
||||
|
||||
@staticmethod
|
||||
def setReporter(reporter):
|
||||
CloseGuard.REPORTER = reporter
|
||||
|
||||
def toString(self) -> str:
|
||||
return f"CloseGuard@{hex(id(self))}[open={self._open}]"
|
||||
|
||||
def equals(self, other) -> bool:
|
||||
return self is other
|
||||
|
||||
def hashCode(self) -> int:
|
||||
return hash(self) & 0x7FFFFFFF
|
||||
|
||||
|
||||
# ============================================================
|
||||
# PotentialDeadlockError
|
||||
# ============================================================
|
||||
|
||||
class PotentialDeadlockError(Exception, Stub):
|
||||
"""
|
||||
dalvik.system.PotentialDeadlockError
|
||||
Thrown when a potential deadlock is detected.
|
||||
"""
|
||||
def __init__(self, message: str = None):
|
||||
super().__init__(message or "Potential deadlock detected")
|
||||
self._message = message
|
||||
|
||||
def toString(self) -> str:
|
||||
return f"PotentialDeadlockError: {self._message}"
|
||||
|
||||
def equals(self, other) -> bool:
|
||||
return isinstance(other, PotentialDeadlockError) and self._message == other._message
|
||||
|
||||
def hashCode(self) -> int:
|
||||
return hash(self._message) & 0x7FFFFFFF
|
||||
|
||||
|
||||
# ============================================================
|
||||
# BlockGuard
|
||||
# ============================================================
|
||||
|
||||
class BlockGuard(Stub):
|
||||
"""
|
||||
dalvik.system.BlockGuard
|
||||
Mechanism to detect and prevent blocking operations on the main thread.
|
||||
"""
|
||||
LAX_POLICY = None
|
||||
|
||||
class Policy(Stub):
|
||||
"""
|
||||
dalvik.system.BlockGuard.Policy
|
||||
Interface for block guard policies.
|
||||
"""
|
||||
def onReadFromDisk(self): pass
|
||||
def onWriteToDisk(self): pass
|
||||
def onNetwork(self): pass
|
||||
def onExplicitSuspend(self): pass
|
||||
def getPolicyMask(self) -> int: return 0
|
||||
def onFileSystemAccess(self): pass
|
||||
def onUnbufferedIO(self): pass
|
||||
|
||||
def toString(self) -> str:
|
||||
return "BlockGuard.Policy"
|
||||
|
||||
def equals(self, other) -> bool:
|
||||
return isinstance(other, BlockGuard.Policy)
|
||||
|
||||
def hashCode(self) -> int:
|
||||
return hash("BlockGuard.Policy") & 0x7FFFFFFF
|
||||
|
||||
class Operational(Policy):
|
||||
"""
|
||||
dalvik.system.BlockGuard.Operational
|
||||
Operational policy for block guard.
|
||||
"""
|
||||
def toString(self) -> str:
|
||||
return "BlockGuard.Operational"
|
||||
|
||||
def equals(self, other) -> bool:
|
||||
return isinstance(other, BlockGuard.Operational)
|
||||
|
||||
def hashCode(self) -> int:
|
||||
return hash("BlockGuard.Operational") & 0x7FFFFFFF
|
||||
|
||||
_delegate = None
|
||||
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
|
||||
@staticmethod
|
||||
def setDelegate(delegate):
|
||||
BlockGuard._delegate = delegate
|
||||
|
||||
@staticmethod
|
||||
def isOperational() -> bool:
|
||||
return BlockGuard._delegate is not None
|
||||
|
||||
@staticmethod
|
||||
def initDelegate():
|
||||
"""Initializes the delegate as a BlockGuard.Operational."""
|
||||
BlockGuard._delegate = BlockGuard.Operational()
|
||||
|
||||
@staticmethod
|
||||
def getThreadPolicy():
|
||||
"""Returns the policy for the current thread."""
|
||||
return BlockGuard.LAX_POLICY or BlockGuard.Policy()
|
||||
|
||||
@staticmethod
|
||||
def setThreadPolicy(policy: Policy):
|
||||
pass
|
||||
|
||||
def toString(self) -> str:
|
||||
return f"BlockGuard@{hex(id(self))}"
|
||||
|
||||
def equals(self, other) -> bool:
|
||||
return self is other
|
||||
|
||||
def hashCode(self) -> int:
|
||||
return hash(self) & 0x7FFFFFFF
|
||||
|
||||
|
||||
BlockGuard.LAX_POLICY = BlockGuard.Policy()
|
||||
Reference in new issue
Block a user