mirror of
https://github.com/NativeScript/NativeScript.git
synced 2025-08-15 11:01:21 +08:00
732 lines
30 KiB
TypeScript
732 lines
30 KiB
TypeScript
/// <reference path="transition-definitions.android.d.ts"/>
|
|
|
|
// Definitions.
|
|
import { NavigationType } from "./frame-common";
|
|
import { NavigationTransition, BackstackEntry } from "../frame";
|
|
|
|
// Types.
|
|
import { Transition, AndroidTransitionType } from "../transition/transition";
|
|
import { FlipTransition } from "../transition/flip-transition";
|
|
import { _resolveAnimationCurve } from "../animation";
|
|
import lazy from "../../utils/lazy";
|
|
import { isEnabled as traceEnabled, write as traceWrite, categories as traceCategories } from "../../trace";
|
|
|
|
interface TransitionListener {
|
|
new(entry: ExpandedEntry, transition: androidx.transition.Transition): ExpandedTransitionListener;
|
|
}
|
|
|
|
const defaultInterpolator = lazy(() => new android.view.animation.AccelerateDecelerateInterpolator());
|
|
|
|
const animFadeIn = 17432576; // android.R.anim.fade_in
|
|
const animFadeOut = 17432577; // android.R.anim.fade_out
|
|
|
|
export const waitingQueue = new Map<number, Set<ExpandedEntry>>();
|
|
export const completedEntries = new Map<number, ExpandedEntry>();
|
|
|
|
let TransitionListener: TransitionListener;
|
|
let AnimationListener: android.animation.Animator.AnimatorListener;
|
|
|
|
interface ExpandedTransitionListener extends androidx.transition.Transition.TransitionListener {
|
|
entry: ExpandedEntry;
|
|
transition: androidx.transition.Transition;
|
|
}
|
|
|
|
interface ExpandedAnimator extends android.animation.Animator {
|
|
entry: ExpandedEntry;
|
|
transitionType?: string;
|
|
}
|
|
|
|
interface ExpandedEntry extends BackstackEntry {
|
|
|
|
enterTransitionListener: ExpandedTransitionListener;
|
|
exitTransitionListener: ExpandedTransitionListener;
|
|
reenterTransitionListener: ExpandedTransitionListener;
|
|
returnTransitionListener: ExpandedTransitionListener;
|
|
|
|
enterAnimator: ExpandedAnimator;
|
|
exitAnimator: ExpandedAnimator;
|
|
popEnterAnimator: ExpandedAnimator;
|
|
popExitAnimator: ExpandedAnimator;
|
|
|
|
transition: Transition;
|
|
transitionName: string;
|
|
frameId: number;
|
|
|
|
isNestedDefaultTransition: boolean;
|
|
}
|
|
|
|
export function _setAndroidFragmentTransitions(
|
|
animated: boolean,
|
|
navigationTransition: NavigationTransition,
|
|
currentEntry: ExpandedEntry,
|
|
newEntry: ExpandedEntry,
|
|
frameId: number,
|
|
fragmentTransaction: any,
|
|
isNestedDefaultTransition?: boolean): void {
|
|
|
|
const currentFragment: androidx.fragment.app.Fragment = currentEntry ? currentEntry.fragment : null;
|
|
const newFragment: androidx.fragment.app.Fragment = newEntry.fragment;
|
|
const entries = waitingQueue.get(frameId);
|
|
if (entries && entries.size > 0) {
|
|
throw new Error("Calling navigation before previous navigation finish.");
|
|
}
|
|
|
|
allowTransitionOverlap(currentFragment);
|
|
allowTransitionOverlap(newFragment);
|
|
|
|
let name = "";
|
|
let transition: Transition;
|
|
|
|
if (navigationTransition) {
|
|
transition = navigationTransition.instance;
|
|
name = navigationTransition.name ? navigationTransition.name.toLowerCase() : "";
|
|
}
|
|
|
|
if (!animated) {
|
|
name = "none";
|
|
} else if (transition) {
|
|
name = "custom";
|
|
} else if (name.indexOf("slide") !== 0 && name !== "fade" && name.indexOf("flip") !== 0 && name.indexOf("explode") !== 0) {
|
|
// If we are given name that doesn't match any of ours - fallback to default.
|
|
name = "default";
|
|
}
|
|
|
|
let currentFragmentNeedsDifferentAnimation = false;
|
|
if (currentEntry) {
|
|
_updateTransitions(currentEntry);
|
|
if (currentEntry.transitionName !== name ||
|
|
currentEntry.transition !== transition || isNestedDefaultTransition) {
|
|
clearExitAndReenterTransitions(currentEntry, true);
|
|
currentFragmentNeedsDifferentAnimation = true;
|
|
}
|
|
}
|
|
|
|
if (name === "none") {
|
|
const noTransition = new NoTransition(0, null);
|
|
|
|
// Setup empty/immediate animator when transitioning to nested frame for first time.
|
|
// Also setup empty/immediate transition to be executed when navigating back to this page.
|
|
// TODO: Consider removing empty/immediate animator when migrating to official androidx.fragment.app.Fragment:1.2.
|
|
if (isNestedDefaultTransition) {
|
|
fragmentTransaction.setCustomAnimations(animFadeIn, animFadeOut);
|
|
setupAllAnimation(newEntry, noTransition);
|
|
setupNewFragmentCustomTransition({ duration: 0, curve: null }, newEntry, noTransition);
|
|
} else {
|
|
setupNewFragmentCustomTransition({ duration: 0, curve: null }, newEntry, noTransition);
|
|
}
|
|
|
|
newEntry.isNestedDefaultTransition = isNestedDefaultTransition;
|
|
|
|
if (currentFragmentNeedsDifferentAnimation) {
|
|
setupCurrentFragmentCustomTransition({ duration: 0, curve: null }, currentEntry, noTransition);
|
|
}
|
|
} else if (name === "custom") {
|
|
setupNewFragmentCustomTransition({ duration: transition.getDuration(), curve: transition.getCurve() }, newEntry, transition);
|
|
if (currentFragmentNeedsDifferentAnimation) {
|
|
setupCurrentFragmentCustomTransition({ duration: transition.getDuration(), curve: transition.getCurve() }, currentEntry, transition);
|
|
}
|
|
} else if (name === "default") {
|
|
setupNewFragmentFadeTransition({ duration: 150, curve: null }, newEntry);
|
|
if (currentFragmentNeedsDifferentAnimation) {
|
|
setupCurrentFragmentFadeTransition({ duration: 150, curve: null }, currentEntry);
|
|
}
|
|
} else if (name.indexOf("slide") === 0) {
|
|
setupNewFragmentSlideTransition(navigationTransition, newEntry, name);
|
|
if (currentFragmentNeedsDifferentAnimation) {
|
|
setupCurrentFragmentSlideTransition(navigationTransition, currentEntry, name);
|
|
}
|
|
} else if (name === "fade") {
|
|
setupNewFragmentFadeTransition(navigationTransition, newEntry);
|
|
if (currentFragmentNeedsDifferentAnimation) {
|
|
setupCurrentFragmentFadeTransition(navigationTransition, currentEntry);
|
|
}
|
|
} else if (name === "explode") {
|
|
setupNewFragmentExplodeTransition(navigationTransition, newEntry);
|
|
if (currentFragmentNeedsDifferentAnimation) {
|
|
setupCurrentFragmentExplodeTransition(navigationTransition, currentEntry);
|
|
}
|
|
} else if (name === "flip") {
|
|
const direction = name.substr("flip".length) || "right"; //Extract the direction from the string
|
|
const flipTransition = new FlipTransition(direction, navigationTransition.duration, navigationTransition.curve);
|
|
|
|
setupNewFragmentCustomTransition(navigationTransition, newEntry, flipTransition);
|
|
if (currentFragmentNeedsDifferentAnimation) {
|
|
setupCurrentFragmentCustomTransition(navigationTransition, currentEntry, flipTransition);
|
|
}
|
|
}
|
|
|
|
newEntry.transitionName = name;
|
|
|
|
if (currentEntry) {
|
|
currentEntry.transitionName = name;
|
|
if (name === "custom") {
|
|
currentEntry.transition = transition;
|
|
}
|
|
}
|
|
|
|
printTransitions(currentEntry);
|
|
printTransitions(newEntry);
|
|
}
|
|
|
|
function setupAllAnimation(entry: ExpandedEntry, transition: Transition): void {
|
|
setupExitAndPopEnterAnimation(entry, transition);
|
|
const listener = getAnimationListener();
|
|
|
|
// setupAllAnimation is called only for new fragments so we don't
|
|
// need to clearAnimationListener for enter & popExit animators.
|
|
const enterAnimator = <ExpandedAnimator>transition.createAndroidAnimator(AndroidTransitionType.enter);
|
|
enterAnimator.transitionType = AndroidTransitionType.enter;
|
|
enterAnimator.entry = entry;
|
|
enterAnimator.addListener(listener);
|
|
entry.enterAnimator = enterAnimator;
|
|
|
|
const popExitAnimator = <ExpandedAnimator>transition.createAndroidAnimator(AndroidTransitionType.popExit);
|
|
popExitAnimator.transitionType = AndroidTransitionType.popExit;
|
|
popExitAnimator.entry = entry;
|
|
popExitAnimator.addListener(listener);
|
|
entry.popExitAnimator = popExitAnimator;
|
|
}
|
|
|
|
function setupExitAndPopEnterAnimation(entry: ExpandedEntry, transition: Transition): void {
|
|
const listener = getAnimationListener();
|
|
|
|
// remove previous listener if we are changing the animator.
|
|
clearAnimationListener(entry.exitAnimator, listener);
|
|
clearAnimationListener(entry.popEnterAnimator, listener);
|
|
|
|
const exitAnimator = <ExpandedAnimator>transition.createAndroidAnimator(AndroidTransitionType.exit);
|
|
exitAnimator.transitionType = AndroidTransitionType.exit;
|
|
exitAnimator.entry = entry;
|
|
exitAnimator.addListener(listener);
|
|
entry.exitAnimator = exitAnimator;
|
|
|
|
const popEnterAnimator = <ExpandedAnimator>transition.createAndroidAnimator(AndroidTransitionType.popEnter);
|
|
popEnterAnimator.transitionType = AndroidTransitionType.popEnter;
|
|
popEnterAnimator.entry = entry;
|
|
popEnterAnimator.addListener(listener);
|
|
entry.popEnterAnimator = popEnterAnimator;
|
|
}
|
|
|
|
function getAnimationListener(): android.animation.Animator.AnimatorListener {
|
|
if (!AnimationListener) {
|
|
@Interfaces([android.animation.Animator.AnimatorListener])
|
|
class AnimationListenerImpl extends java.lang.Object implements android.animation.Animator.AnimatorListener {
|
|
constructor() {
|
|
super();
|
|
|
|
return global.__native(this);
|
|
}
|
|
|
|
onAnimationStart(animator: ExpandedAnimator): void {
|
|
const entry = animator.entry;
|
|
addToWaitingQueue(entry);
|
|
if (traceEnabled()) {
|
|
traceWrite(`START ${animator.transitionType} for ${entry.fragmentTag}`, traceCategories.Transition);
|
|
}
|
|
}
|
|
|
|
onAnimationRepeat(animator: ExpandedAnimator): void {
|
|
if (traceEnabled()) {
|
|
traceWrite(`REPEAT ${animator.transitionType} for ${animator.entry.fragmentTag}`, traceCategories.Transition);
|
|
}
|
|
}
|
|
|
|
onAnimationEnd(animator: ExpandedAnimator): void {
|
|
if (traceEnabled()) {
|
|
traceWrite(`END ${animator.transitionType} for ${animator.entry.fragmentTag}`, traceCategories.Transition);
|
|
}
|
|
transitionOrAnimationCompleted(animator.entry);
|
|
}
|
|
|
|
onAnimationCancel(animator: ExpandedAnimator): void {
|
|
if (traceEnabled()) {
|
|
traceWrite(`CANCEL ${animator.transitionType} for ${animator.entry.fragmentTag}`, traceCategories.Transition);
|
|
}
|
|
}
|
|
}
|
|
|
|
AnimationListener = new AnimationListenerImpl();
|
|
}
|
|
|
|
return AnimationListener;
|
|
}
|
|
|
|
function clearAnimationListener(animator: ExpandedAnimator, listener: android.animation.Animator.AnimatorListener): void {
|
|
if (!animator) {
|
|
return;
|
|
}
|
|
|
|
animator.removeListener(listener);
|
|
|
|
if (animator.entry && traceEnabled()) {
|
|
const entry = animator.entry;
|
|
traceWrite(`Clear ${animator.transitionType} - ${entry.transition} for ${entry.fragmentTag}`, traceCategories.Transition);
|
|
}
|
|
|
|
animator.entry = null;
|
|
}
|
|
|
|
export function _getAnimatedEntries(frameId: number): Set<BackstackEntry> {
|
|
return waitingQueue.get(frameId);
|
|
}
|
|
|
|
export function _updateTransitions(entry: ExpandedEntry): void {
|
|
const fragment = entry.fragment;
|
|
const enterTransitionListener = entry.enterTransitionListener;
|
|
if (enterTransitionListener && fragment) {
|
|
fragment.setEnterTransition(enterTransitionListener.transition);
|
|
}
|
|
|
|
const exitTransitionListener = entry.exitTransitionListener;
|
|
if (exitTransitionListener && fragment) {
|
|
fragment.setExitTransition(exitTransitionListener.transition);
|
|
}
|
|
|
|
const reenterTransitionListener = entry.reenterTransitionListener;
|
|
if (reenterTransitionListener && fragment) {
|
|
fragment.setReenterTransition(reenterTransitionListener.transition);
|
|
}
|
|
|
|
const returnTransitionListener = entry.returnTransitionListener;
|
|
if (returnTransitionListener && fragment) {
|
|
fragment.setReturnTransition(returnTransitionListener.transition);
|
|
}
|
|
}
|
|
|
|
export function _reverseTransitions(previousEntry: ExpandedEntry, currentEntry: ExpandedEntry): boolean {
|
|
const previousFragment = previousEntry.fragment;
|
|
const currentFragment = currentEntry.fragment;
|
|
let transitionUsed = false;
|
|
|
|
const returnTransitionListener = currentEntry.returnTransitionListener;
|
|
if (returnTransitionListener) {
|
|
transitionUsed = true;
|
|
currentFragment.setExitTransition(returnTransitionListener.transition);
|
|
} else {
|
|
currentFragment.setExitTransition(null);
|
|
}
|
|
|
|
const reenterTransitionListener = previousEntry.reenterTransitionListener;
|
|
if (reenterTransitionListener) {
|
|
transitionUsed = true;
|
|
previousFragment.setEnterTransition(reenterTransitionListener.transition);
|
|
} else {
|
|
previousFragment.setEnterTransition(null);
|
|
}
|
|
|
|
return transitionUsed;
|
|
}
|
|
|
|
// Transition listener can't be static because
|
|
// android is cloning transitions and we can't expand them :(
|
|
function getTransitionListener(entry: ExpandedEntry, transition: androidx.transition.Transition): ExpandedTransitionListener {
|
|
if (!TransitionListener) {
|
|
@Interfaces([(<any>androidx).transition.Transition.TransitionListener])
|
|
class TransitionListenerImpl extends java.lang.Object implements androidx.transition.Transition.TransitionListener {
|
|
constructor(public entry: ExpandedEntry, public transition: androidx.transition.Transition) {
|
|
super();
|
|
|
|
return global.__native(this);
|
|
}
|
|
|
|
public onTransitionStart(transition: androidx.transition.Transition): void {
|
|
const entry = this.entry;
|
|
addToWaitingQueue(entry);
|
|
if (traceEnabled()) {
|
|
traceWrite(`START ${toShortString(transition)} transition for ${entry.fragmentTag}`, traceCategories.Transition);
|
|
}
|
|
}
|
|
|
|
onTransitionEnd(transition: androidx.transition.Transition): void {
|
|
const entry = this.entry;
|
|
if (traceEnabled()) {
|
|
traceWrite(`END ${toShortString(transition)} transition for ${entry.fragmentTag}`, traceCategories.Transition);
|
|
}
|
|
|
|
transitionOrAnimationCompleted(entry);
|
|
}
|
|
|
|
onTransitionResume(transition: androidx.transition.Transition): void {
|
|
if (traceEnabled()) {
|
|
const fragment = this.entry.fragmentTag;
|
|
traceWrite(`RESUME ${toShortString(transition)} transition for ${fragment}`, traceCategories.Transition);
|
|
}
|
|
}
|
|
|
|
onTransitionPause(transition: androidx.transition.Transition): void {
|
|
if (traceEnabled()) {
|
|
traceWrite(`PAUSE ${toShortString(transition)} transition for ${this.entry.fragmentTag}`, traceCategories.Transition);
|
|
}
|
|
}
|
|
|
|
onTransitionCancel(transition: androidx.transition.Transition): void {
|
|
if (traceEnabled()) {
|
|
traceWrite(`CANCEL ${toShortString(transition)} transition for ${this.entry.fragmentTag}`, traceCategories.Transition);
|
|
}
|
|
}
|
|
}
|
|
|
|
TransitionListener = TransitionListenerImpl;
|
|
}
|
|
|
|
return new TransitionListener(entry, transition);
|
|
}
|
|
|
|
function addToWaitingQueue(entry: ExpandedEntry): void {
|
|
const frameId = entry.frameId;
|
|
let entries = waitingQueue.get(frameId);
|
|
if (!entries) {
|
|
entries = new Set<ExpandedEntry>();
|
|
waitingQueue.set(frameId, entries);
|
|
}
|
|
|
|
entries.add(entry);
|
|
}
|
|
|
|
function clearExitAndReenterTransitions(entry: ExpandedEntry, removeListener: boolean): void {
|
|
const fragment: androidx.fragment.app.Fragment = entry.fragment;
|
|
const exitListener = entry.exitTransitionListener;
|
|
if (exitListener) {
|
|
const exitTransition = fragment.getExitTransition();
|
|
if (exitTransition) {
|
|
if (removeListener) {
|
|
exitTransition.removeListener(exitListener);
|
|
}
|
|
|
|
fragment.setExitTransition(null);
|
|
if (traceEnabled()) {
|
|
traceWrite(`Cleared Exit ${exitTransition.getClass().getSimpleName()} transition for ${fragment}`, traceCategories.Transition);
|
|
}
|
|
}
|
|
|
|
if (removeListener) {
|
|
entry.exitTransitionListener = null;
|
|
}
|
|
}
|
|
|
|
const reenterListener = entry.reenterTransitionListener;
|
|
if (reenterListener) {
|
|
const reenterTransition = fragment.getReenterTransition();
|
|
if (reenterTransition) {
|
|
if (removeListener) {
|
|
reenterTransition.removeListener(reenterListener);
|
|
}
|
|
|
|
fragment.setReenterTransition(null);
|
|
if (traceEnabled()) {
|
|
traceWrite(`Cleared Reenter ${reenterTransition.getClass().getSimpleName()} transition for ${fragment}`, traceCategories.Transition);
|
|
}
|
|
}
|
|
|
|
if (removeListener) {
|
|
entry.reenterTransitionListener = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
export function _clearFragment(entry: ExpandedEntry): void {
|
|
clearEntry(entry, false);
|
|
}
|
|
|
|
export function _clearEntry(entry: ExpandedEntry): void {
|
|
clearEntry(entry, true);
|
|
}
|
|
|
|
function clearEntry(entry: ExpandedEntry, removeListener: boolean): void {
|
|
clearExitAndReenterTransitions(entry, removeListener);
|
|
|
|
const fragment: androidx.fragment.app.Fragment = entry.fragment;
|
|
const enterListener = entry.enterTransitionListener;
|
|
if (enterListener) {
|
|
const enterTransition = fragment.getEnterTransition();
|
|
if (enterTransition) {
|
|
if (removeListener) {
|
|
enterTransition.removeListener(enterListener);
|
|
}
|
|
|
|
fragment.setEnterTransition(null);
|
|
if (traceEnabled()) {
|
|
traceWrite(`Cleared Enter ${enterTransition.getClass().getSimpleName()} transition for ${fragment}`, traceCategories.Transition);
|
|
}
|
|
}
|
|
|
|
if (removeListener) {
|
|
entry.enterTransitionListener = null;
|
|
}
|
|
}
|
|
|
|
const returnListener = entry.returnTransitionListener;
|
|
if (returnListener) {
|
|
const returnTransition = fragment.getReturnTransition();
|
|
if (returnTransition) {
|
|
if (removeListener) {
|
|
returnTransition.removeListener(returnListener);
|
|
}
|
|
|
|
fragment.setReturnTransition(null);
|
|
if (traceEnabled()) {
|
|
traceWrite(`Cleared Return ${returnTransition.getClass().getSimpleName()} transition for ${fragment}`, traceCategories.Transition);
|
|
}
|
|
}
|
|
|
|
if (removeListener) {
|
|
entry.returnTransitionListener = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
function allowTransitionOverlap(fragment: androidx.fragment.app.Fragment): void {
|
|
if (fragment) {
|
|
fragment.setAllowEnterTransitionOverlap(true);
|
|
fragment.setAllowReturnTransitionOverlap(true);
|
|
}
|
|
}
|
|
|
|
function setEnterTransition(navigationTransition: NavigationTransition, entry: ExpandedEntry, transition: androidx.transition.Transition): void {
|
|
setUpNativeTransition(navigationTransition, transition);
|
|
const listener = addNativeTransitionListener(entry, transition);
|
|
|
|
// attach listener to JS object so that it will be alive as long as entry.
|
|
entry.enterTransitionListener = listener;
|
|
const fragment: androidx.fragment.app.Fragment = entry.fragment;
|
|
fragment.setEnterTransition(transition);
|
|
}
|
|
|
|
function setExitTransition(navigationTransition: NavigationTransition, entry: ExpandedEntry, transition: androidx.transition.Transition): void {
|
|
setUpNativeTransition(navigationTransition, transition);
|
|
const listener = addNativeTransitionListener(entry, transition);
|
|
|
|
// attach listener to JS object so that it will be alive as long as entry.
|
|
entry.exitTransitionListener = listener;
|
|
const fragment: androidx.fragment.app.Fragment = entry.fragment;
|
|
fragment.setExitTransition(transition);
|
|
}
|
|
|
|
function setReenterTransition(navigationTransition: NavigationTransition, entry: ExpandedEntry, transition: androidx.transition.Transition): void {
|
|
setUpNativeTransition(navigationTransition, transition);
|
|
const listener = addNativeTransitionListener(entry, transition);
|
|
|
|
// attach listener to JS object so that it will be alive as long as entry.
|
|
entry.reenterTransitionListener = listener;
|
|
const fragment: androidx.fragment.app.Fragment = entry.fragment;
|
|
fragment.setReenterTransition(transition);
|
|
}
|
|
|
|
function setReturnTransition(navigationTransition: NavigationTransition, entry: ExpandedEntry, transition: androidx.transition.Transition): void {
|
|
setUpNativeTransition(navigationTransition, transition);
|
|
const listener = addNativeTransitionListener(entry, transition);
|
|
|
|
// attach listener to JS object so that it will be alive as long as entry.
|
|
entry.returnTransitionListener = listener;
|
|
const fragment: androidx.fragment.app.Fragment = entry.fragment;
|
|
fragment.setReturnTransition(transition);
|
|
}
|
|
|
|
function setupNewFragmentSlideTransition(navTransition: NavigationTransition, entry: ExpandedEntry, name: string): void {
|
|
setupCurrentFragmentSlideTransition(navTransition, entry, name);
|
|
const direction = name.substr("slide".length) || "left"; //Extract the direction from the string
|
|
switch (direction) {
|
|
case "left":
|
|
setEnterTransition(navTransition, entry, new androidx.transition.Slide(android.view.Gravity.RIGHT));
|
|
setReturnTransition(navTransition, entry, new androidx.transition.Slide(android.view.Gravity.RIGHT));
|
|
break;
|
|
|
|
case "right":
|
|
setEnterTransition(navTransition, entry, new androidx.transition.Slide(android.view.Gravity.LEFT));
|
|
setReturnTransition(navTransition, entry, new androidx.transition.Slide(android.view.Gravity.LEFT));
|
|
break;
|
|
|
|
case "top":
|
|
setEnterTransition(navTransition, entry, new androidx.transition.Slide(android.view.Gravity.BOTTOM));
|
|
setReturnTransition(navTransition, entry, new androidx.transition.Slide(android.view.Gravity.BOTTOM));
|
|
break;
|
|
|
|
case "bottom":
|
|
setEnterTransition(navTransition, entry, new androidx.transition.Slide(android.view.Gravity.TOP));
|
|
setReturnTransition(navTransition, entry, new androidx.transition.Slide(android.view.Gravity.TOP));
|
|
break;
|
|
}
|
|
}
|
|
|
|
function setupCurrentFragmentSlideTransition(navTransition: NavigationTransition, entry: ExpandedEntry, name: string): void {
|
|
const direction = name.substr("slide".length) || "left"; //Extract the direction from the string
|
|
switch (direction) {
|
|
case "left":
|
|
setExitTransition(navTransition, entry, new androidx.transition.Slide(android.view.Gravity.LEFT));
|
|
setReenterTransition(navTransition, entry, new androidx.transition.Slide(android.view.Gravity.LEFT));
|
|
break;
|
|
|
|
case "right":
|
|
setExitTransition(navTransition, entry, new androidx.transition.Slide(android.view.Gravity.RIGHT));
|
|
setReenterTransition(navTransition, entry, new androidx.transition.Slide(android.view.Gravity.RIGHT));
|
|
break;
|
|
|
|
case "top":
|
|
setExitTransition(navTransition, entry, new androidx.transition.Slide(android.view.Gravity.TOP));
|
|
setReenterTransition(navTransition, entry, new androidx.transition.Slide(android.view.Gravity.TOP));
|
|
break;
|
|
|
|
case "bottom":
|
|
setExitTransition(navTransition, entry, new androidx.transition.Slide(android.view.Gravity.BOTTOM));
|
|
setReenterTransition(navTransition, entry, new androidx.transition.Slide(android.view.Gravity.BOTTOM));
|
|
break;
|
|
}
|
|
}
|
|
|
|
function setupCurrentFragmentCustomTransition(navTransition: NavigationTransition, entry: ExpandedEntry, transition: Transition): void {
|
|
const exitAnimator = transition.createAndroidAnimator(AndroidTransitionType.exit);
|
|
const exitTransition = new org.nativescript.widgets.CustomTransition(exitAnimator, transition.constructor.name + AndroidTransitionType.exit.toString());
|
|
|
|
setExitTransition(navTransition, entry, exitTransition);
|
|
|
|
const reenterAnimator = transition.createAndroidAnimator(AndroidTransitionType.popEnter);
|
|
const reenterTransition = new org.nativescript.widgets.CustomTransition(reenterAnimator, transition.constructor.name + AndroidTransitionType.popEnter.toString());
|
|
|
|
setReenterTransition(navTransition, entry, reenterTransition);
|
|
}
|
|
|
|
function setupNewFragmentCustomTransition(navTransition: NavigationTransition, entry: ExpandedEntry, transition: Transition): void {
|
|
setupCurrentFragmentCustomTransition(navTransition, entry, transition);
|
|
|
|
const enterAnimator = transition.createAndroidAnimator(AndroidTransitionType.enter);
|
|
const enterTransition = new org.nativescript.widgets.CustomTransition(enterAnimator, transition.constructor.name + AndroidTransitionType.enter.toString());
|
|
setEnterTransition(navTransition, entry, enterTransition);
|
|
|
|
const returnAnimator = transition.createAndroidAnimator(AndroidTransitionType.popExit);
|
|
const returnTransition = new org.nativescript.widgets.CustomTransition(returnAnimator, transition.constructor.name + AndroidTransitionType.popExit.toString());
|
|
setReturnTransition(navTransition, entry, returnTransition);
|
|
|
|
}
|
|
|
|
function setupNewFragmentFadeTransition(navTransition: NavigationTransition, entry: ExpandedEntry): void {
|
|
setupCurrentFragmentFadeTransition(navTransition, entry);
|
|
|
|
const fadeInEnter = new androidx.transition.Fade(androidx.transition.Fade.IN);
|
|
setEnterTransition(navTransition, entry, fadeInEnter);
|
|
|
|
const fadeOutReturn = new androidx.transition.Fade(androidx.transition.Fade.OUT);
|
|
setReturnTransition(navTransition, entry, fadeOutReturn);
|
|
}
|
|
|
|
function setupCurrentFragmentFadeTransition(navTransition: NavigationTransition, entry: ExpandedEntry): void {
|
|
const fadeOutExit = new androidx.transition.Fade(androidx.transition.Fade.OUT);
|
|
setExitTransition(navTransition, entry, fadeOutExit);
|
|
|
|
// NOTE: There is a bug in Fade transition so we need to set all 4
|
|
// otherwise back navigation will complete immediately (won't run the reverse transition).
|
|
const fadeInReenter = new androidx.transition.Fade(androidx.transition.Fade.IN);
|
|
setReenterTransition(navTransition, entry, fadeInReenter);
|
|
}
|
|
|
|
function setupCurrentFragmentExplodeTransition(navTransition: NavigationTransition, entry: ExpandedEntry): void {
|
|
setExitTransition(navTransition, entry, new androidx.transition.Explode());
|
|
setReenterTransition(navTransition, entry, new androidx.transition.Explode());
|
|
}
|
|
|
|
function setupNewFragmentExplodeTransition(navTransition: NavigationTransition, entry: ExpandedEntry): void {
|
|
setupCurrentFragmentExplodeTransition(navTransition, entry);
|
|
|
|
setEnterTransition(navTransition, entry, new androidx.transition.Explode());
|
|
setReturnTransition(navTransition, entry, new androidx.transition.Explode());
|
|
}
|
|
|
|
function setUpNativeTransition(navigationTransition: NavigationTransition, nativeTransition: androidx.transition.Transition) {
|
|
if (navigationTransition.duration) {
|
|
nativeTransition.setDuration(navigationTransition.duration);
|
|
}
|
|
|
|
const interpolator = navigationTransition.curve ? _resolveAnimationCurve(navigationTransition.curve) : defaultInterpolator();
|
|
nativeTransition.setInterpolator(interpolator);
|
|
}
|
|
|
|
export function addNativeTransitionListener(entry: ExpandedEntry, nativeTransition: androidx.transition.Transition): ExpandedTransitionListener {
|
|
const listener = getTransitionListener(entry, nativeTransition);
|
|
nativeTransition.addListener(listener);
|
|
|
|
return listener;
|
|
}
|
|
|
|
function transitionOrAnimationCompleted(entry: ExpandedEntry): void {
|
|
const frameId = entry.frameId;
|
|
const entries = waitingQueue.get(frameId);
|
|
// https://github.com/NativeScript/NativeScript/issues/5759
|
|
// https://github.com/NativeScript/NativeScript/issues/5780
|
|
// transitionOrAnimationCompleted fires again (probably bug in android)
|
|
// NOTE: we cannot reproduce this issue so this is a blind fix
|
|
if (!entries) {
|
|
return;
|
|
}
|
|
|
|
entries.delete(entry);
|
|
if (entries.size === 0) {
|
|
const frame = entry.resolvedPage.frame;
|
|
|
|
// We have 0 or 1 entry per frameId in completedEntries
|
|
// So there is no need to make it to Set like waitingQueue
|
|
const previousCompletedAnimationEntry = completedEntries.get(frameId);
|
|
completedEntries.delete(frameId);
|
|
waitingQueue.delete(frameId);
|
|
|
|
const navigationContext = frame._executingContext || { navigationType: NavigationType.back };
|
|
let current = frame.isCurrent(entry) ? previousCompletedAnimationEntry : entry;
|
|
current = current || entry;
|
|
// Will be null if Frame is shown modally...
|
|
// transitionOrAnimationCompleted fires again (probably bug in android).
|
|
if (current) {
|
|
setTimeout(() => frame.setCurrent(current, navigationContext.navigationType));
|
|
}
|
|
} else {
|
|
completedEntries.set(frameId, entry);
|
|
}
|
|
}
|
|
|
|
function toShortString(nativeTransition: androidx.transition.Transition): string {
|
|
return `${nativeTransition.getClass().getSimpleName()}@${nativeTransition.hashCode().toString(16)}`;
|
|
}
|
|
|
|
function printTransitions(entry: ExpandedEntry) {
|
|
if (entry && traceEnabled()) {
|
|
let result = `${entry.fragmentTag} Transitions:`;
|
|
if (entry.transitionName) {
|
|
result += `transitionName=${entry.transitionName}, `;
|
|
}
|
|
|
|
const fragment = entry.fragment;
|
|
result += `${fragment.getEnterTransition() ? " enter=" + toShortString(fragment.getEnterTransition()) : ""}`;
|
|
result += `${fragment.getExitTransition() ? " exit=" + toShortString(fragment.getExitTransition()) : ""}`;
|
|
result += `${fragment.getReenterTransition() ? " popEnter=" + toShortString(fragment.getReenterTransition()) : ""}`;
|
|
result += `${fragment.getReturnTransition() ? " popExit=" + toShortString(fragment.getReturnTransition()) : ""}`;
|
|
|
|
traceWrite(result, traceCategories.Transition);
|
|
}
|
|
}
|
|
|
|
function javaObjectArray(...params: java.lang.Object[]) {
|
|
const nativeArray = Array.create(java.lang.Object, params.length);
|
|
params.forEach((value, i) => nativeArray[i] = value);
|
|
|
|
return nativeArray;
|
|
}
|
|
|
|
function createDummyZeroDurationAnimator(duration: number): android.animation.AnimatorSet {
|
|
const animatorSet = new android.animation.AnimatorSet();
|
|
const objectAnimators = Array.create(android.animation.Animator, 1);
|
|
|
|
const values = Array.create("float", 2);
|
|
values[0] = 0.0;
|
|
values[1] = 1.0;
|
|
|
|
const animator = <android.animation.Animator>android.animation.ObjectAnimator.ofFloat(null, "alpha", values);
|
|
animator.setDuration(duration);
|
|
objectAnimators[0] = animator;
|
|
animatorSet.playTogether(objectAnimators);
|
|
|
|
return animatorSet;
|
|
}
|
|
|
|
class NoTransition extends Transition {
|
|
public createAndroidAnimator(transitionType: string): android.animation.AnimatorSet {
|
|
return createDummyZeroDurationAnimator(this.getDuration());
|
|
}
|
|
}
|