嵌套片段在过渡动画期间消失

这里的情景：活动包含片段A，又使用getChildFragmentManager()添加片段A1，并A2在其onCreate像这样：

getChildFragmentManager()
  .beginTransaction()
  .replace(R.id.fragmentOneHolder, new FragmentA1())
  .replace(R.id.fragmentTwoHolder, new FragmentA2())
  .commit()

到目前为止，一切都很好，一切正常。

然后，我们在Activity中运行以下事务：

getSupportFragmentManager()
  .beginTransaction()
  .setCustomAnimations(anim1, anim2, anim1, anim2)
  .replace(R.id.fragmentHolder, new FragmentB())
  .addToBackStack(null)
  .commit()

在过渡期间，enter片段的动画B正确运行，但片段A1和A2完全消失。当我们使用“后退”按钮还原事务时，它们会正确初始化并在popEnter动画过程中正常显示。

在我的简短测试中，它变得很奇怪-如果我为子片段设置动画（请参见下文），则exit在添加片段时动画会间歇性地运行B

getChildFragmentManager()
  .beginTransaction()
  .setCustomAnimations(enter, exit)
  .replace(R.id.fragmentOneHolder, new FragmentA1())
  .replace(R.id.fragmentTwoHolder, new FragmentA2())
  .commit()

我要实现的效果很简单-我想运行片段（anim2）上的exit（或应该是popExit？）动画，A从而对整个容器（包括其嵌套的子代）进行动画处理。

有什么方法可以实现？

编辑：请在这里找到一个测试用例

Edit2：感谢@StevenByle促使我继续尝试使用静态动画。显然，您可以基于每个操作设置动画（不是整个事务的全局动画），这意味着子级可以具有不确定的静态动画集，而其父级可以具有不同的动画，并且整个事情可以在一个事务中完成。请参阅下面的讨论和更新的测试用例项目。

为了避免用户在事务中删除/替换父片段时看到嵌套的片段消失，您可以通过提供它们的图像来“模拟”那些仍然存在的片段，就像它们出现在屏幕上一样。该图像将用作嵌套片段容器的背景，因此即使嵌套片段的视图消失，该图像也会模拟它们的存在。另外，我不认为失去与嵌套片段视图的交互性是一个问题，因为我不希望您在删除它们的过程中不希望用户对其进行操作（可能是作为用户操作好）。

我已经通过设置背景图片（基本的东西）举了一个小例子。

因此，似乎有很多不同的解决方法，但是基于@ Jayd16的答案，我认为我找到了一个非常可靠的综合解决方案，该解决方案仍然允许在子片段上进行自定义过渡动画，而无需这样做布局的位图缓存。

有一个extensions的BaseFragment类，Fragment并使您的所有片段都扩展该类（而不仅仅是子片段）。

在BaseFragment该类中，添加以下内容：

// Arbitrary value; set it to some reasonable default
private static final int DEFAULT_CHILD_ANIMATION_DURATION = 250;

@Override
public Animation onCreateAnimation(int transit, boolean enter, int nextAnim) {
    final Fragment parent = getParentFragment();

    // Apply the workaround only if this is a child fragment, and the parent
    // is being removed.
    if (!enter && parent != null && parent.isRemoving()) {
        // This is a workaround for the bug where child fragments disappear when
        // the parent is removed (as all children are first removed from the parent)
        // See https://code.google.com/p/android/issues/detail?id=55228
        Animation doNothingAnim = new AlphaAnimation(1, 1);
        doNothingAnim.setDuration(getNextAnimationDuration(parent, DEFAULT_CHILD_ANIMATION_DURATION));
        return doNothingAnim;
    } else {
        return super.onCreateAnimation(transit, enter, nextAnim);
    }
}

private static long getNextAnimationDuration(Fragment fragment, long defValue) {
    try {
        // Attempt to get the resource ID of the next animation that
        // will be applied to the given fragment.
        Field nextAnimField = Fragment.class.getDeclaredField("mNextAnim");
        nextAnimField.setAccessible(true);
        int nextAnimResource = nextAnimField.getInt(fragment);
        Animation nextAnim = AnimationUtils.loadAnimation(fragment.getActivity(), nextAnimResource);

        // ...and if it can be loaded, return that animation's duration
        return (nextAnim == null) ? defValue : nextAnim.getDuration();
    } catch (NoSuchFieldException|IllegalAccessException|Resources.NotFoundException ex) {
        Log.w(TAG, "Unable to load next animation from parent.", ex);
        return defValue;
    }
}

不幸的是，它确实需要反思。但是，由于此解决方法是针对支持库的，因此除非您更新支持库，否则就不会冒基础实现更改的风险。如果要从源代码构建支持库，则可以为下一个动画资源ID添加访问器，Fragment.java并消除反射的需要。

此解决方案无需“猜测”父级的动画持续时间（以便“不做任何”动画的持续时间与父级的退出动画的持续时间相同），并允许您仍对子片段进行自定义动画（例如，如果重新用不同的动画交换子片段）。

我能够提出一个非常干净的解决方案。IMO的安全性最低，尽管从技术上讲这是“绘制位图”解决方案，至少由片段库抽象。

确保您的孩子碎片用以下方法覆盖父类：

private static final Animation dummyAnimation = new AlphaAnimation(1,1);
static{
    dummyAnimation.setDuration(500);
}

@Override
public Animation onCreateAnimation(int transit, boolean enter, int nextAnim) {
    if(!enter && getParentFragment() != null){
        return dummyAnimation;
    }
    return super.onCreateAnimation(transit, enter, nextAnim);
}

如果我们在子碎片上有退出动画，它们将被动画化而不是眨眼。我们可以通过制作动画来简单地在整个持续时间内以全alpha绘制子片段来利用这一点。这样，它们在动画时将在父片段中保持可见，从而提供所需的行为。

我能想到的唯一问题是跟踪该持续时间。我也许可以将其设置为很大的数字，但是如果它仍然在某个位置绘制该动画，恐怕会出现性能问题。

我发布我的解决方案是为了清楚。解决方案非常简单。如果您要模仿父级片段事务动画，只需将自定义动画添加到具有相同持续时间的子片段事务中。哦，请确保您在add（）之前设置了自定义动画。

getChildFragmentManager().beginTransaction()
        .setCustomAnimations(R.anim.none, R.anim.none, R.anim.none, R.anim.none)
        .add(R.id.container, nestedFragment)
        .commit();

R.anim.none的xml（我的父母进入/退出动画时间为250ms）

<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
    <translate android:fromXDelta="0" android:toXDelta="0" android:duration="250" />
</set>

我了解这可能无法完全解决您的问题，但也许会满足其他人的需求，您可以为孩子添加enter/ exit和popEnter/ popExit动画Fragment，而实际上并不会对其进行移动/设置动画Fragment。只要动画具有与父级Fragment动画相同的持续时间/偏移，它们就会显示为与父级动画移动/动画化。

您可以在子片段中执行此操作。

@Override
public Animator onCreateAnimator(int transit, boolean enter, int nextAnim) {
    if (true) {//condition
        ObjectAnimator objectAnimator = ObjectAnimator.ofFloat(getView(), "alpha", 1, 1);
        objectAnimator.setDuration(333);//time same with parent fragment's animation
        return objectAnimator;
    }
    return super.onCreateAnimator(transit, enter, nextAnim);
}

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

编辑：我最终没有实现此解决方案，因为这还有其他问题。Square最近推出了2个可替换片段的库。我想说，这实际上可能比尝试破解片段做Google不想让他们做的更好的选择。

http://corner.squareup.com/2014/01/mortar-and-flow.html

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

我想我会提出此解决方案来帮助将来有此问题的人。如果您跟踪与其他人的原始海报发布者对话，并查看他发布的代码，您将看到原始海报最终得出结论，即在对子片段进行动画处理的同时对子片段使用无操作动画。该解决方案并不理想，因为它会迫使您跟踪所有子片段，这在将ViewPager与FragmentPagerAdapter一起使用时会很麻烦。

由于我在所有地方都使用Child Fragments，因此我想出了一种高效，模块化的解决方案（因此可以轻松删除），以防他们修复它，并且不再需要这种无操作动画。

有很多方法可以实现此目的。我选择使用单例，并将其命名为ChildFragmentAnimationManager。基本上，它将根据其父项为我跟踪子项片段，并在询问时对子项应用无操作动画。

public class ChildFragmentAnimationManager {

private static ChildFragmentAnimationManager instance = null;

private Map<Fragment, List<Fragment>> fragmentMap;

private ChildFragmentAnimationManager() {
    fragmentMap = new HashMap<Fragment, List<Fragment>>();
}

public static ChildFragmentAnimationManager instance() {
    if (instance == null) {
        instance = new ChildFragmentAnimationManager();
    }
    return instance;
}

public FragmentTransaction animate(FragmentTransaction ft, Fragment parent) {
    List<Fragment> children = getChildren(parent);

    ft.setCustomAnimations(R.anim.no_anim, R.anim.no_anim, R.anim.no_anim, R.anim.no_anim);
    for (Fragment child : children) {
        ft.remove(child);
    }

    return ft;
}

public void putChild(Fragment parent, Fragment child) {
    List<Fragment> children = getChildren(parent);
    children.add(child);
}

public void removeChild(Fragment parent, Fragment child) {
    List<Fragment> children = getChildren(parent);
    children.remove(child);
}

private List<Fragment> getChildren(Fragment parent) {
    List<Fragment> children;

    if ( fragmentMap.containsKey(parent) ) {
        children = fragmentMap.get(parent);
    } else {
        children = new ArrayList<Fragment>(3);
        fragmentMap.put(parent, children);
    }

    return children;
}

}

接下来，您需要一个扩展Fragment的类，所有Fragment都应扩展（至少是Child Fragments）。我已经有这个课，我称之为BaseFragment。创建片段视图后，我们将其添加到ChildFragmentAnimationManager中，并在销毁它时将其删除。您可以按顺序执行onAttach / Detach或其他匹配方法。我选择创建/销毁视图的逻辑是因为，如果片段没有视图，则我不希望对其进行动画处理以使其继续可见。这种方法还应该与使用Fragments的ViewPagers更好地配合，因为您将不会跟踪FragmentPagerAdapter持有的每个Fragment，而只能跟踪3。

public abstract class BaseFragment extends Fragment {

@Override
public  View onCreateView(LayoutInflater inflater, ViewGroup container,
        Bundle savedInstanceState) {

    Fragment parent = getParentFragment();
    if (parent != null) {
        ChildFragmentAnimationManager.instance().putChild(parent, this);
    }

    return super.onCreateView(inflater, container, savedInstanceState);
}

@Override
public void onDestroyView() {
    Fragment parent = getParentFragment();
    if (parent != null) {
        ChildFragmentAnimationManager.instance().removeChild(parent, this);
    }

    super.onDestroyView();
}

}

现在，所有片段都由父片段存储在内存中，您可以像这样对它们调用动画，而子片段不会消失。

FragmentTransaction ft = getActivity().getSupportFragmentManager().beginTransaction();
ChildFragmentAnimationManager.instance().animate(ft, ReaderFragment.this)
                    .setCustomAnimations(R.anim.up_in, R.anim.up_out, R.anim.down_in, R.anim.down_out)
                    .replace(R.id.container, f)
                    .addToBackStack(null)
                    .commit();

另外，就这样，这是位于res / anim文件夹中的no_anim.xml文件：

<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android" android:interpolator="@android:anim/linear_interpolator">
    <translate android:fromXDelta="0" android:toXDelta="0"
        android:duration="1000" />
</set>

再说一次，我认为这种解决方案不是完美的，但是它比每个实例都有一个子片段要好得多，它在父片段中实现自定义代码以跟踪每个孩子。我去过那里，这很无聊。

我想我找到了比Luksprog建议的将当前片段快照到位图更好的解决方案。

诀窍是隐藏要删除或分离的片段，只有在动画完成后，才可以在其自己的片段事务中删除或分离片段。

想象我们有FragmentA和FragmentB，都带有子片段。现在，您通常可以执行以下操作：

getSupportFragmentManager()
  .beginTransaction()
  .setCustomAnimations(anim1, anim2, anim1, anim2)
  .add(R.id.fragmentHolder, new FragmentB())
  .remove(fragmentA)    <-------------------------------------------
  .addToBackStack(null)
  .commit()

相反，你做

getSupportFragmentManager()
  .beginTransaction()
  .setCustomAnimations(anim1, anim2, anim1, anim2)
  .add(R.id.fragmentHolder, new FragmentB())
  .hide(fragmentA)    <---------------------------------------------
  .addToBackStack(null)
  .commit()

fragmentA.removeMe = true;

现在执行片段：

public class BaseFragment extends Fragment {

    protected Boolean detachMe = false;
    protected Boolean removeMe = false;

    @Override
    public Animation onCreateAnimation(int transit, boolean enter, int nextAnim) {
        if (nextAnim == 0) {
            if (!enter) {
                onExit();
            }

            return null;
        }

        Animation animation = AnimationUtils.loadAnimation(getActivity(), nextAnim);
        assert animation != null;

        if (!enter) {
            animation.setAnimationListener(new Animation.AnimationListener() {
                @Override
                public void onAnimationStart(Animation animation) {
                }

                @Override
                public void onAnimationEnd(Animation animation) {
                    onExit();
                }

                @Override
                public void onAnimationRepeat(Animation animation) {
                }
            });
        }

        return animation;
    }

    private void onExit() {
        if (!detachMe && !removeMe) {
            return;
        }

        FragmentTransaction fragmentTransaction = getFragmentManager().beginTransaction();
        if (detachMe) {
            fragmentTransaction.detach(this);
            detachMe = false;
        } else if (removeMe) {
            fragmentTransaction.remove(this);
            removeMe = false;
        }
        fragmentTransaction.commit();
    }
}

我在地图片段上遇到了同样的问题。它在包含片段的退出动画期间一直消失。解决方法是为子地图片段添加动画，这将使其在父片段的退出动画期间保持可见。子片段的动画在其持续时间段内将其alpha保持在100％。

动画：res / animator / keep_child_fragment.xml

<?xml version="1.0" encoding="utf-8"?>    
<set xmlns:android="http://schemas.android.com/apk/res/android">
    <objectAnimator
        android:propertyName="alpha"
        android:valueFrom="1.0"
        android:valueTo="1.0"
        android:duration="@integer/keep_child_fragment_animation_duration" />
</set>

然后将地图片段添加到父片段时应用动画。

父片段

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
                         Bundle savedInstanceState) {

    View view = inflater.inflate(R.layout.map_parent_fragment, container, false);

    MapFragment mapFragment =  MapFragment.newInstance();

    getChildFragmentManager().beginTransaction()
            .setCustomAnimations(R.animator.keep_child_fragment, 0, 0, 0)
            .add(R.id.map, mapFragment)
            .commit();

    return view;
}

最后，子片段动画的持续时间在资源文件中设置。

values / integers.xml

<resources>
  <integer name="keep_child_fragment_animation_duration">500</integer>
</resources>

为了动画显示缺少的片段，我们可以在ChildFragmentManager上强制弹出堆栈。这将触发过渡动画。为此，我们需要赶上OnBackButtonPressed事件或侦听Backstack更改。

这是代码示例。

View.OnClickListener() {//this is from custom button but you can listen for back button pressed
            @Override
            public void onClick(View v) {
                getChildFragmentManager().popBackStack();
                //and here we can manage other fragment operations 
            }
        });

  Fragment fr = MyNeastedFragment.newInstance(product);

  getChildFragmentManager()
          .beginTransaction()
                .setTransition(FragmentTransaction.TRANSIT_FRAGMENT_CLOSE)
                .replace(R.neasted_fragment_container, fr)
                .addToBackStack("Neasted Fragment")
                .commit();

我最近在以下问题中遇到了这个问题：嵌套片段转换不正确

我有一个解决方案，无需保存位图，也无需使用反射或任何其他不令人满意的方法即可解决此问题。

可以在此处查看示例项目：https : //github.com/zafrani/NestedFragmentTransitions

可以在此处查看效果的GIF：https : //imgur.com/94AvrW4

在我的示例中，有6个子片段，分为两个父片段。我能够实现输入，退出，弹出和推送的过渡，而没有任何问题。配置更改和反压也已成功处理。

解决方案的大部分位于我的BaseFragment（由我的孩子和父母的片段扩展的片段）的onCreateAnimator函数中，如下所示：

   override fun onCreateAnimator(transit: Int, enter: Boolean, nextAnim: Int): Animator {
    if (isConfigChange) {
        resetStates()
        return nothingAnim()
    }

    if (parentFragment is ParentFragment) {
        if ((parentFragment as BaseFragment).isPopping) {
            return nothingAnim()
        }
    }

    if (parentFragment != null && parentFragment.isRemoving) {
        return nothingAnim()
    }

    if (enter) {
        if (isPopping) {
            resetStates()
            return pushAnim()
        }
        if (isSuppressing) {
            resetStates()
            return nothingAnim()
        }
        return enterAnim()
    }

    if (isPopping) {
        resetStates()
        return popAnim()
    }

    if (isSuppressing) {
        resetStates()
        return nothingAnim()
    }

    return exitAnim()
}

活动和父片段负责设置这些布尔值的状态。从我的示例项目中查看方式和位置更容易。

我没有在示例中使用支持片段，但是可以将相同的逻辑用于它们及其onCreateAnimation函数

解决此问题的一种简单方法是使用Fragment该库中的类，而不是标准库片段类：

https://github.com/marksalpeter/contract-fragment

作为附带说明，该软件包还包含一个有用的委托模式，称为ContractFragment，您可能会发现它对于利用父子片段关系构建应用程序很有用。

根据@kcoppock的上述答案，

如果您具有Activity-> Fragment-> Fragments（多次堆叠，以下操作会有所帮助），则对最佳答案恕我直言进行较小的编辑。

public Animation onCreateAnimation(int transit, boolean enter, int nextAnim) {

    final Fragment parent = getParentFragment();

    Fragment parentOfParent = null;

    if( parent!=null ) {
        parentOfParent = parent.getParentFragment();
    }

    if( !enter && parent != null && parentOfParent!=null && parentOfParent.isRemoving()){
        Animation doNothingAnim = new AlphaAnimation(1, 1);
        doNothingAnim.setDuration(getNextAnimationDuration(parent, DEFAULT_CHILD_ANIMATION_DURATION));
        return doNothingAnim;
    } else
    if (!enter && parent != null && parent.isRemoving()) {
        // This is a workaround for the bug where child fragments disappear when
        // the parent is removed (as all children are first removed from the parent)
        // See https://code.google.com/p/android/issues/detail?id=55228
        Animation doNothingAnim = new AlphaAnimation(1, 1);
        doNothingAnim.setDuration(getNextAnimationDuration(parent, DEFAULT_CHILD_ANIMATION_DURATION));
        return doNothingAnim;
    } else {
        return super.onCreateAnimation(transit, enter, nextAnim);
    }
}

我的问题是在父片段删除（ft.remove（fragment））上，子动画没有发生。

基本问题是子片段在退出动画的父片段之前会立即销毁。

子片段自定义动画不会在移除父片段时执行

正如其他人逃避的那样，在删除PARENT之前隐藏PARENT（而不是孩子）是必须的。

            val ft = fragmentManager?.beginTransaction()
            ft?.setCustomAnimations(R.anim.enter_from_right,
                    R.anim.exit_to_right)
            if (parentFragment.isHidden()) {
                ft?.show(vehicleModule)
            } else {
                ft?.hide(vehicleModule)
            }
            ft?.commit()

如果您实际上想删除父对象，则可能应该在自定义动画上设置一个侦听器，以了解动画何时结束，因此您可以安全地对父片段进行一些定型（删除）。如果不这样做，可能会导致动画最终消失。NB动画是在自己的异步队列上完成的。

顺便说一句，您不需要子片段上的自定义动画，因为它们将继承父动画。

问题已在中修复androidx.fragment:fragment:1.2.0-alpha02。有关更多详细信息，请参见https://issuetracker.google.com/issues/116675313。

旧线程，但万一有人在这里跌跌撞撞：

上面的所有方法对我来说都不是很吸引人，位图解决方案非常脏而且性能不佳。其他要求子片段了解用于创建相关子片段的事务中使用的过渡持续时间。在我眼中，更好的解决方案如下：

val currentFragment = supportFragmentManager.findFragmentByTag(TAG)
val transaction = supportFragmentManager
    .beginTransaction()
    .setCustomAnimations(anim1, anim2, anim1, anim2)
    .add(R.id.fragmentHolder, FragmentB(), TAG)
if (currentFragment != null) {
    transaction.hide(currentFragment).commit()
    Handler().postDelayed({
        supportFragmentManager.beginTransaction().remove(currentFragment).commit()
    }, DURATION_OF_ANIM)
} else {
    transaction.commit()
}

我们只隐藏当前片段并添加新片段，动画完成后，我们将删除旧片段。这样一来就可以处理它，而不会创建位图。