@nativescript/core 9.1.0-dev.0 → 9.1.0-next.0

package/ui/frame/index.android.d.ts

@@ -1,4 +1,4 @@
-import type { AndroidActivityCallbacks, AndroidFrame as AndroidFrameDefinition, NavigationTransition } from '.';
+import type { AndroidActivityCallbacks, Frame as FrameDefinition, AndroidFrame as AndroidFrameDefinition, NavigationTransition } from '.';
 import type { BackstackEntry } from './frame-interfaces';
 import type { Page } from '../page';
 import { Observable } from '../../data/observable';
@@ -21,7 +21,6 @@ export declare class Frame extends FrameBase {
      */
     private _isReset;
     private _cachedTransitionState;
-    private _frameCreateTimeout;
     constructor();
     static reloadPage(context?: ModuleContext): void;
     static get defaultAnimatedNavigation(): boolean;
@@ -37,11 +36,6 @@ export declare class Frame extends FrameBase {
     _getChildFragmentManager(): any;
     _onRootViewReset(): void;
     onLoaded(): void;
-    onUnloaded(): void;
-    /**
-     * TODO: Check if this fragment precaution is still needed
-     */
-    private _ensureEntryFragment;
     private disposeCurrentFragment;
     private createFragment;
     setCurrent(entry: BackstackEntry, navigationType: NavigationType): void;
@@ -55,21 +49,22 @@ export declare class Frame extends FrameBase {
     disposeNativeView(): void;
     _popFromFrameStack(): void;
     _getNavBarVisible(page: Page): boolean;
+    _restoreTransitionState(): void;
     _saveFragmentsState(): void;
 }
 export declare function reloadPage(context?: ModuleContext): void;
 declare class AndroidFrame extends Observable implements AndroidFrameDefinition {
     rootViewGroup: android.view.ViewGroup;
-    frameId: any;
+    readonly frameId: number;
     private _showActionBar;
-    private _owner;
-    constructor(owner: Frame);
+    private readonly _owner;
+    constructor(owner: FrameDefinition);
     get showActionBar(): boolean;
     set showActionBar(value: boolean);
     get activity(): androidx.appcompat.app.AppCompatActivity;
     get actionBar(): android.app.ActionBar;
     get currentActivity(): androidx.appcompat.app.AppCompatActivity;
-    get owner(): Frame;
+    get owner(): FrameDefinition;
     canGoBack(): boolean;
     fragmentForPage(entry: BackstackEntry): any;
 }
@@ -87,7 +82,7 @@ export declare class ActivityCallbacksImplementation implements AndroidActivityC
     onBackPressed(activity: any, superFunc: Function): void;
     onRequestPermissionsResult(activity: any, requestCode: number, permissions: Array<string>, grantResults: Array<number>, superFunc: Function): void;
     onActivityResult(activity: any, requestCode: number, resultCode: number, data: android.content.Intent, superFunc: Function): void;
-    resetActivityContent(activity: androidx.appcompat.app.AppCompatActivity): void;
+    resetActivityContent(activity: androidx.appcompat.app.AppCompatActivity, view?: View): void;
     private setActivityContent;
 }
 export declare function setActivityCallbacks(activity: androidx.appcompat.app.AppCompatActivity): void;

package/ui/frame/index.android.js

@@ -3,10 +3,12 @@ import { Trace } from '../../trace';
 import { _stack, FrameBase, NavigationType } from './frame-common';
 import { _clearEntry, _clearFragment, _getAnimatedEntries, _getTransitionState, _restoreTransitionState, _reverseTransitions, _setAndroidFragmentTransitions, _updateTransitions } from './fragment.transitions';
 import { profile } from '../../profiling';
-import { android as androidUtils } from '../../utils/native-helper';
+import { android as androidUtils, dataDeserialize } from '../../utils/native-helper';
 import { ensureFragmentClass, fragmentClass } from './fragment';
 import { getAppMainEntry } from '../../application/helpers-common';
 import { Application } from '../../application/application';
+import { NativeWindowEvents } from '../../native-window/native-window-interfaces';
+import { AndroidNativeWindow } from '../../native-window/native-window.android';
 import { isEmbedded, setEmbeddedView } from '../embedding';
 import { CALLBACKS, FRAMEID, framesCache, setFragmentCallbacks } from './frame-helper-for-android';
 import { SDK_VERSION } from '../../utils';
@@ -14,7 +16,6 @@ export * from './frame-common';
 export { setFragmentClass } from './fragment';
 const INTENT_EXTRA = 'com.tns.activity';
 const ownerSymbol = Symbol('_owner');
-const isPendingDetachSymbol = Symbol('_isPendingDetach');
 let navDepth = -1;
 let fragmentId = -1;
 export let attachStateChangeListener;
@@ -40,11 +41,6 @@ function getAttachListener() {
                 if (owner) {
                     owner._onDetachedFromWindow();
                 }
-                if (view[isPendingDetachSymbol]) {
-                    delete view[isPendingDetachSymbol];
-                    view.removeOnAttachStateChangeListener(this);
-                    view[ownerSymbol] = null;
-                }
             },
         });
         attachStateChangeListener = new AttachListener();
@@ -119,7 +115,6 @@ export class Frame extends FrameBase {
         this._attachedToWindow = true;
         this._isReset = false;
         this._processNextNavigationEntry();
-        this._ensureEntryFragment();
     }
     _onDetachedFromWindow() {
         super._onDetachedFromWindow();
@@ -167,7 +162,7 @@ export class Frame extends FrameBase {
             if (cachedTransitionState) {
                 this._cachedTransitionState = cachedTransitionState;
                 this._currentEntry = null;
-                // NavigateCore will eventually call _processNextNavigationEntry again.
+                // NavigateCore will eventually call _processNextNavigationEntry again
                 this._navigateCore(entry);
                 this._currentEntry = entry;
             }
@@ -207,45 +202,8 @@ export class Frame extends FrameBase {
             this.backgroundColor = this._originalBackground;
             this._originalBackground = null;
         }
-        this._ensureEntryFragment();
         super.onLoaded();
     }
-    onUnloaded() {
-        super.onUnloaded();
-        if (typeof this._frameCreateTimeout === 'number') {
-            clearTimeout(this._frameCreateTimeout);
-            this._frameCreateTimeout = null;
-        }
-    }
-    /**
-     * TODO: Check if this fragment precaution is still needed
-     */
-    _ensureEntryFragment() {
-        // in case the activity is "reset" using resetRootView or disposed we must wait for
-        // the attachedToWindow event to make the first navigation or it will crash
-        // https://github.com/NativeScript/NativeScript/commit/9dd3e1a8076e5022e411f2f2eeba34aabc68d112
-        // though we should not do it on app "start"
-        // or it will create a "flash" to activity background color
-        if (this._isReset && !this._attachedToWindow) {
-            return;
-        }
-        this._frameCreateTimeout = setTimeout(() => {
-            // there's a bug with nested frames where sometimes the nested fragment is not recreated at all
-            // so we manually check on loaded event if the fragment is not recreated and recreate it
-            const currentEntry = this._currentEntry || this._executingContext?.entry;
-            if (currentEntry) {
-                if (!currentEntry.fragment) {
-                    const manager = this._getFragmentManager();
-                    const transaction = manager.beginTransaction();
-                    currentEntry.fragment = this.createFragment(currentEntry, currentEntry.fragmentTag);
-                    _updateTransitions(currentEntry);
-                    transaction.replace(this.containerViewId, currentEntry.fragment, currentEntry.fragmentTag);
-                    transaction.commitAllowingStateLoss();
-                }
-            }
-            this._frameCreateTimeout = null;
-        }, 0);
-    }
     disposeCurrentFragment() {
         if (!this._currentEntry || !this._currentEntry.fragment || !this._currentEntry.fragment.isAdded()) {
             return;
@@ -313,11 +271,8 @@ export class Frame extends FrameBase {
             // Continue with next item in the queue.
             this._processNextNavigationEntry();
         }
-        // restore cached animation settings if we just completed simulated first navigation (no animation)
-        if (this._cachedTransitionState) {
-            _restoreTransitionState(this._cachedTransitionState);
-            this._cachedTransitionState = null;
-        }
+        // Restore cached animation settings if we just completed simulated first navigation (no animation)
+        this._restoreTransitionState();
         // restore original fragment transitions if we just completed replace navigation (hmr)
         if (navigationType === NavigationType.replace) {
             _clearEntry(entry);
@@ -382,7 +337,7 @@ export class Frame extends FrameBase {
         // layout pass so we will wait forever for transitionCompleted handler...
         // https://github.com/NativeScript/NativeScript/issues/4895
         let navigationTransition;
-        if (this._currentEntry) {
+        if (currentEntry) {
             navigationTransition = this._getNavigationTransition(newEntry.entry);
         }
         else {
@@ -456,14 +411,12 @@ export class Frame extends FrameBase {
     disposeNativeView() {
         const nativeView = this.nativeViewProtected;
         const listener = getAttachListener();
-        // There are cases like root view when detach listener is not called upon removing view from view-tree
-        // so mark those views as pending and remove listener once the view is detached
-        if (nativeView.isAttachedToWindow()) {
-            nativeView[isPendingDetachSymbol] = true;
-        }
-        else {
-            nativeView.removeOnAttachStateChangeListener(listener);
-            nativeView[ownerSymbol] = null;
+        nativeView.removeOnAttachStateChangeListener(listener);
+        nativeView[ownerSymbol] = null;
+        // There are cases like root view when detach listener is not called before the native view gets disposed
+        // so call detach method directly for these views
+        if (this._attachedToWindow) {
+            this._onDetachedFromWindow();
         }
         this._tearDownPending = !!this._executingContext;
         const current = this._currentEntry;
@@ -508,6 +461,12 @@ export class Frame extends FrameBase {
                 return true;
         }
     }
+    _restoreTransitionState() {
+        if (this._cachedTransitionState) {
+            _restoreTransitionState(this._cachedTransitionState);
+            this._cachedTransitionState = null;
+        }
+    }
     _saveFragmentsState() {
         // We save only fragments in backstack.
         // Current fragment is saved by FragmentManager.
@@ -634,13 +593,22 @@ if (SDK_VERSION >= 33) {
                 this.setEnabled(false);
                 return;
             }
+            const nativeWindow = Application.android._getWindowForActivity(activity);
             const args = {
-                eventName: 'activityBackPressed',
+                eventName: NativeWindowEvents.activityBackPressed,
                 object: Application,
                 android: Application.android,
+                window: nativeWindow,
                 activity: activity,
                 cancel: false,
             };
+            // Emit on NativeWindow first
+            if (nativeWindow) {
+                nativeWindow.notify({
+                    ...args,
+                    object: nativeWindow,
+                });
+            }
             Application.android.notify(args);
             if (args.cancel) {
                 return;
@@ -651,7 +619,7 @@ if (SDK_VERSION >= 33) {
                 const view = callbacks.getRootView();
                 if (view) {
                     const viewArgs = {
-                        eventName: 'activityBackPressed',
+                        eventName: NativeWindowEvents.activityBackPressed,
                         object: view,
                         activity: activity,
                         cancel: false,
@@ -659,7 +627,7 @@ if (SDK_VERSION >= 33) {
                     view.notify(viewArgs);
                     // In the case of Frame, use this callback only if it was overridden, since the original will cause navigation issues
                     if (!viewArgs.cancel && (view.onBackPressed === Frame.prototype.onBackPressed || !view.onBackPressed())) {
-                        callSuper = view instanceof Frame ? !Frame.goBack() : true;
+                        callSuper = view instanceof Frame ? !Frame.goBack(view) : true;
                     }
                 }
             }
@@ -694,6 +662,34 @@ export class ActivityCallbacksImplementation {
         // When we add support for application save/load state - revise this logic.
         const isRestart = !!savedInstanceState && moduleLoaded;
         superFunc.call(activity, isRestart ? savedInstanceState : null);
+        if (isRestart && activity.getSupportFragmentManager) {
+            // Remove restored fragments that NativeScript will recreate via _setupUI/createNativeView.
+            // NativeScript tears down and rebuilds the entire view tree on activity recreation,
+            // so restored fragments (especially from ViewPager2/tabs) become orphaned without views.
+            // NativeScript core's own fragments use tags like "fragment{id}[{depth}]" and are
+            // handled by _processNextNavigationEntry. We remove all non-NativeScript fragments.
+            const fm = activity.getSupportFragmentManager();
+            const fragments = fm.getFragments();
+            const size = fragments?.size?.() ?? 0;
+            if (size > 0) {
+                const ft = fm.beginTransaction();
+                let removed = false;
+                for (let i = size - 1; i >= 0; i--) {
+                    const f = fragments.get(i);
+                    if (!f)
+                        continue;
+                    const tag = f.getTag();
+                    if (tag && tag.startsWith('fragment')) {
+                        continue;
+                    }
+                    ft.remove(f);
+                    removed = true;
+                }
+                if (removed) {
+                    ft.commitNowAllowingStateLoss();
+                }
+            }
+        }
         // Try to get the rootViewId form the saved state in case the activity
         // was destroyed and we are now recreating it.
         if (savedInstanceState) {
@@ -703,12 +699,22 @@ export class ActivityCallbacksImplementation {
             }
         }
         if (intent && intent.getAction()) {
-            Application.android.notify({
-                eventName: Application.AndroidApplication.activityNewIntentEvent,
+            const nativeWindow = Application.android._getWindowForActivity(activity);
+            const newIntentArgs = {
+                eventName: NativeWindowEvents.activityNewIntent,
                 object: Application.android,
+                window: nativeWindow,
                 activity,
                 intent,
-            });
+            };
+            // Emit on NativeWindow first
+            if (nativeWindow) {
+                nativeWindow.notify({
+                    ...newIntentArgs,
+                    object: nativeWindow,
+                });
+            }
+            Application.android.notify(newIntentArgs);
         }
         this.setActivityContent(activity, savedInstanceState, true);
         moduleLoaded = true;
@@ -727,12 +733,22 @@ export class ActivityCallbacksImplementation {
     onNewIntent(activity, intent, superSetIntentFunc, superFunc) {
         superFunc.call(activity, intent);
         superSetIntentFunc.call(activity, intent);
-        Application.android.notify({
-            eventName: Application.AndroidApplication.activityNewIntentEvent,
+        const nativeWindow = Application.android._getWindowForActivity(activity);
+        const newIntentArgs = {
+            eventName: NativeWindowEvents.activityNewIntent,
             object: Application.android,
+            window: nativeWindow,
             activity,
             intent,
-        });
+        };
+        // Emit on NativeWindow first
+        if (nativeWindow) {
+            nativeWindow.notify({
+                ...newIntentArgs,
+                object: nativeWindow,
+            });
+        }
+        Application.android.notify(newIntentArgs);
     }
     onStart(activity, superFunc) {
         superFunc.call(activity);
@@ -781,18 +797,6 @@ export class ActivityCallbacksImplementation {
             if (rootView) {
                 rootView._tearDownUI(true);
             }
-            // this may happen when the user changes the system theme
-            // In such case, isFinishing() is false (and isChangingConfigurations is true), and the app will start again (onCreate) with a savedInstanceState
-            // as a result, launchEvent will never be called
-            // possible alternative: always fire launchEvent and exitEvent, but pass extra flags to make it clear what kind of launch/destroy is happening
-            if (activity.isFinishing()) {
-                const exitArgs = {
-                    eventName: Application.exitEvent,
-                    object: Application.android,
-                    android: activity,
-                };
-                Application.notify(exitArgs);
-            }
         }
         finally {
             superFunc.call(activity);
@@ -802,13 +806,22 @@ export class ActivityCallbacksImplementation {
         if (Trace.isEnabled()) {
             Trace.write('NativeScriptActivity.onBackPressed;', Trace.categories.NativeLifecycle);
         }
+        const nativeWindow = Application.android._getWindowForActivity(activity);
         const args = {
-            eventName: 'activityBackPressed',
+            eventName: NativeWindowEvents.activityBackPressed,
             object: Application,
             android: Application.android,
+            window: nativeWindow,
             activity: activity,
             cancel: false,
         };
+        // Emit on NativeWindow first
+        if (nativeWindow) {
+            nativeWindow.notify({
+                ...args,
+                object: nativeWindow,
+            });
+        }
         Application.android.notify(args);
         if (args.cancel) {
             return;
@@ -816,7 +829,7 @@ export class ActivityCallbacksImplementation {
         const view = this._rootView;
         let callSuper = false;
         const viewArgs = {
-            eventName: 'activityBackPressed',
+            eventName: NativeWindowEvents.activityBackPressed,
             object: view,
             activity: activity,
             cancel: false,
@@ -824,7 +837,7 @@ export class ActivityCallbacksImplementation {
         view.notify(viewArgs);
         // In the case of Frame, use this callback only if it was overridden, since the original will cause navigation issues
         if (!viewArgs.cancel && (view.onBackPressed === Frame.prototype.onBackPressed || !view.onBackPressed())) {
-            callSuper = view instanceof Frame ? !Frame.goBack() : true;
+            callSuper = view instanceof Frame ? !Frame.goBack(view) : true;
         }
         if (callSuper) {
             superFunc.call(activity);
@@ -834,40 +847,62 @@ export class ActivityCallbacksImplementation {
         if (Trace.isEnabled()) {
             Trace.write('NativeScriptActivity.onRequestPermissionsResult;', Trace.categories.NativeLifecycle);
         }
-        Application.android.notify({
-            eventName: 'activityRequestPermissions',
+        const nativeWindow = Application.android._getWindowForActivity(activity);
+        const permArgs = {
+            eventName: NativeWindowEvents.activityRequestPermissions,
             object: Application,
             android: Application.android,
+            window: nativeWindow,
             activity: activity,
             requestCode: requestCode,
             permissions: permissions,
             grantResults: grantResults,
-        });
+        };
+        // Emit on NativeWindow first
+        if (nativeWindow) {
+            nativeWindow.notify({
+                ...permArgs,
+                object: nativeWindow,
+            });
+        }
+        Application.android.notify(permArgs);
     }
     onActivityResult(activity, requestCode, resultCode, data, superFunc) {
         superFunc.call(activity, requestCode, resultCode, data);
         if (Trace.isEnabled()) {
             Trace.write(`NativeScriptActivity.onActivityResult(${requestCode}, ${resultCode}, ${data})`, Trace.categories.NativeLifecycle);
         }
-        Application.android.notify({
-            eventName: 'activityResult',
+        const nativeWindow = Application.android._getWindowForActivity(activity);
+        const resultArgs = {
+            eventName: NativeWindowEvents.activityResult,
             object: Application,
             android: Application.android,
+            window: nativeWindow,
             activity: activity,
             requestCode: requestCode,
             resultCode: resultCode,
             intent: data,
-        });
+        };
+        // Emit on NativeWindow first
+        if (nativeWindow) {
+            nativeWindow.notify({
+                ...resultArgs,
+                object: nativeWindow,
+            });
+        }
+        Application.android.notify(resultArgs);
     }
-    resetActivityContent(activity) {
+    resetActivityContent(activity, view) {
         if (this._rootView) {
             const manager = this._rootView._getFragmentManager();
             manager.executePendingTransactions();
+            // Some flavors reuse the same root view, so unload the view in order to load it successfully when needed
+            this._rootView.callUnloaded();
             this._rootView._onRootViewReset();
         }
         // Delete previously cached root view in order to recreate it.
         this._rootView = null;
-        this.setActivityContent(activity, null, false);
+        this.setActivityContent(activity, null, false, view);
         this._rootView.callLoaded();
     }
     // Paths that go trough this method:
@@ -875,18 +910,42 @@ export class ActivityCallbacksImplementation {
     // 2. Application revived after Activity is destroyed. this._rootView should have been restored by id in onCreate.
     // 3. Livesync if rootView has no custom _onLivesync. this._rootView should have been cleared upfront. Launch event should not fired
     // 4. resetRootView method. this._rootView should have been cleared upfront. Launch event should not fired
-    setActivityContent(activity, savedInstanceState, fireLaunchEvent) {
-        let rootView = this._rootView;
+    // 5. NativeWindow.setContent - the caller supplies the view, so nothing is resolved from the main entry.
+    setActivityContent(activity, savedInstanceState, fireLaunchEvent, view) {
+        let rootView = view ?? this._rootView;
         if (Trace.isEnabled()) {
             Trace.write(`Frame.setActivityContent rootView: ${rootView} shouldCreateRootFrame: false fireLaunchEvent: ${fireLaunchEvent}`, Trace.categories.NativeLifecycle);
         }
         const intent = activity.getIntent();
-        rootView = Application.createRootView(rootView, fireLaunchEvent, {
+        const launchData = {
             // todo: deprecate in favor of args.intent?
             android: intent,
             intent,
             savedInstanceState,
-        });
+        };
+        let nativeWindow = Application.android._getWindowForActivity(activity);
+        if (!nativeWindow && isEmbedded()) {
+            // When embedded, the host owns the activity and may never install our lifecycle
+            // callbacks, so this is the only place the window can come into existence.
+            const embeddedWindow = new AndroidNativeWindow(activity, AndroidNativeWindow.newWindowId(), Application.android._getWindows().length === 0, 'embedded');
+            Application.android._registerWindow(embeddedWindow);
+            embeddedWindow._registerConfigurationCallbacks();
+            nativeWindow = embeddedWindow;
+        }
+        if (!rootView && fireLaunchEvent && nativeWindow) {
+            // This method installs the root view on the activity itself, so the resolved view is
+            // handed back rather than applied through NativeWindow.setContent(), which would
+            // re-enter here through resetActivityContent().
+            rootView = Application._resolveWindowContent(nativeWindow, {
+                window: nativeWindow,
+                isPrimary: nativeWindow.isPrimary,
+                data: dataDeserialize(intent?.getExtras()) ?? undefined,
+                android: { intent, savedInstanceState },
+            }, { install: false, launchData });
+        }
+        else {
+            rootView = Application.createRootView(rootView, fireLaunchEvent, launchData);
+        }
         if (!rootView) {
             // no root view created
             return;
@@ -902,7 +961,8 @@ export class ActivityCallbacksImplementation {
         }
         this._rootView = rootView;
         // sets root classes once rootView is ready...
-        Application.initRootView(rootView);
+        Application.initRootView(rootView, nativeWindow);
+        nativeWindow?._adoptRootView(rootView);
     }
 }
 __decorate([