@nativescript/core 9.0.0-alpha.1 → 9.0.0-alpha.11

package/ui/frame/index.android.js

@@ -1,23 +1,21 @@
-// Types.
-import { Application } from '../../application';
 import { Observable } from '../../data/observable';
 import { Trace } from '../../trace';
 import { _stack, FrameBase, NavigationType } from './frame-common';
-import { _clearEntry, _clearFragment, _getAnimatedEntries, _reverseTransitions, _setAndroidFragmentTransitions, _updateTransitions, addNativeTransitionListener } from './fragment.transitions';
+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 { ensureFragmentClass, fragmentClass } from './fragment';
-import { FragmentCallbacksImplementation } from './callbacks/fragment-callbacks';
-import { ActivityCallbacksImplementation } from './callbacks/activity-callbacks';
+import { getAppMainEntry } from '../../application/helpers-common';
+import { Application } from '../../application/application';
+import { isEmbedded, setEmbeddedView } from '../embedding';
+import { CALLBACKS, FRAMEID, framesCache, setFragmentCallbacks } from './frame-helper-for-android';
 export * from './frame-common';
 export { setFragmentClass } from './fragment';
 const INTENT_EXTRA = 'com.tns.activity';
-const FRAMEID = '_frameId';
-const CALLBACKS = '_callbacks';
 const ownerSymbol = Symbol('_owner');
+const isPendingDetachSymbol = Symbol('_isPendingDetach');
 let navDepth = -1;
 let fragmentId = -1;
-export { moduleLoaded } from './callbacks/activity-callbacks';
 export let attachStateChangeListener;
 function getAttachListener() {
     if (!attachStateChangeListener) {
@@ -41,6 +39,11 @@ function getAttachListener() {
                 if (owner) {
                     owner._onDetachedFromWindow();
                 }
+                if (view[isPendingDetachSymbol]) {
+                    delete view[isPendingDetachSymbol];
+                    view.removeOnAttachStateChangeListener(this);
+                    view[ownerSymbol] = null;
+                }
             },
         });
         attachStateChangeListener = new AttachListener();
@@ -53,7 +56,10 @@ export class Frame extends FrameBase {
         this._containerViewId = -1;
         this._tearDownPending = false;
         this._attachedToWindow = false;
-        this._wasReset = false;
+        /**
+         * This property indicates that the view is to be reused as a root view or has been previously disposed.
+         */
+        this._isReset = false;
         this._android = new AndroidFrame(this);
     }
     static reloadPage(context) {
@@ -62,7 +68,7 @@ export class Frame extends FrameBase {
         if (callbacks) {
             const rootView = callbacks.getRootView();
             // Handle application root module
-            const isAppRootModuleChanged = context && context.path && context.path.includes(Application.getMainEntry().moduleName) && context.type !== 'style';
+            const isAppRootModuleChanged = context && context.path && context.path.includes(getAppMainEntry().moduleName) && context.type !== 'style';
             // Reset activity content when:
             // + Application root module is changed
             // + View did not handle the change
@@ -109,8 +115,9 @@ export class Frame extends FrameBase {
             return;
         }
         this._attachedToWindow = true;
-        this._wasReset = false;
+        this._isReset = false;
         this._processNextNavigationEntry();
+        this._ensureEntryFragment();
     }
     _onDetachedFromWindow() {
         super._onDetachedFromWindow();
@@ -125,12 +132,12 @@ export class Frame extends FrameBase {
         if (!this.isLoaded || this._executingContext) {
             return;
         }
-        // in case the activity is "reset" using resetRootView we must wait for
+        // 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._wasReset && !this._attachedToWindow) {
+        if (this._isReset && !this._attachedToWindow) {
             return;
         }
         const animatedEntries = _getAnimatedEntries(this._android.frameId);
@@ -154,7 +161,7 @@ export class Frame extends FrameBase {
             // simulated navigation (NoTransition, zero duration animator) and thus the fragment immediately disappears;
             // the user only sees the animation of the entering fragment as per its specific enter animation settings.
             // NOTE: we are restoring the animation settings in Frame.setCurrent(...) as navigation completes asynchronously
-            const cachedTransitionState = getTransitionState(this._currentEntry);
+            const cachedTransitionState = _getTransitionState(this._currentEntry);
             if (cachedTransitionState) {
                 this._cachedTransitionState = cachedTransitionState;
                 this._currentEntry = null;
@@ -186,7 +193,7 @@ export class Frame extends FrameBase {
     _onRootViewReset() {
         super._onRootViewReset();
         // used to handle the "first" navigate differently on first run and on reset
-        this._wasReset = true;
+        this._isReset = true;
         // call this AFTER the super call to ensure descendants apply their rootview-reset logic first
         // i.e. in a scenario with nested frames / frame with tabview let the descendandt cleanup the inner
         // fragments first, and then cleanup the parent fragments
@@ -198,6 +205,28 @@ 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
@@ -212,15 +241,8 @@ export class Frame extends FrameBase {
                     transaction.commitAllowingStateLoss();
                 }
             }
-        }, 0);
-        super.onLoaded();
-    }
-    onUnloaded() {
-        super.onUnloaded();
-        if (typeof this._frameCreateTimeout === 'number') {
-            clearTimeout(this._frameCreateTimeout);
             this._frameCreateTimeout = null;
-        }
+        }, 0);
     }
     disposeCurrentFragment() {
         if (!this._currentEntry || !this._currentEntry.fragment || !this._currentEntry.fragment.isAdded()) {
@@ -291,7 +313,7 @@ export class Frame extends FrameBase {
         }
         // restore cached animation settings if we just completed simulated first navigation (no animation)
         if (this._cachedTransitionState) {
-            restoreTransitionState(this._currentEntry, this._cachedTransitionState);
+            _restoreTransitionState(this._cachedTransitionState);
             this._cachedTransitionState = null;
         }
         // restore original fragment transitions if we just completed replace navigation (hmr)
@@ -396,16 +418,16 @@ export class Frame extends FrameBase {
         super._removeEntry(removed);
         if (removed.fragment) {
             _clearEntry(removed);
+            removed.fragment = null;
         }
-        removed.fragment = null;
         removed.viewSavedState = null;
     }
     _disposeBackstackEntry(entry) {
         if (entry.fragment) {
             _clearFragment(entry);
+            entry.fragment = null;
         }
         entry.recreated = false;
-        entry.fragment = null;
         super._disposeBackstackEntry(entry);
     }
     createNativeView() {
@@ -420,18 +442,27 @@ export class Frame extends FrameBase {
     initNativeView() {
         super.initNativeView();
         const listener = getAttachListener();
-        this.nativeViewProtected.addOnAttachStateChangeListener(listener);
-        this.nativeViewProtected[ownerSymbol] = this;
-        this._android.rootViewGroup = this.nativeViewProtected;
+        const nativeView = this.nativeViewProtected;
+        nativeView.addOnAttachStateChangeListener(listener);
+        nativeView[ownerSymbol] = this;
+        this._android.rootViewGroup = nativeView;
         if (this._containerViewId < 0) {
             this._containerViewId = android.view.View.generateViewId();
         }
         this._android.rootViewGroup.setId(this._containerViewId);
     }
     disposeNativeView() {
+        const nativeView = this.nativeViewProtected;
         const listener = getAttachListener();
-        this.nativeViewProtected.removeOnAttachStateChangeListener(listener);
-        this.nativeViewProtected[ownerSymbol] = null;
+        // 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;
+        }
         this._tearDownPending = !!this._executingContext;
         const current = this._currentEntry;
         const executingEntry = this._executingContext ? this._executingContext.entry : null;
@@ -445,6 +476,10 @@ export class Frame extends FrameBase {
         if (current && !executingEntry) {
             this._disposeBackstackEntry(current);
         }
+        // Dispose cached transition and store it again if view ever gets re-used
+        this._cachedTransitionState = null;
+        // Mark as reset in order to properly re-initialize fragments if view ever gets re-used
+        this._isReset = true;
         this._android.rootViewGroup = null;
         this._removeFromFrameStack();
         super.disposeNativeView();
@@ -496,47 +531,7 @@ export function reloadPage(context) {
 }
 // attach on global, so it can be overwritten in NativeScript Angular
 global.__onLiveSyncCore = Frame.reloadPage;
-function cloneExpandedTransitionListener(expandedTransitionListener) {
-    if (!expandedTransitionListener) {
-        return null;
-    }
-    const cloneTransition = expandedTransitionListener.transition.clone();
-    return addNativeTransitionListener(expandedTransitionListener.entry, cloneTransition);
-}
-function getTransitionState(entry) {
-    const expandedEntry = entry;
-    const transitionState = {};
-    if (expandedEntry.enterTransitionListener && expandedEntry.exitTransitionListener) {
-        transitionState.enterTransitionListener = cloneExpandedTransitionListener(expandedEntry.enterTransitionListener);
-        transitionState.exitTransitionListener = cloneExpandedTransitionListener(expandedEntry.exitTransitionListener);
-        transitionState.reenterTransitionListener = cloneExpandedTransitionListener(expandedEntry.reenterTransitionListener);
-        transitionState.returnTransitionListener = cloneExpandedTransitionListener(expandedEntry.returnTransitionListener);
-        transitionState.transitionName = expandedEntry.transitionName;
-        transitionState.entry = entry;
-    }
-    else {
-        return null;
-    }
-    return transitionState;
-}
-function restoreTransitionState(entry, snapshot) {
-    const expandedEntry = entry;
-    if (snapshot.enterTransitionListener) {
-        expandedEntry.enterTransitionListener = snapshot.enterTransitionListener;
-    }
-    if (snapshot.exitTransitionListener) {
-        expandedEntry.exitTransitionListener = snapshot.exitTransitionListener;
-    }
-    if (snapshot.reenterTransitionListener) {
-        expandedEntry.reenterTransitionListener = snapshot.reenterTransitionListener;
-    }
-    if (snapshot.returnTransitionListener) {
-        expandedEntry.returnTransitionListener = snapshot.returnTransitionListener;
-    }
-    expandedEntry.transitionName = snapshot.transitionName;
-}
 let framesCounter = 0;
-const framesCache = new Array();
 class AndroidFrame extends Observable {
     constructor(owner) {
         super();
@@ -622,20 +617,301 @@ function startActivity(activity, frameId) {
     // TODO: Put the navigation context (if any) in the intent
     activity.startActivity(intent);
 }
-export function getFrameByNumberId(frameId) {
-    // Find the frame for this activity.
-    for (let i = 0; i < framesCache.length; i++) {
-        const aliveFrame = framesCache[i].get();
-        if (aliveFrame && aliveFrame.frameId === frameId) {
-            return aliveFrame.owner;
+const activityRootViewsMap = new Map();
+const ROOT_VIEW_ID_EXTRA = 'com.tns.activity.rootViewId';
+export let moduleLoaded;
+export class ActivityCallbacksImplementation {
+    getRootView() {
+        return this._rootView;
+    }
+    onCreate(activity, savedInstanceState, intentOrSuperFunc, superFunc) {
+        if (Trace.isEnabled()) {
+            Trace.write(`Activity.onCreate(${savedInstanceState})`, Trace.categories.NativeLifecycle);
+        }
+        const intent = superFunc ? intentOrSuperFunc : undefined;
+        if (!superFunc) {
+            console.log('AndroidActivityCallbacks.onCreate(activity: any, savedInstanceState: any, superFunc: Function) ' + 'is deprecated. Use AndroidActivityCallbacks.onCreate(activity: any, savedInstanceState: any, intent: any, superFunc: Function) instead.');
+            superFunc = intentOrSuperFunc;
+        }
+        // If there is savedInstanceState this call will recreate all fragments that were previously in the navigation.
+        // We take care of associating them with a Page from our backstack in the onAttachFragment callback.
+        // If there is savedInstanceState and moduleLoaded is false we are restarted but process was killed.
+        // For now we treat it like first run (e.g. we are not passing savedInstanceState so no fragments are being restored).
+        // When we add support for application save/load state - revise this logic.
+        const isRestart = !!savedInstanceState && moduleLoaded;
+        superFunc.call(activity, isRestart ? savedInstanceState : null);
+        // Try to get the rootViewId form the saved state in case the activity
+        // was destroyed and we are now recreating it.
+        if (savedInstanceState) {
+            const rootViewId = savedInstanceState.getInt(ROOT_VIEW_ID_EXTRA, -1);
+            if (rootViewId !== -1 && activityRootViewsMap.has(rootViewId)) {
+                this._rootView = activityRootViewsMap.get(rootViewId)?.get();
+            }
+        }
+        if (intent && intent.getAction()) {
+            Application.android.notify({
+                eventName: Application.AndroidApplication.activityNewIntentEvent,
+                object: Application.android,
+                activity,
+                intent,
+            });
+        }
+        this.setActivityContent(activity, savedInstanceState, true);
+        moduleLoaded = true;
+    }
+    onSaveInstanceState(activity, outState, superFunc) {
+        superFunc.call(activity, outState);
+        const rootView = this._rootView;
+        if (rootView instanceof Frame) {
+            outState.putInt(INTENT_EXTRA, rootView.android.frameId);
+            rootView._saveFragmentsState();
+        }
+        if (rootView) {
+            outState.putInt(ROOT_VIEW_ID_EXTRA, rootView._domId);
+        }
+    }
+    onNewIntent(activity, intent, superSetIntentFunc, superFunc) {
+        superFunc.call(activity, intent);
+        superSetIntentFunc.call(activity, intent);
+        Application.android.notify({
+            eventName: Application.AndroidApplication.activityNewIntentEvent,
+            object: Application.android,
+            activity,
+            intent,
+        });
+    }
+    onStart(activity, superFunc) {
+        superFunc.call(activity);
+        if (Trace.isEnabled()) {
+            Trace.write('NativeScriptActivity.onStart();', Trace.categories.NativeLifecycle);
+        }
+        const rootView = this._rootView;
+        if (rootView && !rootView.isLoaded && !isEmbedded()) {
+            rootView.callLoaded();
+        }
+    }
+    onStop(activity, superFunc) {
+        superFunc.call(activity);
+        if (Trace.isEnabled()) {
+            Trace.write('NativeScriptActivity.onStop();', Trace.categories.NativeLifecycle);
+        }
+        const rootView = this._rootView;
+        if (rootView && rootView.isLoaded && !isEmbedded()) {
+            rootView.callUnloaded();
+        }
+    }
+    onPostResume(activity, superFunc) {
+        superFunc.call(activity);
+        if (Trace.isEnabled()) {
+            Trace.write('NativeScriptActivity.onPostResume();', Trace.categories.NativeLifecycle);
+        }
+        // NOTE: activity.onPostResume() is called when activity resume is complete and we can
+        // safely raise the application resume event;
+        // onActivityResumed(...) lifecycle callback registered in application is called too early
+        // and raising the application resume event there causes issues like
+        // https://github.com/NativeScript/NativeScript/issues/6708
+        if (activity.isNativeScriptActivity) {
+            Application.setSuspended(false, {
+                // todo: deprecate in favor of using event.activity instead.
+                android: activity,
+                activity,
+            });
         }
     }
-    return null;
+    onDestroy(activity, superFunc) {
+        try {
+            if (Trace.isEnabled()) {
+                Trace.write('NativeScriptActivity.onDestroy();', Trace.categories.NativeLifecycle);
+            }
+            const rootView = this._rootView;
+            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);
+        }
+    }
+    onBackPressed(activity, superFunc) {
+        if (Trace.isEnabled()) {
+            Trace.write('NativeScriptActivity.onBackPressed;', Trace.categories.NativeLifecycle);
+        }
+        const args = {
+            eventName: 'activityBackPressed',
+            object: Application,
+            android: Application.android,
+            activity: activity,
+            cancel: false,
+        };
+        Application.android.notify(args);
+        if (args.cancel) {
+            return;
+        }
+        const view = this._rootView;
+        let callSuper = false;
+        const viewArgs = {
+            eventName: 'activityBackPressed',
+            object: view,
+            activity: activity,
+            cancel: false,
+        };
+        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;
+        }
+        if (callSuper) {
+            superFunc.call(activity);
+        }
+    }
+    onRequestPermissionsResult(activity, requestCode, permissions, grantResults, superFunc) {
+        if (Trace.isEnabled()) {
+            Trace.write('NativeScriptActivity.onRequestPermissionsResult;', Trace.categories.NativeLifecycle);
+        }
+        Application.android.notify({
+            eventName: 'activityRequestPermissions',
+            object: Application,
+            android: Application.android,
+            activity: activity,
+            requestCode: requestCode,
+            permissions: permissions,
+            grantResults: grantResults,
+        });
+    }
+    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',
+            object: Application,
+            android: Application.android,
+            activity: activity,
+            requestCode: requestCode,
+            resultCode: resultCode,
+            intent: data,
+        });
+    }
+    resetActivityContent(activity) {
+        if (this._rootView) {
+            const manager = this._rootView._getFragmentManager();
+            manager.executePendingTransactions();
+            this._rootView._onRootViewReset();
+        }
+        // Delete previously cached root view in order to recreate it.
+        this._rootView = null;
+        this.setActivityContent(activity, null, false);
+        this._rootView.callLoaded();
+    }
+    // Paths that go trough this method:
+    // 1. Application initial start - there is no rootView in callbacks.
+    // 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;
+        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, {
+            // todo: deprecate in favor of args.intent?
+            android: intent,
+            intent,
+            savedInstanceState,
+        });
+        if (!rootView) {
+            // no root view created
+            return;
+        }
+        activityRootViewsMap.set(rootView._domId, new WeakRef(rootView));
+        // setup view as styleScopeHost
+        rootView._setupAsRootView(activity);
+        if (isEmbedded()) {
+            setEmbeddedView(rootView);
+        }
+        else {
+            activity.setContentView(rootView.nativeViewProtected, new org.nativescript.widgets.CommonLayoutParams());
+        }
+        this._rootView = rootView;
+        // sets root classes once rootView is ready...
+        Application.initRootView(rootView);
+    }
 }
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [androidx.appcompat.app.AppCompatActivity, android.os.Bundle, Object, Function]),
+    __metadata("design:returntype", void 0)
+], ActivityCallbacksImplementation.prototype, "onCreate", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [androidx.appcompat.app.AppCompatActivity, android.os.Bundle, Function]),
+    __metadata("design:returntype", void 0)
+], ActivityCallbacksImplementation.prototype, "onSaveInstanceState", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [androidx.appcompat.app.AppCompatActivity, android.content.Intent, Function, Function]),
+    __metadata("design:returntype", void 0)
+], ActivityCallbacksImplementation.prototype, "onNewIntent", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Function]),
+    __metadata("design:returntype", void 0)
+], ActivityCallbacksImplementation.prototype, "onStart", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Function]),
+    __metadata("design:returntype", void 0)
+], ActivityCallbacksImplementation.prototype, "onStop", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Function]),
+    __metadata("design:returntype", void 0)
+], ActivityCallbacksImplementation.prototype, "onPostResume", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Function]),
+    __metadata("design:returntype", void 0)
+], ActivityCallbacksImplementation.prototype, "onDestroy", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Function]),
+    __metadata("design:returntype", void 0)
+], ActivityCallbacksImplementation.prototype, "onBackPressed", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, Array, Array, Function]),
+    __metadata("design:returntype", void 0)
+], ActivityCallbacksImplementation.prototype, "onRequestPermissionsResult", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, Number, android.content.Intent, Function]),
+    __metadata("design:returntype", void 0)
+], ActivityCallbacksImplementation.prototype, "onActivityResult", null);
 export function setActivityCallbacks(activity) {
     activity[CALLBACKS] = new ActivityCallbacksImplementation();
 }
-export function setFragmentCallbacks(fragment) {
-    fragment[CALLBACKS] = new FragmentCallbacksImplementation();
-}
 //# sourceMappingURL=index.android.js.map