""" Android Fragment API — Fragment, FragmentManager, FragmentTransaction, etc. 方法签名完全对齐 Android SDK """ from __future__ import annotations import uuid import threading from typing import Any, Dict, List, Optional, Set, Tuple, Callable from enum import IntEnum from .._core import Stub, AndroidOnlyError from ..java.lang import RuntimeException, IllegalArgumentException, IllegalStateException # ═══════════════════════════════════════════════════════════════ # 常量 # ═══════════════════════════════════════════════════════════════ # TRANSIT_* 常量 TRANSIT_NONE = 0 TRANSIT_FRAGMENT_OPEN = 1 TRANSIT_FRAGMENT_CLOSE = 2 TRANSIT_FRAGMENT_FADE = 3 TRANSIT_UNSET = -1 TRANSIT_ENTER_MASK = 0x1000 TRANSIT_EXIT_MASK = 0x2000 # TRANSACTION_* 常量 TRANSACTION_NONE = 0 TRANSACTION_ADD = 1 TRANSACTION_REMOVE = 2 TRANSACTION_REPLACE = 3 TRANSACTION_SHOW = 4 TRANSACTION_HIDE = 5 TRANSACTION_ATTACH = 6 TRANSACTION_DETACH = 7 TRANSACTION_SET_PRIMARY_NAV = 8 # OP_* 操作常量 (内部) _OP_NONE = 0 _OP_ADD = 1 _OP_REPLACE = 2 _OP_REMOVE = 3 _OP_HIDE = 4 _OP_SHOW = 5 _OP_DETACH = 6 _OP_ATTACH = 7 _OP_SET_PRIMARY_NAV = 8 # Fragment 常量 Fragment_USE_DEFAULT_TRANSITION = 0 FRAGMENT_RESULT_CANCELED = 0 FRAGMENT_RESULT_OK = -1 # FragmentManager 常量 POP_BACK_STACK_INCLUSIVE = 1 # ═══════════════════════════════════════════════════════════════ # Fragment # ═══════════════════════════════════════════════════════════════ class Fragment(Stub): """Fragment — 片段基类 (桌面存根)""" def __init__(self): super().__init__() self._mCalled = False self._mTag: Optional[str] = None self._mFragmentId = 0 self._mContainerId = 0 self._mView: Optional[Any] = None self._mArguments: Optional[Any] = None self._mHidden = False self._mDetached = False self._mRemoving = False self._mInLayout = False self._mMenuVisible = True self._mHasMenu = False self._mRetainInstance = False self._mUserVisibleHint = True self._mState = 0 self._mSavedState: Optional[Any] = None self._mActivity: Optional["FragmentActivity"] = None self._mHost: Optional["FragmentHostCallback"] = None self._mFragmentManager: Optional["FragmentManager"] = None self._mChildFragmentManager: Optional["FragmentManager"] = None self._mParentFragment: Optional["Fragment"] = None self._mTargetFragment: Optional["Fragment"] = None self._mTargetRequestCode = 0 self._mNextAnim = 0 self._mEnterTransition: Optional[Any] = None self._mExitTransition: Optional[Any] = None self._mSharedElementEnterTransition: Optional[Any] = None self._mSharedElementExitTransition: Optional[Any] = None self._mAllowEnterTransitionOverlap: Optional[bool] = None self._mAllowReturnTransitionOverlap: Optional[bool] = None self._mReenterTransition: Optional[Any] = None self._mReturnTransition: Optional[Any] = None self._mSharedElementReturnTransition: Optional[Any] = None self._mSharedElementReenterTransition: Optional[Any] = None self._mLifecycleRegistry: Optional[Any] = None self._mViewModelStore: Optional[Any] = None self._mMaxState: Optional[str] = None self._mInitialLifecycleState: Optional[int] = None self._mPrimaryNavigationFragment = False self._mIsNewlyAdded = False self._mIsCreated = False self._mIsViewCreated = False self._mIsStateSaved = False self._mIsStateSavedBefore = False self._mFragmentTransitionState = 0 self._mInTransition = False self._mPostponedHandler: Optional[Any] = None self._mAnimationInfo: Optional[Any] = None self._mDebug = False self._mCalledForTransition = False self._mHiddenChanged = False self._mAnimationResId = 0 self._mContainer: Optional["FragmentContainer"] = None self._mFactory: Optional[Any] = None self._mRequestPermissionsResult: List[Tuple[int, List[str], List[int]]] = [] self._mResultListeners: List[Any] = [] def getActivity(self) -> Optional["FragmentActivity"]: return self._mActivity def getHost(self) -> Optional["FragmentHostCallback"]: return self._mHost def getFragmentManager(self) -> Optional["FragmentManager"]: return self._mFragmentManager def getChildFragmentManager(self) -> Optional["FragmentManager"]: if self._mChildFragmentManager is None: from .._core import Stub as _Stub self._mChildFragmentManager = FragmentManager() return self._mChildFragmentManager def getParentFragment(self) -> Optional["Fragment"]: return self._mParentFragment def getTag(self) -> Optional[str]: return self._mTag def getId(self) -> int: return self._mFragmentId def getView(self) -> Optional[Any]: return self._mView def getArguments(self) -> Optional[Any]: return self._mArguments def setArguments(self, args: Any) -> None: if self._mState > 0: raise IllegalStateException("Fragment already active") self._mArguments = args def isAdded(self) -> bool: return self._mActivity is not None and self._mState > 0 def isDetached(self) -> bool: return self._mDetached def isRemoving(self) -> bool: return self._mRemoving def isInLayout(self) -> bool: return self._mInLayout def isResumed(self) -> bool: return self._mState >= 7 def isVisible(self) -> bool: return (not self._mHidden) and self.isAdded() and self._mView is not None def isHidden(self) -> bool: return self._mHidden def isMenuVisible(self) -> bool: return self._mMenuVisible def getUserVisibleHint(self) -> bool: return self._mUserVisibleHint def setUserVisibleHint(self, isVisible: bool) -> None: self._mUserVisibleHint = isVisible self._mHiddenChanged = not isVisible def getRetainInstance(self) -> bool: return self._mRetainInstance def setRetainInstance(self, retain: bool) -> None: self._mRetainInstance = retain def hasOptionsMenu(self) -> bool: return self._mHasMenu def setHasOptionsMenu(self, hasMenu: bool) -> None: self._mHasMenu = hasMenu def setMenuVisibility(self, menuVisible: bool) -> None: self._mMenuVisible = menuVisible def getTargetFragment(self) -> Optional["Fragment"]: return self._mTargetFragment def setTargetFragment(self, fragment: Optional["Fragment"], requestCode: int) -> None: self._mTargetFragment = fragment self._mTargetRequestCode = requestCode def getTargetRequestCode(self) -> int: return self._mTargetRequestCode def getContext(self) -> Optional[Any]: return self._mActivity def getResources(self) -> Optional[Any]: if self._mActivity: return self._mActivity.getResources() return None def requireActivity(self) -> "FragmentActivity": if self._mActivity is None: raise IllegalStateException("Fragment not attached to Activity") return self._mActivity def requireFragmentManager(self) -> "FragmentManager": if self._mFragmentManager is None: raise IllegalStateException("Fragment not attached to FragmentManager") return self._mFragmentManager def requireContext(self) -> Any: ctx = self.getContext() if ctx is None: raise IllegalStateException("Fragment not attached to a context") return ctx def requireView(self) -> Any: view = self.getView() if view is None: raise IllegalStateException("Fragment does not have a view") return view def requireHost(self) -> "FragmentHostCallback": if self._mHost is None: raise IllegalStateException("Fragment not attached to host") return self._mHost def isStateSaved(self) -> bool: return self._mIsStateSaved def getLifecycle(self) -> Optional[Any]: return self._mLifecycleRegistry def getViewModelStore(self) -> Optional[Any]: return self._mViewModelStore def postponeEnterTransition(self) -> None: self._mPostponedHandler = True def startPostponedEnterTransition(self) -> None: self._mPostponedHandler = None def getEnterTransition(self) -> Optional[Any]: return self._mEnterTransition def setEnterTransition(self, transition: Any) -> None: self._mEnterTransition = transition def getExitTransition(self) -> Optional[Any]: return self._mExitTransition def setExitTransition(self, transition: Any) -> None: self._mExitTransition = transition def getSharedElementEnterTransition(self) -> Optional[Any]: return self._mSharedElementEnterTransition def setSharedElementEnterTransition(self, transition: Any) -> None: self._mSharedElementEnterTransition = transition def getSharedElementExitTransition(self) -> Optional[Any]: return self._mSharedElementExitTransition def setSharedElementExitTransition(self, transition: Any) -> None: self._mSharedElementExitTransition = transition def getReenterTransition(self) -> Optional[Any]: return self._mReenterTransition or self._mEnterTransition def setReenterTransition(self, transition: Any) -> None: self._mReenterTransition = transition def getReturnTransition(self) -> Optional[Any]: return self._mReturnTransition or self._mExitTransition def setReturnTransition(self, transition: Any) -> None: self._mReturnTransition = transition def getSharedElementReturnTransition(self) -> Optional[Any]: return self._mSharedElementReturnTransition or self._mSharedElementEnterTransition def setSharedElementReturnTransition(self, transition: Any) -> None: self._mSharedElementReturnTransition = transition def getSharedElementReenterTransition(self) -> Optional[Any]: return self._mSharedElementReenterTransition or self._mSharedElementExitTransition def setSharedElementReenterTransition(self, transition: Any) -> None: self._mSharedElementReenterTransition = transition def getAllowEnterTransitionOverlap(self) -> bool: return self._mAllowEnterTransitionOverlap is not False def setAllowEnterTransitionOverlap(self, allow: bool) -> None: self._mAllowEnterTransitionOverlap = allow def getAllowReturnTransitionOverlap(self) -> bool: return self._mAllowReturnTransitionOverlap is not False def setAllowReturnTransitionOverlap(self, allow: bool) -> None: self._mAllowReturnTransitionOverlap = allow def isInBackStack(self) -> bool: return self._mFragmentManager is not None def getString(self, resId: int, *formatArgs: Any) -> str: return f"string_{resId}" def getText(self, resId: int) -> str: return f"text_{resId}" def getInt(self, resId: int) -> int: return 0 def getBoolean(self, resId: int) -> bool: return False def instantiate(self, context: Any, fname: str, args: Optional[Any] = None) -> "Fragment": return Fragment() # ── 生命周期 ── def onAttach(self, context: Any) -> None: self._mCalled = True def onCreate(self, savedInstanceState: Optional[Any]) -> None: self._mCalled = True self._mIsCreated = True def onCreateView(self, inflater: Any, container: Any, savedInstanceState: Optional[Any]) -> Optional[Any]: self._mCalled = True return None def onViewCreated(self, view: Any, savedInstanceState: Optional[Any]) -> None: self._mCalled = True self._mIsViewCreated = True def onActivityCreated(self, savedInstanceState: Optional[Any]) -> None: self._mCalled = True def onViewStateRestored(self, savedInstanceState: Optional[Any]) -> None: self._mCalled = True def onStart(self) -> None: self._mCalled = True def onResume(self) -> None: self._mCalled = True def onPause(self) -> None: self._mCalled = True def onStop(self) -> None: self._mCalled = True def onDestroyView(self) -> None: self._mCalled = True self._mIsViewCreated = False def onDestroy(self) -> None: self._mCalled = True self._mIsCreated = False def onDetach(self) -> None: self._mCalled = True def onSaveInstanceState(self, outState: Any) -> None: pass def onMultiWindowModeChanged(self, isInMultiWindowMode: bool, newConfig: Any) -> None: pass def onPictureInPictureModeChanged(self, isInPictureInPictureMode: bool, newConfig: Any) -> None: pass def onConfigurationChanged(self, newConfig: Any) -> None: pass def onLowMemory(self) -> None: pass def onHiddenChanged(self, hidden: bool) -> None: pass def onAttachFragment(self, childFragment: "Fragment") -> None: pass def dump(self, prefix: str, fd: Any, writer: Any, args: List[str]) -> None: pass def registerForActivityResult(self, contract: Any, callback: Any) -> Any: return None def unregisterForActivityResult(self, token: Any) -> None: pass def toString(self) -> str: return f"Fragment({self._mTag or hex(id(self))})" # ═══════════════════════════════════════════════════════════════ # FragmentManager # ═══════════════════════════════════════════════════════════════ class FragmentManager(Stub): """FragmentManager — 片段管理器""" def __init__(self): super().__init__() self._lock = threading.Lock() self._fragments: Dict[str, Fragment] = {} self._back_stack: List["FragmentTransaction"] = [] self._back_stack_indices: Dict[int, str] = {} self._next_index = 0 self._primary_nav_fragment: Optional[Fragment] = None self._fragment_container: Optional["FragmentContainer"] = None def beginTransaction(self) -> "FragmentTransaction": return FragmentTransaction(self) def executePendingTransactions(self) -> bool: return True def findFragmentById(self, id: int) -> Optional[Fragment]: with self._lock: for frag in self._fragments.values(): if frag.getId() == id: return frag return None def findFragmentByTag(self, tag: str) -> Optional[Fragment]: with self._lock: return self._fragments.get(tag) def popBackStack(self) -> None: with self._lock: if self._back_stack: trans = self._back_stack.pop() trans._reverse() def popBackStackImmediate(self, name: Optional[str] = None, flags: int = 0) -> bool: self.popBackStack() return True def popBackStack( self, name: Optional[str], flags: int ) -> None: with self._lock: if name is None: if self._back_stack: trans = self._back_stack.pop() trans._reverse() return idx = -1 for i, t in enumerate(self._back_stack): if t._name == name: idx = i break if idx >= 0: inclusive = (flags & POP_BACK_STACK_INCLUSIVE) != 0 start = idx if inclusive else idx + 1 to_remove = self._back_stack[start:] self._back_stack = self._back_stack[:start] for t in reversed(to_remove): t._reverse() def getBackStackEntryCount(self) -> int: with self._lock: return len(self._back_stack) def getBackStackEntryAt(self, index: int) -> Optional[Any]: with self._lock: if 0 <= index < len(self._back_stack): return self._back_stack[index] return None def saveFragmentInstanceState(self, fragment: Fragment) -> Optional[Any]: return None def isDestroyed(self) -> bool: return False def isStateSaved(self) -> bool: return False def getFragments(self) -> List[Fragment]: with self._lock: return list(self._fragments.values()) def getFragment(self, bundle: Any, key: str) -> Optional[Fragment]: return None def putFragment(self, bundle: Any, key: str, fragment: Fragment) -> None: pass def getPrimaryNavigationFragment(self) -> Optional[Fragment]: return self._primary_nav_fragment def registerFragmentLifecycleCallbacks(self, cb: Any, recursive: bool) -> None: pass def unregisterFragmentLifecycleCallbacks(self, cb: Any) -> None: pass def isPrimaryNavigation(self, fragment: Fragment) -> bool: return fragment == self._primary_nav_fragment def toString(self) -> str: with self._lock: return f"FragmentManager(fragments={len(self._fragments)}, backstack={len(self._back_stack)})" # ═══════════════════════════════════════════════════════════════ # FragmentTransaction # ═══════════════════════════════════════════════════════════════ class FragmentTransaction(Stub): """FragmentTransaction — 片段事务""" TRANSIT_ENTER_MASK = TRANSIT_ENTER_MASK TRANSIT_EXIT_MASK = TRANSIT_EXIT_MASK TRANSIT_UNSET = TRANSIT_UNSET TRANSIT_NONE = TRANSIT_NONE TRANSIT_FRAGMENT_OPEN = TRANSIT_FRAGMENT_OPEN TRANSIT_FRAGMENT_CLOSE = TRANSIT_FRAGMENT_CLOSE TRANSIT_FRAGMENT_FADE = TRANSIT_FRAGMENT_FADE def __init__(self, manager: "FragmentManager"): super().__init__() self._manager = manager self._ops: List[Dict[str, Any]] = [] self._name: Optional[str] = None self._transition = TRANSIT_NONE self._transition_style = 0 self._transition_shared = False self._allow_add_to_back_stack = True self._add_to_back_stack = False self._is_reordering_allowed = False self._bread_crumb_title_res = 0 self._bread_crumb_title: Optional[str] = None self._mCommitListener: Optional[Any] = None def add(self, containerViewId: Any = 0, fragment: Optional[Any] = None, tag: Optional[str] = None) -> "FragmentTransaction": if fragment is None and not isinstance(containerViewId, int): fragment = containerViewId containerViewId = 0 self._ops.append({ "op": _OP_ADD, "fragment": fragment, "containerId": int(containerViewId) if isinstance(containerViewId, int) else 0, "tag": tag, }) if tag: fragment._mTag = tag return self def replace(self, containerViewId: int, fragment: Fragment, tag: Optional[str] = None) -> "FragmentTransaction": self._ops.append({ "op": _OP_REPLACE, "fragment": fragment, "containerId": containerViewId, "tag": tag, }) if tag: fragment._mTag = tag return self def remove(self, fragment: Fragment) -> "FragmentTransaction": self._ops.append({"op": _OP_REMOVE, "fragment": fragment}) return self def hide(self, fragment: Fragment) -> "FragmentTransaction": self._ops.append({"op": _OP_HIDE, "fragment": fragment}) return self def show(self, fragment: Fragment) -> "FragmentTransaction": self._ops.append({"op": _OP_SHOW, "fragment": fragment}) return self def detach(self, fragment: Fragment) -> "FragmentTransaction": self._ops.append({"op": _OP_DETACH, "fragment": fragment}) return self def attach(self, fragment: Fragment) -> "FragmentTransaction": self._ops.append({"op": _OP_ATTACH, "fragment": fragment}) return self def setPrimaryNavigationFragment(self, fragment: Fragment) -> "FragmentTransaction": self._ops.append({"op": _OP_SET_PRIMARY_NAV, "fragment": fragment}) return self def addToBackStack(self, name: Optional[str] = None) -> "FragmentTransaction": self._add_to_back_stack = True self._name = name return self def setTransition(self, transit: int) -> "FragmentTransaction": self._transition = transit return self def setTransitionStyle(self, styleRes: int) -> "FragmentTransaction": self._transition_style = styleRes return self def setAllowOptimization(self, allow: bool) -> "FragmentTransaction": self._is_reordering_allowed = allow return self def setReorderingAllowed(self, allowed: bool) -> "FragmentTransaction": self._is_reordering_allowed = allowed return self def setBreadCrumbTitle(self, titleOrRes: Any) -> "FragmentTransaction": if isinstance(titleOrRes, int): self._bread_crumb_title_res = titleOrRes else: self._bread_crumb_title = str(titleOrRes) return self def runOnCommit(self, runnable: Callable[[], None]) -> "FragmentTransaction": self._mCommitListener = runnable return self def commit(self) -> int: with self._manager._lock: entry_id = self._manager._next_index self._manager._next_index += 1 self._commit_ops() if self._add_to_back_stack: self._manager._back_stack.append(self) return entry_id def commitNow(self) -> None: self.commit() def commitAllowingStateLoss(self) -> int: return self.commit() def _commit_ops(self) -> None: for op in self._ops: frag = op["fragment"] tag = op.get("tag") or frag._mTag if op["op"] == _OP_ADD or op["op"] == _OP_REPLACE: if tag: self._manager._fragments[tag] = frag frag._mFragmentManager = self._manager elif op["op"] == _OP_REMOVE: if tag and tag in self._manager._fragments: del self._manager._fragments[tag] elif op["op"] == _OP_SET_PRIMARY_NAV: self._manager._primary_nav_fragment = frag def _reverse(self) -> None: for op in reversed(self._ops): frag = op["fragment"] tag = frag._mTag if op["op"] == _OP_ADD: if tag and tag in self._manager._fragments: del self._manager._fragments[tag] elif op["op"] == _OP_REMOVE: if tag: self._manager._fragments[tag] = frag def toString(self) -> str: return f"FragmentTransaction(ops={len(self._ops)}, backstack={self._add_to_back_stack})" # ═══════════════════════════════════════════════════════════════ # FragmentActivity # ═══════════════════════════════════════════════════════════════ class FragmentActivity(Stub): """FragmentActivity — 支持 Fragment 的 Activity""" def __init__(self): super().__init__() self._mFragments: FragmentController = FragmentController(FragmentManager()) self._mFragmentManager: FragmentManager = FragmentManager() self._mCreated = False self._mResumed = False self._mStarted = False def getSupportFragmentManager(self) -> FragmentManager: return self._mFragmentManager def getSupportFragmentManager(self) -> FragmentManager: return self._mFragments.getFragmentManager() def onAttachFragment(self, fragment: Fragment) -> None: pass def supportInvalidateOptionsMenu(self) -> None: pass def dump(self, prefix: str, fd: Any, writer: Any, args: List[str]) -> None: pass def getLifecycle(self) -> Optional[Any]: return None def getViewModelStore(self) -> Optional[Any]: return None def toString(self) -> str: return f"FragmentActivity@{hex(id(self))}" # ═══════════════════════════════════════════════════════════════ # FragmentController # ═══════════════════════════════════════════════════════════════ class FragmentController(Stub): """FragmentController — 片段控制器""" def __init__(self, manager: FragmentManager): super().__init__() self._manager = manager def getFragmentManager(self) -> FragmentManager: return self._manager def execPendingActions(self) -> None: pass def doLoaderStart(self) -> None: pass def doLoaderStop(self, retain: bool) -> None: pass def doLoaderRetain(self) -> None: pass def doLoaderDestroy(self) -> None: pass def noteStateNotSaved(self) -> None: pass def saveAllState(self) -> Optional[Any]: return None def restoreAllState(self, state: Any) -> None: pass def createLoader(self, id: int, bundle: Any, callback: Any) -> Any: return None def dispatchCreate(self) -> None: pass def dispatchActivityCreated(self) -> None: pass def dispatchStart(self) -> None: pass def dispatchResume(self) -> None: pass def dispatchPause(self) -> None: pass def dispatchStop(self) -> None: pass def dispatchDestroy(self) -> None: pass def dispatchMultiWindowModeChanged(self, isInMultiWindowMode: bool, newConfig: Any) -> None: pass def dispatchPictureInPictureModeChanged(self, isInPictureInPictureMode: bool, newConfig: Any) -> None: pass def dispatchConfigurationChanged(self, newConfig: Any) -> None: pass def dispatchLowMemory(self) -> None: pass def toString(self) -> str: return f"FragmentController(manager={self._manager})" # ═══════════════════════════════════════════════════════════════ # FragmentHostCallback # ═══════════════════════════════════════════════════════════════ class FragmentHostCallback(Stub): """FragmentHostCallback — 片段宿主的回调基类""" def __init__(self, context: Any = None, fragmentManager: Any = None, loaderManager: Any = None): super().__init__() self._context = context self._fragmentManager = fragmentManager self._loaderManager = loaderManager def onStartLoadingFragment(self, fragment: Fragment) -> None: pass def onDump(self, prefix: str, fd: Any, writer: Any, args: List[str]) -> None: pass def onShouldShowRequestPermissionRationale(self, permission: str) -> bool: return True def onGetLayoutInflater(self) -> Any: return None def onFindViewById(self, id: int) -> Optional[Any]: return None def onHasView(self) -> bool: return False def onGetWindowAnimations(self) -> int: return 0 def onHasWindowAnimations(self) -> bool: return False def onGetActivityResultRegistry(self) -> Any: return None def onAttachFragment(self, fragment: Fragment) -> None: pass def onGetHostIdentifier(self) -> Any: return None def onValidateRequestPermissionsRequestCode(self, requestCode: int) -> None: pass def toString(self) -> str: return f"FragmentHostCallback@{hex(id(self))}" # ═══════════════════════════════════════════════════════════════ # FragmentContainer # ═══════════════════════════════════════════════════════════════ class FragmentContainer(Stub): """FragmentContainer — 片段容器接口""" def __init__(self): super().__init__() def instantiate(self, context: Any, className: str, arguments: Optional[Any] = None) -> Fragment: return Fragment() def onFindViewById(self, id: int) -> Optional[Any]: return None def onHasView(self) -> bool: return False def toString(self) -> str: return f"FragmentContainer@{hex(id(self))}" # ═══════════════════════════════════════════════════════════════ # DialogFragment # ═══════════════════════════════════════════════════════════════ class DialogFragment(Fragment): """DialogFragment — 对话框片段""" STYLE_NORMAL = 0 STYLE_NO_TITLE = 1 STYLE_NO_FRAME = 2 STYLE_NO_INPUT = 3 def __init__(self): super().__init__() self._dialog: Optional[Any] = None self._style = DialogFragment.STYLE_NORMAL self._theme = 0 self._cancelable = True self._showing = False self._dismissed = False self._dismissed_by_nav = False self._shows_dialog = True self._mBackStackId = -1 self._mDialogCanceled = False def setStyle(self, style: int, theme: int = 0) -> None: self._style = style self._theme = theme def show(self, manager: FragmentManager, tag: str) -> None: self._showing = True manager.beginTransaction().add(self, tag).commit() def showNow(self, manager: FragmentManager, tag: str) -> None: self.show(manager, tag) def dismiss(self) -> None: self._dismissed = True fm = self.getFragmentManager() if fm: fm.beginTransaction().remove(self).commit() def dismissAllowingStateLoss(self) -> None: self.dismiss() def getDialog(self) -> Optional[Any]: return self._dialog def getTheme(self) -> int: return self._theme def setCancelable(self, cancelable: bool) -> None: self._cancelable = cancelable def isCancelable(self) -> bool: return self._cancelable def setShowsDialog(self, showsDialog: bool) -> None: self._shows_dialog = showsDialog def getShowsDialog(self) -> bool: return self._shows_dialog def onDismiss(self, dialog: Any) -> None: pass def onCancel(self, dialog: Any) -> None: pass def onCreateDialog(self, savedInstanceState: Optional[Any]) -> Any: return None def toString(self) -> str: return f"DialogFragment(style={self._style}, showing={self._showing})" # ═══════════════════════════════════════════════════════════════ # ListFragment # ═══════════════════════════════════════════════════════════════ class ListFragment(Fragment): """ListFragment — 列表片段""" def __init__(self): super().__init__() self._adapter: Optional[Any] = None self._list_view: Optional[Any] = None self._selected_position = -1 self._empty_text: Optional[str] = None self._empty_view: Optional[Any] = None self._progress_container: Optional[Any] = None self._standard_empty_view = False self._list_shown = False self._list_shown_no_animation = True def getListAdapter(self) -> Optional[Any]: return self._adapter def setListAdapter(self, adapter: Any) -> None: self._adapter = adapter def getListView(self) -> Optional[Any]: return self._list_view def getSelectedItemPosition(self) -> int: return self._selected_position def getSelectedItemId(self) -> int: return 0 def setSelection(self, position: int) -> None: self._selected_position = position def setEmptyText(self, text: str) -> None: self._empty_text = text def getEmptyText(self) -> Optional[str]: return self._empty_text def listViewScrollToTop(self) -> None: pass def isListShown(self) -> bool: return self._list_shown def setListShown(self, shown: bool) -> None: self._list_shown = shown self._list_shown_no_animation = True def setListShownNoAnimation(self, shown: bool) -> None: self._list_shown = shown self._list_shown_no_animation = True def onListItemClick(self, lv: Any, v: Any, position: int, id: int) -> None: pass def onListAdapterChanged(self, adapter: Any) -> None: pass def toString(self) -> str: return f"ListFragment(list_shown={self._list_shown})" # ═══════════════════════════════════════════════════════════════ # FragmentManagerNonConfig # ═══════════════════════════════════════════════════════════════ class FragmentManagerNonConfig(Stub): """FragmentManagerNonConfig — 非配置保留片段 (已弃用)""" def __init__(self): super().__init__() self._fragments: List[Fragment] = [] self._child_non_configs: List["FragmentManagerNonConfig"] = [] self._view_model_stores: List[Any] = [] def getFragments(self) -> List[Fragment]: return list(self._fragments) def getChildNonConfigs(self) -> List["FragmentManagerNonConfig"]: return list(self._child_non_configs) def getViewModelStores(self) -> List[Any]: return list(self._view_model_stores) def toString(self) -> str: return f"FragmentManagerNonConfig(fragments={len(self._fragments)})"