T.trigger(delay: Long = 500, block: (T) -> Unit) {
46 | triggerDelay = delay
47 | if (triggerEnable()) {
48 | block(this)
49 | }
50 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/common/weikaiyun/util/ResUtils.kt:
--------------------------------------------------------------------------------
1 | package com.common.weikaiyun.util
2 |
3 | import android.graphics.drawable.Drawable
4 | import androidx.annotation.ColorRes
5 | import androidx.annotation.DrawableRes
6 | import androidx.appcompat.content.res.AppCompatResources
7 | import com.common.weikaiyun.demo.DemoApplication
8 |
9 | object ResUtils {
10 | fun getDrawable(@DrawableRes resId: Int): Drawable {
11 | return AppCompatResources.getDrawable(DemoApplication.context, resId)!!
12 | }
13 |
14 | fun getColor(@ColorRes resId: Int): Int {
15 | return DemoApplication.context.getColor(resId)
16 | }
17 | }
--------------------------------------------------------------------------------
/app/src/main/res/drawable-v24/ic_launcher_foreground.xml:
--------------------------------------------------------------------------------
1 |
7 |
8 |
9 |
15 |
105 | * None if debug(false).
106 | *
107 | * Default:NONE
108 | */
109 | public FragmentationBuilder stackViewMode(@StackViewMode int mode) {
110 | this.mode = mode;
111 | return this;
112 | }
113 |
114 | public Fragmentation install() {
115 | Fragmentation.INSTANCE = new Fragmentation(this);
116 | return Fragmentation.INSTANCE;
117 | }
118 | }
119 | }
120 |
--------------------------------------------------------------------------------
/fragmentation/src/main/java/com/weikaiyun/fragmentation/ISupportActivity.java:
--------------------------------------------------------------------------------
1 | package com.weikaiyun.fragmentation;
2 |
3 | import android.view.MotionEvent;
4 |
5 | import com.weikaiyun.fragmentation.animation.FragmentAnimator;
6 |
7 | public interface ISupportActivity {
8 |
9 | SupportActivityDelegate getSupportDelegate();
10 |
11 | ExtraTransaction extraTransaction();
12 |
13 | void post(Runnable runnable);
14 |
15 | void onBackPressed();
16 |
17 | void onBackPressedSupport();
18 |
19 | boolean dispatchTouchEvent(MotionEvent ev);
20 |
21 | FragmentAnimator getFragmentAnimator();
22 |
23 | void setFragmentAnimator(FragmentAnimator fragmentAnimator);
24 | }
25 |
--------------------------------------------------------------------------------
/fragmentation/src/main/java/com/weikaiyun/fragmentation/ISupportFragment.java:
--------------------------------------------------------------------------------
1 | package com.weikaiyun.fragmentation;
2 |
3 | import android.os.Bundle;
4 |
5 | import androidx.annotation.IntDef;
6 |
7 | import java.lang.annotation.Retention;
8 | import java.lang.annotation.RetentionPolicy;
9 |
10 | public interface ISupportFragment {
11 | // LaunchMode
12 | int STANDARD = 0;
13 | int SINGLETOP = 1;
14 | int SINGLETASK = 2;
15 |
16 | // ResultCode
17 | int RESULT_CANCELED = 0;
18 | int RESULT_OK = -1;
19 |
20 | @IntDef({STANDARD, SINGLETOP, SINGLETASK})
21 | @Retention(RetentionPolicy.SOURCE)
22 | public @interface LaunchMode {
23 | }
24 |
25 | SupportFragmentDelegate getSupportDelegate();
26 |
27 | ExtraTransaction extraTransaction();
28 |
29 | void post(Runnable runnable);
30 |
31 | void lazyInit();
32 |
33 | void setFragmentResult(int resultCode, Bundle bundle);
34 |
35 | void onFragmentResult(int requestCode, int resultCode, Bundle data);
36 |
37 | void onNewBundle(Bundle args);
38 |
39 | void putNewBundle(Bundle newBundle);
40 |
41 | boolean onBackPressedSupport();
42 |
43 | void onVisible();
44 |
45 | void onInvisible();
46 | }
47 |
--------------------------------------------------------------------------------
/fragmentation/src/main/java/com/weikaiyun/fragmentation/SupportActivity.java:
--------------------------------------------------------------------------------
1 | package com.weikaiyun.fragmentation;
2 |
3 | import android.os.Bundle;
4 | import android.view.MotionEvent;
5 |
6 | import androidx.annotation.DrawableRes;
7 | import androidx.annotation.NonNull;
8 | import androidx.annotation.Nullable;
9 | import androidx.appcompat.app.AppCompatActivity;
10 |
11 | import com.weikaiyun.fragmentation.animation.FragmentAnimator;
12 |
13 | /**
14 | * Base class for activities that use the support-based
15 | * {@link ISupportActivity} and
16 | * {@link AppCompatActivity} APIs.
17 | */
18 | abstract public class SupportActivity extends AppCompatActivity implements ISupportActivity {
19 | final SupportActivityDelegate mDelegate = new SupportActivityDelegate(this);
20 |
21 | @Override
22 | public SupportActivityDelegate getSupportDelegate() {
23 | return mDelegate;
24 | }
25 |
26 | /**
27 | * Perform some extra transactions.
28 | * 额外的事务：自定义Tag, 操作非回退栈Fragment
29 | */
30 | @Override
31 | public ExtraTransaction extraTransaction() {
32 | return mDelegate.extraTransaction();
33 | }
34 |
35 | @Override
36 | protected void onCreate(@Nullable Bundle savedInstanceState) {
37 | super.onCreate(savedInstanceState);
38 | mDelegate.onCreate(savedInstanceState);
39 | }
40 |
41 | @Override
42 | protected void onPostCreate(@Nullable Bundle savedInstanceState) {
43 | super.onPostCreate(savedInstanceState);
44 | mDelegate.onPostCreate(savedInstanceState);
45 | }
46 |
47 | @Override
48 | protected void onSaveInstanceState(@NonNull Bundle outState) {
49 | mDelegate.onSaveInstanceState(outState);
50 | super.onSaveInstanceState(outState);
51 | }
52 |
53 | @Override
54 | protected void onStart() {
55 | super.onStart();
56 | }
57 |
58 | @Override
59 | protected void onStop() {
60 | super.onStop();
61 |
62 | }
63 |
64 | @Override
65 | protected void onDestroy() {
66 | super.onDestroy();
67 | mDelegate.onDestroy();
68 | }
69 |
70 | /**
71 | * Get all fragments animation.
72 | *
73 | * @return FragmentAnimator
74 | */
75 | @Override
76 | public FragmentAnimator getFragmentAnimator() {
77 | return mDelegate.getFragmentAnimator();
78 | }
79 |
80 | /**
81 | * Set all fragments animation.
82 | * 设置Fragment内的全局动画
83 | */
84 | @Override
85 | public void setFragmentAnimator(FragmentAnimator fragmentAnimator) {
86 | mDelegate.setFragmentAnimator(fragmentAnimator);
87 | }
88 |
89 | /**
90 | * Note：super.dispatchTouchEvent(ev);
91 | */
92 | @Override
93 | public boolean dispatchTouchEvent(MotionEvent ev) {
94 | return super.dispatchTouchEvent(ev);
95 | }
96 |
97 | /**
98 | * 不建议复写该方法,请使用 {@link #onBackPressedSupport} 代替
99 | */
100 | @Override
101 | final public void onBackPressed() {
102 | mDelegate.onBackPressed();
103 | }
104 |
105 | /**
106 | * 该方法回调时机为,Activity回退栈内Fragment的数量 小于等于1 时,默认finish Activity
107 | * 请尽量复写该方法,避免复写onBackPress(),以保证SupportFragment内的onBackPressedSupport()回退事件正常执行
108 | */
109 | @Override
110 | public void onBackPressedSupport() {
111 | mDelegate.onBackPressedSupport();
112 | }
113 |
114 |
115 | @Override
116 | public void post(Runnable runnable) {
117 | mDelegate.post(runnable);
118 | }
119 |
120 |
121 | /**
122 | * 加载根Fragment, 即Activity内的第一个Fragment
123 | *
124 | * @param containerId 容器id
125 | * @param toFragment 目标Fragment
126 | */
127 | public void loadRootFragment(int containerId, @NonNull ISupportFragment toFragment) {
128 | mDelegate.loadRootFragment(containerId, toFragment);
129 | }
130 |
131 | /**
132 | * 加载多个同级根Fragment
133 | */
134 | public void loadMultipleRootFragment(int containerId, int showPosition, ISupportFragment... toFragments) {
135 | mDelegate.loadMultipleRootFragment(containerId, showPosition, toFragments);
136 | }
137 |
138 | /**
139 | * show一个Fragment,hide其他同栈所有Fragment
140 | * 使用该方法时，要确保同级栈内无多余的Fragment,(只有通过loadMultipleRootFragment()载入的Fragment)
141 | *
142 | * 建议使用更明确的{@link #showHideFragment(ISupportFragment, ISupportFragment)}
143 | *
144 | * @param showFragment 需要show的Fragment
145 | */
146 | public void showHideFragment(ISupportFragment showFragment) {
147 | mDelegate.showHideFragment(showFragment);
148 | }
149 |
150 | /**
151 | * show一个Fragment,hide一个Fragment
152 | */
153 | public void showHideFragment(ISupportFragment showFragment, ISupportFragment hideFragment) {
154 | mDelegate.showHideFragment(showFragment, hideFragment);
155 | }
156 |
157 | /**
158 | * It is recommended to use {@link SupportFragment#start(ISupportFragment)}.
159 | */
160 | public void start(ISupportFragment toFragment) {
161 | mDelegate.start(toFragment);
162 | }
163 |
164 | /**
165 | * It is recommended to use {@link SupportFragment#start(ISupportFragment, int)}.
166 | *
167 | * @param launchMode Similar to Activity's LaunchMode.
168 | */
169 | public void start(ISupportFragment toFragment, @ISupportFragment.LaunchMode int launchMode) {
170 | mDelegate.start(toFragment, launchMode);
171 | }
172 |
173 | /**
174 | * It is recommended to use {@link SupportFragment#startForResult(ISupportFragment, int)}.
175 | * Launch an fragment for which you would like a result when it popped.
176 | */
177 | public void startForResult(ISupportFragment toFragment, int requestCode) {
178 | mDelegate.startForResult(toFragment, requestCode);
179 | }
180 |
181 | /**
182 | * It is recommended to use {@link SupportFragment#startWithPop(ISupportFragment)}.
183 | * Start the target Fragment and pop itself
184 | */
185 | public void startWithPop(ISupportFragment toFragment) {
186 | mDelegate.startWithPop(toFragment);
187 | }
188 |
189 | /**
190 | * It is recommended to use {@link SupportFragment#startWithPopTo(ISupportFragment, Class, boolean)}.
191 | *
192 | * @see #popTo(Class, boolean)
193 | * +
194 | * @see #start(ISupportFragment)
195 | */
196 | public void startWithPopTo(ISupportFragment toFragment, Class targetFragmentClass,
197 | boolean includeTargetFragment) {
198 |
199 | mDelegate.startWithPopTo(toFragment, targetFragmentClass, includeTargetFragment);
200 | }
201 |
202 |
203 | /**
204 | * It is recommended to use {@link SupportFragment#replaceFragment(ISupportFragment)}.
205 | */
206 | public void replaceFragment(ISupportFragment toFragment) {
207 | mDelegate.replaceFragment(toFragment);
208 | }
209 |
210 | /**
211 | * Pop the fragment.
212 | */
213 | public void pop() {
214 | mDelegate.pop();
215 | }
216 |
217 | /**
218 | * 出栈到目标fragment
219 | *
220 | * @param targetFragmentClass 目标fragment
221 | * @param includeTargetFragment 是否包含该fragment
222 | */
223 | public void popTo(Class targetFragmentClass, boolean includeTargetFragment) {
224 | mDelegate.popTo(targetFragmentClass, includeTargetFragment);
225 | }
226 |
227 | /**
228 | * If you want to begin another FragmentTransaction immediately after popTo(), use this method.
229 | * 如果你想在出栈后, 立刻进行FragmentTransaction操作，请使用该方法
230 | */
231 | public void popTo(Class targetFragmentClass, boolean includeTargetFragment,
232 | Runnable afterPopTransactionRunnable) {
233 |
234 | mDelegate.popTo(targetFragmentClass, includeTargetFragment, afterPopTransactionRunnable);
235 | }
236 |
237 | /**
238 | * 得到位于栈顶Fragment
239 | */
240 | public ISupportFragment getTopFragment() {
241 | return SupportHelper.getTopFragment(getSupportFragmentManager());
242 | }
243 |
244 | /**
245 | * 获取栈内的fragment对象
246 | */
247 | public T findFragment(Class fragmentClass) {
248 | return SupportHelper.findFragment(getSupportFragmentManager(), fragmentClass);
249 | }
250 |
251 | /**
252 | * 当Fragment根布局 没有 设定background属性时,
253 | * Fragmentation默认使用Theme的android:windowbackground作为Fragment的背景,
254 | * 可以通过该方法改变其内所有Fragment的默认背景。
255 | */
256 | public void setDefaultFragmentBackground(@DrawableRes int backgroundRes) {
257 | mDelegate.setDefaultFragmentBackground(backgroundRes);
258 | }
259 | }
260 |
--------------------------------------------------------------------------------
/fragmentation/src/main/java/com/weikaiyun/fragmentation/SupportActivityDelegate.java:
--------------------------------------------------------------------------------
1 | package com.weikaiyun.fragmentation;
2 |
3 | import android.os.Bundle;
4 |
5 | import androidx.annotation.DrawableRes;
6 | import androidx.annotation.NonNull;
7 | import androidx.annotation.Nullable;
8 | import androidx.core.app.ActivityCompat;
9 | import androidx.fragment.app.Fragment;
10 | import androidx.fragment.app.FragmentActivity;
11 | import androidx.fragment.app.FragmentManager;
12 |
13 | import com.weikaiyun.fragmentation.animation.FragmentAnimator;
14 | import com.weikaiyun.fragmentation.debug.DebugStackDelegate;
15 | import com.weikaiyun.fragmentation.queue.Action;
16 |
17 | import java.util.List;
18 |
19 | public class SupportActivityDelegate {
20 | private final ISupportActivity mSupport;
21 | private final FragmentActivity mActivity;
22 |
23 | private TransactionDelegate mTransactionDelegate;
24 |
25 | private final DebugStackDelegate mDebugStackDelegate;
26 |
27 | private int mDefaultFragmentBackground = 0;
28 |
29 | private FragmentAnimator mFragmentAnimator = new FragmentAnimator();
30 |
31 | static final String S_FRAGMENTATION_FRAGMENT_ANIMATOR = "s_fragmentation_fragment_animator";
32 |
33 | public SupportActivityDelegate(ISupportActivity support) {
34 | if (!(support instanceof FragmentActivity))
35 | throw new RuntimeException("Must extends FragmentActivity/AppCompatActivity");
36 | this.mSupport = support;
37 | this.mActivity = (FragmentActivity) support;
38 | this.mDebugStackDelegate = new DebugStackDelegate(this.mActivity);
39 | }
40 |
41 | /**
42 | * Perform some extra transactions.
43 | * 额外的事务：自定义Tag，操作非回退栈Fragment
44 | */
45 | public ExtraTransaction extraTransaction() {
46 |
47 | return new ExtraTransaction.ExtraTransactionImpl<>((FragmentActivity) mSupport,
48 | getTopFragment(), getTransactionDelegate(), true);
49 | }
50 |
51 | public void onCreate(@Nullable Bundle savedInstanceState) {
52 | if (savedInstanceState != null) {
53 | FragmentAnimator animator = savedInstanceState.getParcelable(S_FRAGMENTATION_FRAGMENT_ANIMATOR);
54 | if (animator != null) {
55 | mFragmentAnimator = animator;
56 | }
57 | }
58 | mTransactionDelegate = getTransactionDelegate();
59 | mDebugStackDelegate.onCreate(Fragmentation.getDefault().getMode());
60 | }
61 |
62 | public void onSaveInstanceState(@NonNull Bundle outState) {
63 | outState.putParcelable(S_FRAGMENTATION_FRAGMENT_ANIMATOR, mFragmentAnimator);
64 | }
65 |
66 | public void onPostCreate(@Nullable Bundle savedInstanceState) {
67 | mDebugStackDelegate.onPostCreate(Fragmentation.getDefault().getMode());
68 | }
69 |
70 | public void onDestroy() {
71 | mDebugStackDelegate.onDestroy();
72 | }
73 |
74 | public TransactionDelegate getTransactionDelegate() {
75 | if (mTransactionDelegate == null) {
76 | mTransactionDelegate = new TransactionDelegate(mSupport);
77 | }
78 | return mTransactionDelegate;
79 | }
80 |
81 | /**
82 | * Causes the Runnable r to be added to the action queue.
83 | *
84 | * The runnable will be run after all the previous action has been run.
85 | *
86 | * 前面的事务全部执行后 执行该Action
87 | */
88 | public void post(final Runnable runnable) {
89 | mTransactionDelegate.post(runnable);
90 | }
91 |
92 | /**
93 | * 不建议复写该方法,请使用 {@link #onBackPressedSupport} 代替
94 | */
95 | public void onBackPressed() {
96 | mTransactionDelegate.mActionQueue.enqueue(new Action(Action.ACTION_BACK) {
97 | @Override
98 | public void run() {
99 | // 获取activeFragment:即从栈顶开始 状态为show的那个Fragment
100 | ISupportFragment activeFragment =
101 | SupportHelper.getActiveFragment(getSupportFragmentManager());
102 |
103 | if (mTransactionDelegate.dispatchBackPressedEvent(activeFragment)) return;
104 |
105 | mSupport.onBackPressedSupport();
106 | }
107 | });
108 | }
109 |
110 | /**
111 | * 该方法回调时机为,Activity回退栈内Fragment的数量 小于等于1 时,默认finish Activity
112 | * 请尽量复写该方法,避免复写onBackPress(),以保证SupportFragment内的onBackPressedSupport()回退事件正常执行
113 | */
114 | public void onBackPressedSupport() {
115 | List list = SupportHelper.getActiveFragments(getSupportFragmentManager());
116 | int fragmentNum = 0;
117 | for (Fragment f : list) {
118 | if (f instanceof ISupportFragment
119 | && ((ISupportFragment) f).getSupportDelegate().isCanPop()
120 | && ((ISupportFragment) f).getSupportDelegate().isStartByFragmentation()) {
121 | fragmentNum++;
122 | }
123 | }
124 | if (fragmentNum > 0) {
125 | pop();
126 | } else {
127 | ActivityCompat.finishAfterTransition(mActivity);
128 | }
129 | }
130 |
131 | public FragmentAnimator getFragmentAnimator() {
132 | return mFragmentAnimator;
133 | }
134 |
135 | public void setFragmentAnimator(FragmentAnimator mFragmentAnimator) {
136 | this.mFragmentAnimator = mFragmentAnimator;
137 | }
138 |
139 | /**
140 | * 加载根Fragment, 即Activity内的第一个Fragment 或 Fragment内的第一个子Fragment
141 | */
142 |
143 | public void loadRootFragment(int containerId, ISupportFragment toFragment) {
144 |
145 | mTransactionDelegate.loadRootTransaction(getSupportFragmentManager(),
146 | containerId, toFragment);
147 | }
148 |
149 | /**
150 | * 加载多个同级根Fragment,类似Wechat, QQ主页的场景
151 | */
152 | public void loadMultipleRootFragment(int containerId, int showPosition, ISupportFragment... toFragments) {
153 |
154 | mTransactionDelegate.loadMultipleRootTransaction(getSupportFragmentManager(),
155 | containerId, showPosition, toFragments);
156 | }
157 |
158 | /**
159 | * 这个的使用必须要注意
160 | * show一个Fragment,hide其他同栈所有Fragment
161 | * 使用该方法时，要确保同级栈内无多余的Fragment,(只有通过loadMultipleRootFragment()载入的Fragment)
162 | *
163 | *
164 | * 建议使用更明确的{@link #showHideFragment(ISupportFragment, ISupportFragment)}
165 | *
166 | * @param showFragment 需要show的Fragment
167 | */
168 | public void showHideFragment(ISupportFragment showFragment) {
169 | showHideFragment(showFragment, null);
170 | }
171 |
172 | /**
173 | * show一个Fragment,hide一个Fragment
174 | *
175 | * @param showFragment 需要show的Fragment
176 | * @param hideFragment 需要hide的Fragment
177 | */
178 | public void showHideFragment(ISupportFragment showFragment, ISupportFragment hideFragment) {
179 |
180 | mTransactionDelegate.showHideFragment(getSupportFragmentManager(), showFragment, hideFragment);
181 | }
182 |
183 | public void start(ISupportFragment toFragment) {
184 | start(toFragment, ISupportFragment.STANDARD);
185 | }
186 |
187 | /**
188 | * @param launchMode Similar to Activity's LaunchMode.
189 | */
190 | public void start(ISupportFragment toFragment, @ISupportFragment.LaunchMode int launchMode) {
191 |
192 | mTransactionDelegate.dispatchStartTransaction(getSupportFragmentManager(),
193 | getTopFragment(), toFragment, 0, launchMode, TransactionDelegate.TYPE_ADD);
194 | }
195 |
196 | /**
197 | * Launch an fragment for which you would like a result when it popped.
198 | */
199 | public void startForResult(ISupportFragment toFragment, int requestCode) {
200 |
201 | mTransactionDelegate.dispatchStartTransaction(getSupportFragmentManager(),
202 | getTopFragment(), toFragment, requestCode, ISupportFragment.STANDARD,
203 | TransactionDelegate.TYPE_ADD_RESULT);
204 | }
205 |
206 | /**
207 | * Start the target Fragment and pop itself
208 | */
209 | public void startWithPop(ISupportFragment toFragment) {
210 | mTransactionDelegate.dispatchStartWithPopTransaction(getSupportFragmentManager(), getTopFragment(), toFragment);
211 | }
212 |
213 | public void startWithPopTo(ISupportFragment toFragment, Class targetFragmentClass,
214 | boolean includeTargetFragment) {
215 |
216 | mTransactionDelegate.dispatchStartWithPopToTransaction(getSupportFragmentManager(),
217 | getTopFragment(), toFragment, targetFragmentClass.getName(), includeTargetFragment);
218 | }
219 |
220 | public void replaceFragment(ISupportFragment toFragment) {
221 |
222 | mTransactionDelegate.dispatchStartTransaction(getSupportFragmentManager(),
223 | getTopFragment(), toFragment, 0, ISupportFragment.STANDARD,
224 | TransactionDelegate.TYPE_REPLACE);
225 | }
226 |
227 | /**
228 | * Pop the child fragment.
229 | */
230 | public void pop() {
231 | mTransactionDelegate.pop(getSupportFragmentManager());
232 | }
233 |
234 | /**
235 | * Pop the last fragment transition from the manager's fragment
236 | * back stack.
237 | *
238 | * 出栈到目标fragment
239 | *
240 | * @param targetFragmentClass 目标fragment
241 | * @param includeTargetFragment 是否包含该fragment
242 | */
243 | public void popTo(Class targetFragmentClass, boolean includeTargetFragment) {
244 | popTo(targetFragmentClass, includeTargetFragment, null);
245 | }
246 |
247 | /**
248 | * If you want to begin another FragmentTransaction immediately after popTo(), use this method.
249 | * 如果你想在出栈后, 立刻进行FragmentTransaction操作，请使用该方法
250 | */
251 |
252 | public void popTo(Class targetFragmentClass, boolean includeTargetFragment,
253 | Runnable afterPopTransactionRunnable) {
254 |
255 | mTransactionDelegate.popTo(targetFragmentClass.getName(), includeTargetFragment,
256 | afterPopTransactionRunnable, getSupportFragmentManager());
257 | }
258 |
259 | private FragmentManager getSupportFragmentManager() {
260 | return mActivity.getSupportFragmentManager();
261 | }
262 |
263 | private ISupportFragment getTopFragment() {
264 | return SupportHelper.getTopFragment(getSupportFragmentManager());
265 | }
266 |
267 | /**
268 | * 当Fragment根布局 没有设定background属性时,
269 | * Fragmentation默认使用Theme的android:windowbackground作为Fragment的背景,
270 | * 可以通过该方法改变Fragment背景。
271 | */
272 | public void setDefaultFragmentBackground(@DrawableRes int backgroundRes) {
273 | mDefaultFragmentBackground = backgroundRes;
274 | }
275 |
276 | public int getDefaultFragmentBackground() {
277 | return mDefaultFragmentBackground;
278 | }
279 | }
280 |
--------------------------------------------------------------------------------
/fragmentation/src/main/java/com/weikaiyun/fragmentation/SupportFragment.java:
--------------------------------------------------------------------------------
1 | package com.weikaiyun.fragmentation;
2 |
3 | import android.app.Activity;
4 | import android.content.Context;
5 | import android.content.Intent;
6 | import android.os.Bundle;
7 | import android.view.View;
8 | import android.view.animation.Animation;
9 | import android.view.animation.AnimationUtils;
10 |
11 | import androidx.annotation.NonNull;
12 | import androidx.annotation.Nullable;
13 | import androidx.fragment.app.Fragment;
14 |
15 |
16 | /**
17 | * Base class for activities that use the support-based
18 | * {@link ISupportFragment} and
19 | * {@link Fragment} APIs.
20 | */
21 | abstract public class SupportFragment extends Fragment implements ISupportFragment {
22 | final SupportFragmentDelegate mDelegate = new SupportFragmentDelegate(this);
23 | protected SupportActivity _mActivity;
24 |
25 | private boolean isLoaded;
26 |
27 | @Nullable
28 | @Override
29 | public Animation onCreateAnimation(final int transit, final boolean enter, int nextAnim) {
30 | if (nextAnim > 0) {
31 | Animation anim = AnimationUtils.loadAnimation(_mActivity, nextAnim);
32 | anim.setAnimationListener(new Animation.AnimationListener() {
33 | @Override
34 | public void onAnimationStart(Animation animation) {
35 |
36 | }
37 |
38 | @Override
39 | public void onAnimationEnd(Animation animation) {
40 | if (enter) {
41 | onEnterAnimationEnd();
42 | }
43 | }
44 |
45 | @Override
46 | public void onAnimationRepeat(Animation animation) {
47 |
48 | }
49 | });
50 |
51 | return anim;
52 | }
53 | return super.onCreateAnimation(transit, enter, nextAnim);
54 | }
55 |
56 | @Override
57 | public SupportFragmentDelegate getSupportDelegate() {
58 | return mDelegate;
59 | }
60 |
61 | /**
62 | * Perform some extra transactions.
63 | * 额外的事务：自定义Tag，添加SharedElement动画，操作非回退栈Fragment
64 | */
65 | @Override
66 | public ExtraTransaction extraTransaction() {
67 | return mDelegate.extraTransaction();
68 | }
69 |
70 | @Override
71 | public void onAttach(@NonNull Context context) {
72 | super.onAttach(context);
73 | mDelegate.onAttach(context);
74 | _mActivity = (SupportActivity) mDelegate.getActivity();
75 | }
76 |
77 | @Override
78 | public void onCreate(@Nullable Bundle savedInstanceState) {
79 | super.onCreate(savedInstanceState);
80 | mDelegate.onCreate(savedInstanceState);
81 | }
82 |
83 | @Override
84 | public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
85 | super.onViewCreated(view, savedInstanceState);
86 | mDelegate.onViewCreated(savedInstanceState);
87 | }
88 |
89 | @Override
90 | public void onSaveInstanceState(@NonNull Bundle outState) {
91 | super.onSaveInstanceState(outState);
92 | mDelegate.onSaveInstanceState(outState);
93 | }
94 |
95 | @Override
96 | public void onResume() {
97 | super.onResume();
98 | if (!getSupportDelegate().hasEnterAnimation) {
99 | onRealResume();
100 | }
101 | }
102 |
103 | @Override
104 | public void onPause() {
105 | super.onPause();
106 | getSupportDelegate().setVisible(false);
107 | onInvisible();
108 | }
109 |
110 | @Override
111 | public void lazyInit() {
112 |
113 | }
114 |
115 | @Override
116 | public void onVisible() {
117 |
118 | }
119 |
120 | @Override
121 | public void onInvisible() {
122 |
123 | }
124 |
125 | private void onEnterAnimationEnd() {
126 | onRealResume();
127 | getSupportDelegate().hasEnterAnimation = false;
128 | }
129 |
130 | private void onRealResume() {
131 | if (!isLoaded && !isHidden()) {
132 | lazyInit();
133 | isLoaded = true;
134 | }
135 |
136 | if (!isHidden()) {
137 | getSupportDelegate().setVisible(true);
138 | onVisible();
139 | }
140 | }
141 |
142 | @Override
143 | public void onDestroyView() {
144 | super.onDestroyView();
145 | isLoaded = false;
146 | }
147 |
148 | @Override
149 | public void onDestroy() {
150 | mDelegate.onDestroy();
151 | super.onDestroy();
152 | }
153 |
154 | /**
155 | * Causes the Runnable r to be added to the action queue.
156 | *
157 | * The runnable will be run after all the previous action has been run.
158 | *
159 | * 前面的事务全部执行后 执行该Action
160 | */
161 | @Override
162 | public void post(Runnable runnable) {
163 | mDelegate.post(runnable);
164 | }
165 |
166 | /**
167 | * 按返回键触发,前提是SupportActivity的onBackPressed()方法能被调用
168 | *
169 | * @return false则继续向上传递, true则消费掉该事件
170 | */
171 | @Override
172 | public boolean onBackPressedSupport() {
173 | return mDelegate.onBackPressedSupport();
174 | }
175 |
176 | /**
177 | * 类似 {@link Activity#setResult(int, Intent)}
178 | *
179 | * Similar to {@link Activity#setResult(int, Intent)}
180 | *
181 | * @see #startForResult(ISupportFragment, int)
182 | */
183 | @Override
184 | public void setFragmentResult(int resultCode, Bundle bundle) {
185 | mDelegate.setFragmentResult(resultCode, bundle);
186 | }
187 |
188 | /**
189 | * 类似Activity.onActivityResult(int, int, Intent)
190 | *
191 | * @see #startForResult(ISupportFragment, int)
192 | */
193 | @Override
194 | public void onFragmentResult(int requestCode, int resultCode, Bundle data) {
195 |
196 | }
197 |
198 | /**
199 | * 在start(TargetFragment,LaunchMode)时,启动模式为SingleTask/SingleTop, 回调TargetFragment的该方法
200 | * 类似 Activity.onNewIntent(Intent)
201 | *
202 | * @param args putNewBundle(Bundle newBundle)
203 | * @see #start(ISupportFragment, int)
204 | */
205 | @Override
206 | public void onNewBundle(Bundle args) {
207 |
208 | }
209 |
210 | /**
211 | * 添加NewBundle,用于启动模式为SingleTask/SingleTop时
212 | *
213 | * @see #start(ISupportFragment, int)
214 | */
215 | @Override
216 | public void putNewBundle(Bundle newBundle) {
217 | mDelegate.putNewBundle(newBundle);
218 | }
219 |
220 |
221 | /**
222 | * 隐藏软键盘
223 | */
224 | protected void hideSoftInput() {
225 | mDelegate.hideSoftInput();
226 | }
227 |
228 | /**
229 | * 显示软键盘
230 | */
231 | protected void showSoftInput(final View view) {
232 | mDelegate.showSoftInput(view);
233 | }
234 |
235 | /**
236 | * 加载根Fragment, 即Fragment内的第一个子Fragment
237 | *
238 | * @param containerId 容器id
239 | * @param toFragment 目标Fragment
240 | */
241 | public void loadRootFragment(int containerId, ISupportFragment toFragment) {
242 | mDelegate.loadRootFragment(containerId, toFragment);
243 | }
244 |
245 | /**
246 | * 加载多个同级根Fragment
247 | */
248 | public void loadMultipleRootFragment(int containerId, int showPosition, ISupportFragment... toFragments) {
249 | mDelegate.loadMultipleRootFragment(containerId, showPosition, toFragments);
250 | }
251 |
252 | /**
253 | * show一个Fragment,hide其他同栈所有Fragment
254 | * 使用该方法时，要确保同级栈内无多余的Fragment(只有通过loadMultipleRootFragment()载入的Fragment)
255 | *
256 | * 建议使用更明确的{@link #showHideFragment(ISupportFragment, ISupportFragment)}
257 | *
258 | * @param showFragment 需要show的Fragment
259 | */
260 | public void showHideFragment(ISupportFragment showFragment) {
261 | mDelegate.showHideFragment(showFragment);
262 | }
263 |
264 | /**
265 | * show一个Fragment,hide一个Fragment ; 主要用于类似微信主页那种 切换tab的情况
266 | */
267 | public void showHideFragment(ISupportFragment showFragment, ISupportFragment hideFragment) {
268 | mDelegate.showHideFragment(showFragment, hideFragment);
269 | }
270 |
271 | public void start(ISupportFragment toFragment) {
272 | mDelegate.start(toFragment);
273 | }
274 |
275 | /**
276 | * @param launchMode Similar to Activity's LaunchMode.
277 | */
278 | public void start(final ISupportFragment toFragment, @LaunchMode int launchMode) {
279 | mDelegate.start(toFragment, launchMode);
280 | }
281 |
282 | /**
283 | * Launch an fragment for which you would like a result when it popped.
284 | */
285 | public void startForResult(ISupportFragment toFragment, int requestCode) {
286 | mDelegate.startForResult(toFragment, requestCode);
287 | }
288 |
289 | /**
290 | * Start the target Fragment and pop itself
291 | */
292 | public void startWithPop(ISupportFragment toFragment) {
293 | mDelegate.startWithPop(toFragment);
294 | }
295 |
296 | /**
297 | * @see #popTo(Class, boolean)
298 | * +
299 | * @see #start(ISupportFragment)
300 | */
301 | public void startWithPopTo(ISupportFragment toFragment, Class targetFragmentClass, boolean includeTargetFragment) {
302 | mDelegate.startWithPopTo(toFragment, targetFragmentClass, includeTargetFragment);
303 | }
304 |
305 |
306 |
307 | public void replaceFragment(ISupportFragment toFragment) {
308 | mDelegate.replaceFragment(toFragment);
309 | }
310 |
311 | public void pop() {
312 | mDelegate.pop();
313 | }
314 |
315 | public void popQuiet() {
316 | mDelegate.popQuiet();
317 | }
318 |
319 | /**
320 | * Pop the last fragment transition from the manager's fragment
321 | * back stack.
322 | *
323 | * 出栈到目标fragment
324 | *
325 | * @param targetFragmentClass 目标fragment
326 | * @param includeTargetFragment 是否包含该fragment
327 | */
328 | public void popTo(Class targetFragmentClass, boolean includeTargetFragment) {
329 | mDelegate.popTo(targetFragmentClass, includeTargetFragment);
330 | }
331 |
332 | /**
333 | * If you want to begin another FragmentTransaction immediately after popTo(), use this method.
334 | * 如果你想在出栈后, 立刻进行FragmentTransaction操作，请使用该方法
335 | */
336 | public void popTo(Class targetFragmentClass, boolean includeTargetFragment, Runnable afterPopTransactionRunnable) {
337 | mDelegate.popTo(targetFragmentClass, includeTargetFragment, afterPopTransactionRunnable);
338 | }
339 |
340 |
341 |
342 |
343 | public void startChild(ISupportFragment toFragment) {
344 | mDelegate.startChild(toFragment);
345 | }
346 |
347 | public void startChild(final ISupportFragment toFragment, @ISupportFragment.LaunchMode int launchMode) {
348 | mDelegate.startChild(toFragment, launchMode);
349 | }
350 |
351 | public void startChildForResult(ISupportFragment toFragment, int requestCode) {
352 | mDelegate.startChildForResult(toFragment, requestCode);
353 | }
354 |
355 | public void startChildWithPop(ISupportFragment toFragment) {
356 | mDelegate.startChildWithPop(toFragment);
357 | }
358 |
359 | public void replaceChildFragment(ISupportFragment toFragment) {
360 | mDelegate.replaceChildFragment(toFragment);
361 | }
362 |
363 | /**
364 | * Pop the child fragment.
365 | */
366 | public void popChild() {
367 | mDelegate.popChild();
368 | }
369 |
370 | public void popToChild(Class targetFragmentClass, boolean includeTargetFragment) {
371 | mDelegate.popToChild(targetFragmentClass, includeTargetFragment);
372 | }
373 |
374 | public void popToChild(Class targetFragmentClass, boolean includeTargetFragment, Runnable afterPopTransactionRunnable) {
375 | mDelegate.popToChild(targetFragmentClass, includeTargetFragment, afterPopTransactionRunnable);
376 | }
377 |
378 | /**
379 | * 得到位于栈顶Fragment
380 | */
381 | public ISupportFragment getTopFragment() {
382 | return SupportHelper.getTopFragment(getParentFragmentManager());
383 | }
384 |
385 | /**
386 | * 得到位于子栈顶Fragment
387 | */
388 | public ISupportFragment getTopChildFragment() {
389 | return SupportHelper.getTopFragment(getChildFragmentManager());
390 | }
391 |
392 | /**
393 | * @return 位于当前Fragment的前一个Fragment
394 | */
395 | public ISupportFragment getPreFragment() {
396 | return SupportHelper.getPreFragment(this);
397 | }
398 |
399 | /**
400 | * 获取栈内的fragment对象
401 | */
402 | public T findFragment(Class fragmentClass) {
403 | return SupportHelper.findFragment(getParentFragmentManager(), fragmentClass);
404 | }
405 |
406 | /**
407 | * 获取子栈内的fragment对象
408 | */
409 | public T findChildFragment(Class fragmentClass) {
410 | return SupportHelper.findFragment(getChildFragmentManager(), fragmentClass);
411 | }
412 | }
413 |
--------------------------------------------------------------------------------
/fragmentation/src/main/java/com/weikaiyun/fragmentation/SupportFragmentDelegate.java:
--------------------------------------------------------------------------------
1 | package com.weikaiyun.fragmentation;
2 |
3 | import android.app.Activity;
4 | import android.content.Context;
5 | import android.content.Intent;
6 | import android.content.res.TypedArray;
7 | import android.os.Bundle;
8 | import android.view.View;
9 |
10 | import androidx.annotation.NonNull;
11 | import androidx.annotation.Nullable;
12 | import androidx.fragment.app.Fragment;
13 | import androidx.fragment.app.FragmentActivity;
14 | import androidx.fragment.app.FragmentManager;
15 |
16 | import com.weikaiyun.fragmentation.record.ResultRecord;
17 | import com.weikaiyun.fragmentation.record.TransactionRecord;
18 |
19 | public class SupportFragmentDelegate {
20 | static final String S_FRAGMENTATION_FRAGMENT_VISIBLE_PROP = "s_fragmentation_fragment_visible_prop";
21 | static final String S_FRAGMENTATION_FRAGMENT_POP_PROP = "s_fragmentation_fragment_pop_prop";
22 | static final String S_FRAGMENTATION_FRAGMENT_START_PROP = "s_fragmentation_fragment_start_prop";
23 |
24 | int mContainerId;
25 |
26 | private TransactionDelegate mTransactionDelegate;
27 | TransactionRecord mTransactionRecord;
28 | Bundle mNewBundle;
29 |
30 | private final ISupportFragment mSupportF;
31 | private final Fragment mFragment;
32 | protected FragmentActivity _mActivity;
33 | private ISupportActivity mSupport;
34 |
35 | private boolean isVisible = false;
36 |
37 | boolean hasEnterAnimation = false;
38 |
39 | private boolean canPop = true;
40 |
41 | private boolean startByFragmentation = false;
42 |
43 | public boolean hasEnterAnimation() {
44 | return hasEnterAnimation;
45 | }
46 |
47 | public void setHasEnterAnimation(boolean hasEnterAnimation) {
48 | this.hasEnterAnimation = hasEnterAnimation;
49 | }
50 |
51 | public void setCanPop(boolean canPop) {
52 | this.canPop = canPop;
53 | }
54 |
55 | public boolean isCanPop() {
56 | return canPop;
57 | }
58 |
59 | public boolean isStartByFragmentation() {
60 | return startByFragmentation;
61 | }
62 |
63 | public void setStartByFragmentation(boolean startByFragmentation) {
64 | this.startByFragmentation = startByFragmentation;
65 | }
66 |
67 | public void setVisible(boolean visible) {
68 | isVisible = visible;
69 | }
70 |
71 | public boolean isVisible() {
72 | return isVisible;
73 | }
74 |
75 | public SupportFragmentDelegate(ISupportFragment support) {
76 | if (!(support instanceof Fragment))
77 | throw new RuntimeException("Must extends Fragment");
78 | this.mSupportF = support;
79 | this.mFragment = (Fragment) support;
80 | }
81 |
82 | /**
83 | * Perform some extra transactions.
84 | * 额外的事务：自定义Tag，添加SharedElement动画，操作非回退栈Fragment
85 | */
86 | public ExtraTransaction extraTransaction() {
87 | if (mTransactionDelegate == null)
88 | throw new RuntimeException(mFragment.getClass().getSimpleName() + " not attach!");
89 |
90 | return new ExtraTransaction.ExtraTransactionImpl<>((FragmentActivity) mSupport,
91 | mSupportF, mTransactionDelegate, false);
92 | }
93 |
94 | public void onAttach(Context context) {
95 | if (context instanceof ISupportActivity) {
96 | this.mSupport = (ISupportActivity) context;
97 | this._mActivity = (FragmentActivity) context;
98 | mTransactionDelegate = mSupport.getSupportDelegate().getTransactionDelegate();
99 | } else {
100 | throw new RuntimeException(context.getClass().getSimpleName() + " must impl ISupportActivity!");
101 | }
102 | }
103 |
104 | public void onCreate(@Nullable Bundle savedInstanceState) {
105 | if(savedInstanceState != null) {
106 | startByFragmentation = savedInstanceState.getBoolean(S_FRAGMENTATION_FRAGMENT_START_PROP, false);
107 | isVisible = savedInstanceState.getBoolean(S_FRAGMENTATION_FRAGMENT_VISIBLE_PROP, false);
108 | canPop = savedInstanceState.getBoolean(S_FRAGMENTATION_FRAGMENT_POP_PROP, true);
109 | }
110 | Bundle bundle = mFragment.getArguments();
111 | if (bundle != null) {
112 | mContainerId = bundle.getInt(TransactionDelegate.FRAGMENTATION_ARG_CONTAINER);
113 | }
114 | }
115 |
116 | public void onViewCreated(@Nullable Bundle savedInstanceState) {
117 | View view = mFragment.getView();
118 | if (view != null) {
119 | setBackground(view);
120 | }
121 | }
122 |
123 | public void onSaveInstanceState(@NonNull Bundle outState) {
124 | outState.putBoolean(S_FRAGMENTATION_FRAGMENT_START_PROP, startByFragmentation);
125 | outState.putBoolean(S_FRAGMENTATION_FRAGMENT_POP_PROP, canPop);
126 | outState.putBoolean(S_FRAGMENTATION_FRAGMENT_VISIBLE_PROP, isVisible);
127 | }
128 |
129 | public void setBackground(View view) {
130 | if (view.getBackground() != null) {
131 | return;
132 | }
133 |
134 | int defaultBg = mSupport.getSupportDelegate().getDefaultFragmentBackground();
135 | if (defaultBg == 0) {
136 | int background = getWindowBackground();
137 | view.setBackgroundResource(background);
138 | } else {
139 | view.setBackgroundResource(defaultBg);
140 | }
141 | }
142 |
143 | private int getWindowBackground() {
144 | TypedArray a = _mActivity.getTheme().obtainStyledAttributes(new int[]{
145 | android.R.attr.windowBackground
146 | });
147 | int background = a.getResourceId(0, 0);
148 | a.recycle();
149 | return background;
150 | }
151 |
152 | public void onDestroy() {
153 | mTransactionDelegate.handleResultRecord(mFragment);
154 | }
155 |
156 | /**
157 | * Causes the Runnable r to be added to the action queue.
158 | *
159 | * The runnable will be run after all the previous action has been run.
160 | *
161 | * 前面的事务全部执行后 执行该Action
162 | */
163 | public void post(final Runnable runnable) {
164 | mTransactionDelegate.post(runnable);
165 | }
166 |
167 | /**
168 | * 类似 {@link Activity#setResult(int, Intent)}
169 | *
170 | * Similar to {@link Activity#setResult(int, Intent)}
171 | *
172 | * @see #startForResult(ISupportFragment, int)
173 | */
174 | public void setFragmentResult(int resultCode, Bundle bundle) {
175 | Bundle args = mFragment.getArguments();
176 | if (args == null || !args.containsKey(TransactionDelegate.FRAGMENTATION_ARG_RESULT_RECORD)) {
177 | return;
178 | }
179 |
180 | ResultRecord resultRecord = args.getParcelable(TransactionDelegate.FRAGMENTATION_ARG_RESULT_RECORD);
181 | if (resultRecord != null) {
182 | resultRecord.resultCode = resultCode;
183 | resultRecord.resultBundle = bundle;
184 | }
185 | }
186 |
187 | /**
188 | * 添加NewBundle,用于启动模式为SingleTask/SingleTop时
189 | *
190 | * @see #start(ISupportFragment, int)
191 | */
192 | public void putNewBundle(Bundle newBundle) {
193 | this.mNewBundle = newBundle;
194 | }
195 |
196 | /**
197 | * Back Event
198 | *
199 | * @return false则继续向上传递, true则消费掉该事件
200 | */
201 | public boolean onBackPressedSupport() {
202 | return false;
203 | }
204 |
205 |
206 | /**
207 | * 隐藏软键盘
208 | */
209 | public void hideSoftInput() {
210 | Activity activity = mFragment.getActivity();
211 | if (activity == null) return;
212 | View view = activity.getWindow().getDecorView();
213 | SupportHelper.hideSoftInput(view);
214 | }
215 |
216 | /**
217 | * 显示软键盘
218 | */
219 | public void showSoftInput(View view) {
220 | SupportHelper.showSoftInput(view);
221 | }
222 |
223 |
224 | /**
225 | * 加载根Fragment, 即Activity内的第一个Fragment 或 Fragment内的第一个子Fragment
226 | */
227 |
228 | public void loadRootFragment(int containerId, ISupportFragment toFragment) {
229 |
230 | mTransactionDelegate.loadRootTransaction(getChildFragmentManager(),
231 | containerId, toFragment);
232 | }
233 |
234 | /**
235 | * 加载多个同级根Fragment
236 | */
237 | public void loadMultipleRootFragment(int containerId, int showPosition,
238 | ISupportFragment... toFragments) {
239 |
240 | mTransactionDelegate.loadMultipleRootTransaction(getChildFragmentManager(),
241 | containerId, showPosition, toFragments);
242 | }
243 |
244 | /**
245 | * show一个Fragment,hide其他同栈所有Fragment
246 | * 使用该方法时，要确保同级栈内无多余的Fragment(只有通过loadMultipleRootFragment()载入的Fragment)
247 | *
248 | * 建议使用更明确的{@link #showHideFragment(ISupportFragment, ISupportFragment)}
249 | */
250 | public void showHideFragment(ISupportFragment showFragment) {
251 | showHideFragment(showFragment, null);
252 | }
253 |
254 | /**
255 | * show一个Fragment,hide一个Fragment
256 | */
257 | public void showHideFragment(ISupportFragment showFragment, ISupportFragment hideFragment) {
258 | mTransactionDelegate.showHideFragment(getChildFragmentManager(), showFragment, hideFragment);
259 | }
260 |
261 | public void start(ISupportFragment toFragment) {
262 | start(toFragment, ISupportFragment.STANDARD);
263 | }
264 |
265 | /**
266 | * @param launchMode Similar to Activity's LaunchMode.
267 | */
268 | public void start(final ISupportFragment toFragment, @ISupportFragment.LaunchMode int launchMode) {
269 |
270 | mTransactionDelegate.dispatchStartTransaction(mFragment.getParentFragmentManager(), mSupportF,
271 | toFragment, 0, launchMode, TransactionDelegate.TYPE_ADD);
272 | }
273 |
274 | /**
275 | * Launch an fragment for which you would like a result when it poped.
276 | */
277 | public void startForResult(ISupportFragment toFragment, int requestCode) {
278 |
279 | mTransactionDelegate.dispatchStartTransaction(mFragment.getParentFragmentManager(), mSupportF,
280 | toFragment, requestCode, ISupportFragment.STANDARD, TransactionDelegate.TYPE_ADD_RESULT);
281 | }
282 |
283 | /**
284 | * Start the target Fragment and pop itself
285 | */
286 | public void startWithPop(ISupportFragment toFragment) {
287 | mTransactionDelegate.dispatchStartWithPopTransaction(mFragment.getParentFragmentManager(), mSupportF, toFragment);
288 | }
289 |
290 | public void startWithPopTo(ISupportFragment toFragment, Class targetFragmentClass,
291 | boolean includeTargetFragment) {
292 |
293 | mTransactionDelegate.dispatchStartWithPopToTransaction(mFragment.getParentFragmentManager(), mSupportF,
294 | toFragment, targetFragmentClass.getName(), includeTargetFragment);
295 | }
296 |
297 | public void replaceFragment(ISupportFragment toFragment) {
298 |
299 | mTransactionDelegate.dispatchStartTransaction(mFragment.getParentFragmentManager(), mSupportF,
300 | toFragment, 0, ISupportFragment.STANDARD,
301 | TransactionDelegate.TYPE_REPLACE);
302 | }
303 |
304 | public void startChild(ISupportFragment toFragment) {
305 | startChild(toFragment, ISupportFragment.STANDARD);
306 | }
307 |
308 | public void startChild(final ISupportFragment toFragment, @ISupportFragment.LaunchMode int launchMode) {
309 |
310 | mTransactionDelegate.dispatchStartTransaction(getChildFragmentManager(), getChildTopFragment(),
311 | toFragment, 0, launchMode, TransactionDelegate.TYPE_ADD);
312 | }
313 |
314 | public void startChildForResult(ISupportFragment toFragment, int requestCode) {
315 |
316 | mTransactionDelegate.dispatchStartTransaction(getChildFragmentManager(), getChildTopFragment(),
317 | toFragment, requestCode, ISupportFragment.STANDARD, TransactionDelegate.TYPE_ADD_RESULT);
318 | }
319 |
320 | public void startChildWithPop(ISupportFragment toFragment) {
321 | mTransactionDelegate.dispatchStartWithPopTransaction(getChildFragmentManager(), getChildTopFragment(), toFragment);
322 | }
323 |
324 | public void replaceChildFragment(ISupportFragment toFragment) {
325 | mTransactionDelegate.dispatchStartTransaction(getChildFragmentManager(), getChildTopFragment(),
326 | toFragment, 0, ISupportFragment.STANDARD, TransactionDelegate.TYPE_REPLACE);
327 | }
328 |
329 | public void pop() {
330 | mTransactionDelegate.pop(mFragment.getParentFragmentManager());
331 | }
332 |
333 | public void popQuiet() {
334 | mTransactionDelegate.popQuiet(mFragment.getParentFragmentManager());
335 | }
336 |
337 | /**
338 | * Pop the child fragment.
339 | */
340 | public void popChild() {
341 | mTransactionDelegate.pop(getChildFragmentManager());
342 | }
343 |
344 | /**
345 | * Pop the last fragment transition from the manager's fragment
346 | * back stack.
347 | *
348 | * 出栈到目标fragment
349 | *
350 | * @param targetFragmentClass 目标fragment
351 | * @param includeTargetFragment 是否包含该fragment
352 | */
353 | public void popTo(Class targetFragmentClass, boolean includeTargetFragment) {
354 | popTo(targetFragmentClass, includeTargetFragment, null);
355 | }
356 |
357 | /**
358 | * If you want to begin another FragmentTransaction immediately after popTo(), use this method.
359 | * 如果你想在出栈后, 立刻进行FragmentTransaction操作，请使用该方法
360 | */
361 | public void popTo(Class targetFragmentClass, boolean includeTargetFragment,
362 | Runnable afterPopTransactionRunnable) {
363 |
364 | mTransactionDelegate.popTo(targetFragmentClass.getName(), includeTargetFragment,
365 | afterPopTransactionRunnable, mFragment.getParentFragmentManager());
366 | }
367 |
368 | public void popToChild(Class targetFragmentClass, boolean includeTargetFragment) {
369 | popToChild(targetFragmentClass, includeTargetFragment, null);
370 | }
371 |
372 | public void popToChild(Class targetFragmentClass, boolean includeTargetFragment,
373 | Runnable afterPopTransactionRunnable) {
374 |
375 | mTransactionDelegate.popTo(targetFragmentClass.getName(), includeTargetFragment,
376 | afterPopTransactionRunnable, getChildFragmentManager());
377 | }
378 |
379 | private FragmentManager getChildFragmentManager() {
380 | return mFragment.getChildFragmentManager();
381 | }
382 |
383 | private ISupportFragment getChildTopFragment() {
384 | return SupportHelper.getTopFragment(getChildFragmentManager());
385 | }
386 |
387 | public FragmentActivity getActivity() {
388 | return _mActivity;
389 | }
390 | }
--------------------------------------------------------------------------------
/fragmentation/src/main/java/com/weikaiyun/fragmentation/SupportHelper.java:
--------------------------------------------------------------------------------
1 | package com.weikaiyun.fragmentation;
2 |
3 | import android.content.Context;
4 | import android.view.View;
5 | import android.view.inputmethod.InputMethodManager;
6 |
7 | import androidx.fragment.app.Fragment;
8 | import androidx.fragment.app.FragmentManager;
9 |
10 | import java.util.ArrayList;
11 | import java.util.List;
12 |
13 | public class SupportHelper {
14 | private static final long SHOW_SPACE = 200L;
15 |
16 | private SupportHelper() {
17 | }
18 |
19 | /**
20 | * 显示软键盘
21 | */
22 | public static void showSoftInput(final View view) {
23 | if (view == null || view.getContext() == null) return;
24 | final InputMethodManager imm = (InputMethodManager) view.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
25 | view.requestFocus();
26 | view.postDelayed(new Runnable() {
27 | @Override
28 | public void run() {
29 | imm.showSoftInput(view, InputMethodManager.SHOW_FORCED);
30 | }
31 | }, SHOW_SPACE);
32 | }
33 |
34 | /**
35 | * 隐藏软键盘
36 | */
37 | public static void hideSoftInput(View view) {
38 | if (view == null || view.getContext() == null) return;
39 | InputMethodManager imm = (InputMethodManager) view.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
40 | imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
41 | }
42 |
43 | /**
44 | * 获得栈顶SupportFragment
45 | */
46 | public static ISupportFragment getTopFragment(FragmentManager fragmentManager) {
47 | return getTopFragment(fragmentManager, 0);
48 | }
49 |
50 | public static ISupportFragment getTopFragment(FragmentManager fragmentManager, int containerId) {
51 | List fragmentList = getActiveFragments(fragmentManager);
52 | for (int i = fragmentList.size() - 1; i >= 0; i--) {
53 | Fragment fragment = fragmentList.get(i);
54 | if (fragment instanceof ISupportFragment) {
55 | ISupportFragment iFragment = (ISupportFragment) fragment;
56 | if (containerId == 0) return iFragment;
57 |
58 | if (containerId == iFragment.getSupportDelegate().mContainerId) {
59 | return iFragment;
60 | }
61 | }
62 | }
63 | return null;
64 | }
65 |
66 | /**
67 | * 获取目标Fragment的前一个SupportFragment
68 | *
69 | * @param fragment 目标Fragment
70 | */
71 | public static ISupportFragment getPreFragment(Fragment fragment) {
72 | FragmentManager fragmentManager = fragment.getParentFragmentManager();
73 |
74 | List fragmentList = getActiveFragments(fragmentManager);
75 | int index = fragmentList.indexOf(fragment);
76 | for (int i = index - 1; i >= 0; i--) {
77 | Fragment preFragment = fragmentList.get(i);
78 | if (preFragment instanceof ISupportFragment) {
79 | return (ISupportFragment) preFragment;
80 | }
81 | }
82 | return null;
83 | }
84 |
85 | /**
86 | * Same as fragmentManager.findFragmentByTag(fragmentClass.getName());
87 | * find Fragment from FragmentStack
88 | */
89 | @SuppressWarnings("unchecked")
90 | public static T findFragment(FragmentManager fragmentManager, Class fragmentClass) {
91 | return findStackFragment(fragmentClass, null, fragmentManager);
92 | }
93 |
94 | /**
95 | * Same as fragmentManager.findFragmentByTag(fragmentTag);
96 | *
97 | * find Fragment from FragmentStack
98 | */
99 | @SuppressWarnings("unchecked")
100 | public static T findFragment(FragmentManager fragmentManager, String fragmentTag) {
101 | return findStackFragment(null, fragmentTag, fragmentManager);
102 | }
103 |
104 | /**
105 | * 从栈顶开始，寻找FragmentManager以及其所有子栈, 直到找到状态为show & userVisible的Fragment
106 | */
107 | public static ISupportFragment getActiveFragment(FragmentManager fragmentManager) {
108 | return getActiveFragment(fragmentManager, null);
109 | }
110 |
111 | @SuppressWarnings("unchecked")
112 | static T findStackFragment(Class fragmentClass, String toFragmentTag, FragmentManager fragmentManager) {
113 | Fragment fragment = null;
114 |
115 | if (toFragmentTag == null) {
116 | List fragmentList = getActiveFragments(fragmentManager);
117 |
118 | int sizeChildFrgList = fragmentList.size();
119 |
120 | for (int i = sizeChildFrgList - 1; i >= 0; i--) {
121 | Fragment brotherFragment = fragmentList.get(i);
122 | if (brotherFragment instanceof ISupportFragment && brotherFragment.getClass().getName().equals(fragmentClass.getName())) {
123 | fragment = brotherFragment;
124 | break;
125 | }
126 | }
127 | } else {
128 | fragment = fragmentManager.findFragmentByTag(toFragmentTag);
129 | if (fragment == null) return null;
130 | }
131 | return (T) fragment;
132 | }
133 |
134 | private static ISupportFragment getActiveFragment(FragmentManager fragmentManager, ISupportFragment parentFragment) {
135 | List fragmentList = getActiveFragments(fragmentManager);
136 | for (int i = fragmentList.size() - 1; i >= 0; i--) {
137 | Fragment fragment = fragmentList.get(i);
138 | if (fragment instanceof ISupportFragment) {
139 | if (fragment.isResumed() && !fragment.isHidden()) {
140 | return getActiveFragment(fragment.getChildFragmentManager(), (ISupportFragment) fragment);
141 | }
142 | }
143 | }
144 | return parentFragment;
145 | }
146 |
147 | static List getWillPopFragments(FragmentManager fm, String targetTag, boolean includeTarget) {
148 | Fragment target = fm.findFragmentByTag(targetTag);
149 | List willPopFragments = new ArrayList<>();
150 |
151 | List fragmentList = getActiveFragments(fm);
152 |
153 | int size = fragmentList.size();
154 |
155 | int startIndex = -1;
156 | for (int i = size - 1; i >= 0; i--) {
157 | if (target == fragmentList.get(i)) {
158 | if (includeTarget) {
159 | startIndex = i;
160 | } else if (i + 1 < size) {
161 | startIndex = i + 1;
162 | }
163 | break;
164 | }
165 | }
166 |
167 | if (startIndex == -1) return willPopFragments;
168 |
169 | for (int i = size - 1; i >= startIndex; i--) {
170 | Fragment fragment = fragmentList.get(i);
171 | if (fragment != null && fragment.getView() != null) {
172 | willPopFragments.add(fragment);
173 | }
174 | }
175 | return willPopFragments;
176 | }
177 |
178 | public static List getActiveFragments(FragmentManager fragmentManager) {
179 | return fragmentManager.getFragments();
180 | }
181 | }
182 |
--------------------------------------------------------------------------------
/fragmentation/src/main/java/com/weikaiyun/fragmentation/animation/FragmentAnimator.java:
--------------------------------------------------------------------------------
1 | package com.weikaiyun.fragmentation.animation;
2 |
3 | import android.os.Parcel;
4 | import android.os.Parcelable;
5 |
6 | import androidx.annotation.AnimRes;
7 |
8 | /**
9 | * Fragment动画实体类
10 | */
11 | public class FragmentAnimator implements Parcelable {
12 | @AnimRes
13 | protected int targetFragmentEnter;
14 | @AnimRes
15 | protected int currentFragmentPopExit;
16 | @AnimRes
17 | protected int currentFragmentPopEnter;
18 | @AnimRes
19 | protected int targetFragmentExit;
20 |
21 | public FragmentAnimator() {
22 | }
23 |
24 | public FragmentAnimator(int targetFragmentEnter, int currentFragmentPopExit, int currentFragmentPopEnter, int targetFragmentExit) {
25 | this.targetFragmentEnter = targetFragmentEnter;
26 | this.currentFragmentPopExit = currentFragmentPopExit;
27 | this.currentFragmentPopEnter = currentFragmentPopEnter;
28 | this.targetFragmentExit = targetFragmentExit;
29 | }
30 |
31 | protected FragmentAnimator(Parcel in) {
32 | targetFragmentEnter = in.readInt();
33 | currentFragmentPopExit = in.readInt();
34 | currentFragmentPopEnter = in.readInt();
35 | targetFragmentExit = in.readInt();
36 | }
37 |
38 | public static final Creator CREATOR = new Creator() {
39 | @Override
40 | public FragmentAnimator createFromParcel(Parcel in) {
41 | return new FragmentAnimator(in);
42 | }
43 |
44 | @Override
45 | public FragmentAnimator[] newArray(int size) {
46 | return new FragmentAnimator[size];
47 | }
48 | };
49 |
50 | public int getTargetFragmentEnter() {
51 | return targetFragmentEnter;
52 | }
53 |
54 | public int getCurrentFragmentPopExit() {
55 | return currentFragmentPopExit;
56 | }
57 |
58 | public int getCurrentFragmentPopEnter() {
59 | return currentFragmentPopEnter;
60 | }
61 |
62 | public int getTargetFragmentExit() {
63 | return targetFragmentExit;
64 | }
65 |
66 | public FragmentAnimator setTargetFragmentEnter(int targetFragmentEnter) {
67 | this.targetFragmentEnter = targetFragmentEnter;
68 | return this;
69 | }
70 |
71 | public FragmentAnimator setCurrentFragmentPopExit(int currentFragmentPopExit) {
72 | this.currentFragmentPopExit = currentFragmentPopExit;
73 | return this;
74 | }
75 |
76 | public FragmentAnimator setCurrentFragmentPopEnter(int currentFragmentPopEnter) {
77 | this.currentFragmentPopEnter = currentFragmentPopEnter;
78 | return this;
79 | }
80 |
81 | public FragmentAnimator setTargetFragmentExit(int targetFragmentExit) {
82 | this.targetFragmentExit = targetFragmentExit;
83 | return this;
84 | }
85 |
86 | @Override
87 | public int describeContents() {
88 | return 0;
89 | }
90 |
91 | @Override
92 | public void writeToParcel(Parcel dest, int flags) {
93 | dest.writeInt(targetFragmentEnter);
94 | dest.writeInt(currentFragmentPopExit);
95 | dest.writeInt(currentFragmentPopEnter);
96 | dest.writeInt(targetFragmentExit);
97 | }
98 | }
99 |
--------------------------------------------------------------------------------
/fragmentation/src/main/java/com/weikaiyun/fragmentation/debug/DebugFragmentRecord.java:
--------------------------------------------------------------------------------
1 | package com.weikaiyun.fragmentation.debug;
2 |
3 | import java.util.List;
4 |
5 | /**
6 | * 为了调试时 查看栈视图
7 | */
8 | public class DebugFragmentRecord {
9 | public CharSequence fragmentName;
10 | public List childFragmentRecord;
11 |
12 | public DebugFragmentRecord(CharSequence fragmentName, List childFragmentRecord) {
13 | this.fragmentName = fragmentName;
14 | this.childFragmentRecord = childFragmentRecord;
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/fragmentation/src/main/java/com/weikaiyun/fragmentation/debug/DebugHierarchyViewContainer.java:
--------------------------------------------------------------------------------
1 | package com.weikaiyun.fragmentation.debug;
2 |
3 | import android.content.Context;
4 | import android.content.res.TypedArray;
5 | import android.graphics.Color;
6 | import android.util.AttributeSet;
7 | import android.view.Gravity;
8 | import android.view.View;
9 | import android.view.ViewGroup;
10 | import android.widget.HorizontalScrollView;
11 | import android.widget.ImageView;
12 | import android.widget.LinearLayout;
13 | import android.widget.ScrollView;
14 | import android.widget.TextView;
15 | import android.widget.Toast;
16 |
17 | import androidx.annotation.NonNull;
18 |
19 | import com.weikaiyun.fragmentation.R;
20 |
21 | import java.util.List;
22 |
23 | public class DebugHierarchyViewContainer extends ScrollView {
24 | private Context mContext;
25 |
26 | private LinearLayout mLinearLayout;
27 | private LinearLayout mTitleLayout;
28 |
29 | private int mItemHeight;
30 | private int mPadding;
31 |
32 | public DebugHierarchyViewContainer(Context context) {
33 | super(context);
34 | initView(context);
35 | }
36 |
37 | public DebugHierarchyViewContainer(Context context, AttributeSet attrs) {
38 | super(context, attrs);
39 | initView(context);
40 | }
41 |
42 | public DebugHierarchyViewContainer(Context context, AttributeSet attrs, int defStyleAttr) {
43 | super(context, attrs, defStyleAttr);
44 | initView(context);
45 | }
46 |
47 | private void initView(Context context) {
48 | mContext = context;
49 | HorizontalScrollView hScrollView = new HorizontalScrollView(context);
50 | mLinearLayout = new LinearLayout(context);
51 | mLinearLayout.setOrientation(LinearLayout.VERTICAL);
52 | hScrollView.addView(mLinearLayout);
53 | addView(hScrollView);
54 |
55 | mItemHeight = dip2px(50);
56 | mPadding = dip2px(16);
57 | }
58 |
59 | private int dip2px(float dp) {
60 | float scale = mContext.getResources().getDisplayMetrics().density;
61 | return (int) (dp * scale + 0.5f);
62 | }
63 |
64 | public void bindFragmentRecords(List fragmentRecords) {
65 | mLinearLayout.removeAllViews();
66 | LinearLayout ll = getTitleLayout();
67 | mLinearLayout.addView(ll);
68 |
69 | if (fragmentRecords == null) return;
70 |
71 | DebugHierarchyViewContainer.this.setView(fragmentRecords, 0, null);
72 | }
73 |
74 | @NonNull
75 | private LinearLayout getTitleLayout() {
76 | if (mTitleLayout != null) return mTitleLayout;
77 |
78 | mTitleLayout = new LinearLayout(mContext);
79 | mTitleLayout.setPadding(dip2px(24), dip2px(24), 0, dip2px(8));
80 | mTitleLayout.setOrientation(LinearLayout.HORIZONTAL);
81 | ViewGroup.LayoutParams flParams = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT);
82 | mTitleLayout.setLayoutParams(flParams);
83 |
84 | TextView title = new TextView(mContext);
85 | title.setText(mContext.getClass().getSimpleName());
86 | title.setTextSize(20);
87 | title.setTextColor(Color.BLACK);
88 | LinearLayout.LayoutParams p = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
89 | p.gravity = Gravity.CENTER_VERTICAL;
90 | title.setLayoutParams(p);
91 | mTitleLayout.addView(title);
92 |
93 | ImageView img = new ImageView(mContext);
94 | img.setImageResource(R.drawable.fragmentation_help);
95 | LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
96 | params.leftMargin = dip2px(16);
97 | params.gravity = Gravity.CENTER_VERTICAL;
98 | img.setLayoutParams(params);
99 | mTitleLayout.setOnClickListener(new OnClickListener() {
100 | @Override
101 | public void onClick(View v) {
102 | Toast.makeText(mContext, R.string.fragmentation_stack_help, Toast.LENGTH_LONG).show();
103 | }
104 | });
105 | mTitleLayout.addView(img);
106 | return mTitleLayout;
107 | }
108 |
109 | private void setView(final List fragmentRecordList, final int hierarchy, final TextView tvItem) {
110 | for (int i = fragmentRecordList.size() - 1; i >= 0; i--) {
111 | DebugFragmentRecord child = fragmentRecordList.get(i);
112 | int tempHierarchy = hierarchy;
113 |
114 | final TextView childTvItem;
115 | childTvItem = getTextView(child, tempHierarchy);
116 | childTvItem.setTag(R.id.hierarchy, tempHierarchy);
117 |
118 | final List childFragmentRecord = child.childFragmentRecord;
119 | if (childFragmentRecord != null && childFragmentRecord.size() > 0) {
120 | tempHierarchy++;
121 | childTvItem.setCompoundDrawablesWithIntrinsicBounds(R.drawable.fragmentation_ic_right, 0, 0, 0);
122 | final int finalChildHierarchy = tempHierarchy;
123 | childTvItem.setOnClickListener(new OnClickListener() {
124 | @Override
125 | public void onClick(View v) {
126 | if (v.getTag(R.id.isexpand) != null) {
127 | boolean isExpand = (boolean) v.getTag(R.id.isexpand);
128 | if (isExpand) {
129 | childTvItem.setCompoundDrawablesWithIntrinsicBounds(R.drawable.fragmentation_ic_right, 0, 0, 0);
130 | DebugHierarchyViewContainer.this.removeView(finalChildHierarchy);
131 | } else {
132 | handleExpandView(childFragmentRecord, finalChildHierarchy, childTvItem);
133 |
134 | }
135 | v.setTag(R.id.isexpand, !isExpand);
136 | } else {
137 | childTvItem.setTag(R.id.isexpand, true);
138 | handleExpandView(childFragmentRecord, finalChildHierarchy, childTvItem);
139 | }
140 | }
141 | });
142 | } else {
143 | childTvItem.setPadding(childTvItem.getPaddingLeft() + mPadding, 0, mPadding, 0);
144 | }
145 |
146 | if (tvItem == null) {
147 | mLinearLayout.addView(childTvItem);
148 | } else {
149 | mLinearLayout.addView(childTvItem, mLinearLayout.indexOfChild(tvItem) + 1);
150 | }
151 | }
152 | }
153 |
154 | private void handleExpandView(List childFragmentRecord, int finalChildHierarchy, TextView childTvItem) {
155 | DebugHierarchyViewContainer.this.setView(childFragmentRecord, finalChildHierarchy, childTvItem);
156 | childTvItem.setCompoundDrawablesWithIntrinsicBounds(R.drawable.fragmentation_ic_expandable, 0, 0, 0);
157 | }
158 |
159 | private void removeView(int hierarchy) {
160 | int size = mLinearLayout.getChildCount();
161 | for (int i = size - 1; i >= 0; i--) {
162 | View view = mLinearLayout.getChildAt(i);
163 | if (view.getTag(R.id.hierarchy) != null && (int) view.getTag(R.id.hierarchy) >= hierarchy) {
164 | mLinearLayout.removeView(view);
165 | }
166 | }
167 | }
168 |
169 | private TextView getTextView(DebugFragmentRecord fragmentRecord, int hierarchy) {
170 | TextView tvItem = new TextView(mContext);
171 |
172 | ViewGroup.LayoutParams params = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, mItemHeight);
173 | tvItem.setLayoutParams(params);
174 | if (hierarchy == 0) {
175 | tvItem.setTextColor(Color.parseColor("#333333"));
176 | tvItem.setTextSize(16);
177 | }else {
178 | tvItem.setTextColor(Color.parseColor("#666666"));
179 | }
180 | tvItem.setGravity(Gravity.CENTER_VERTICAL);
181 | tvItem.setPadding((int) (mPadding + hierarchy * mPadding * 1.5), 0, mPadding, 0);
182 | tvItem.setCompoundDrawablePadding(mPadding / 2);
183 |
184 | TypedArray a = mContext.obtainStyledAttributes(new int[]{android.R.attr.selectableItemBackground});
185 | tvItem.setBackground(a.getDrawable(0));
186 | a.recycle();
187 |
188 | tvItem.setText(fragmentRecord.fragmentName);
189 |
190 | return tvItem;
191 | }
192 | }
193 |
--------------------------------------------------------------------------------
/fragmentation/src/main/java/com/weikaiyun/fragmentation/debug/DebugStackDelegate.java:
--------------------------------------------------------------------------------
1 | package com.weikaiyun.fragmentation.debug;
2 |
3 | import android.annotation.SuppressLint;
4 | import android.content.Context;
5 | import android.hardware.Sensor;
6 | import android.hardware.SensorEvent;
7 | import android.hardware.SensorEventListener;
8 | import android.hardware.SensorManager;
9 | import android.util.TypedValue;
10 | import android.view.Gravity;
11 | import android.view.MotionEvent;
12 | import android.view.View;
13 | import android.view.ViewGroup;
14 | import android.widget.FrameLayout;
15 | import android.widget.ImageView;
16 |
17 | import androidx.annotation.NonNull;
18 | import androidx.appcompat.app.AlertDialog;
19 | import androidx.fragment.app.Fragment;
20 | import androidx.fragment.app.FragmentActivity;
21 |
22 | import com.weikaiyun.fragmentation.Fragmentation;
23 | import com.weikaiyun.fragmentation.ISupportFragment;
24 | import com.weikaiyun.fragmentation.R;
25 | import com.weikaiyun.fragmentation.SupportHelper;
26 |
27 | import java.util.ArrayList;
28 | import java.util.List;
29 |
30 | public class DebugStackDelegate implements SensorEventListener {
31 | private final FragmentActivity mActivity;
32 | private SensorManager mSensorManager;
33 | private AlertDialog mStackDialog;
34 |
35 | public DebugStackDelegate(FragmentActivity activity) {
36 | this.mActivity = activity;
37 | }
38 |
39 | public void onCreate(int mode) {
40 | if (mode != Fragmentation.SHAKE) return;
41 | mSensorManager = (SensorManager) mActivity.getSystemService(Context.SENSOR_SERVICE);
42 | mSensorManager.registerListener(this,
43 | mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
44 | SensorManager.SENSOR_DELAY_NORMAL);
45 | }
46 |
47 | @SuppressLint("ClickableViewAccessibility")
48 | public void onPostCreate(int mode) {
49 | if (mode != Fragmentation.BUBBLE) return;
50 | View root = mActivity.findViewById(android.R.id.content);
51 | if (root instanceof FrameLayout) {
52 | FrameLayout content = (FrameLayout) root;
53 | final ImageView stackView = new ImageView(mActivity);
54 | stackView.setImageResource(R.drawable.fragmentation_ic_stack);
55 | FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
56 | params.gravity = Gravity.END;
57 | final int dp18 = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 18, mActivity.getResources().getDisplayMetrics());
58 | params.topMargin = dp18 * 7;
59 | params.rightMargin = dp18;
60 | stackView.setLayoutParams(params);
61 | content.addView(stackView);
62 | stackView.setOnTouchListener(new StackViewTouchListener(stackView, dp18 / 4));
63 | stackView.setOnClickListener(new View.OnClickListener() {
64 | @Override
65 | public void onClick(View v) {
66 | showFragmentStackHierarchyView();
67 | }
68 | });
69 | }
70 | }
71 |
72 | public void onDestroy() {
73 | if (mSensorManager != null) {
74 | mSensorManager.unregisterListener(this);
75 | }
76 | }
77 |
78 | @Override
79 | public void onSensorChanged(SensorEvent event) {
80 | int sensorType = event.sensor.getType();
81 | float[] values = event.values;
82 | if (sensorType == Sensor.TYPE_ACCELEROMETER) {
83 | int value = 12;
84 | if ((Math.abs(values[0]) >= value || Math.abs(values[1]) >= value || Math.abs(values[2]) >= value)) {
85 | showFragmentStackHierarchyView();
86 | }
87 | }
88 | }
89 |
90 | @Override
91 | public void onAccuracyChanged(Sensor sensor, int accuracy) {
92 | }
93 |
94 | /**
95 | * 调试相关:以dialog形式 显示 栈视图
96 | */
97 | public void showFragmentStackHierarchyView() {
98 | if (mStackDialog != null && mStackDialog.isShowing()) return;
99 | DebugHierarchyViewContainer container = new DebugHierarchyViewContainer(mActivity);
100 | container.bindFragmentRecords(getFragmentRecords());
101 | container.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
102 | mStackDialog = new AlertDialog.Builder(mActivity)
103 | .setView(container)
104 | .setPositiveButton(android.R.string.cancel, null)
105 | .setCancelable(true)
106 | .create();
107 | mStackDialog.show();
108 | }
109 |
110 |
111 |
112 | private List getFragmentRecords() {
113 | List fragmentRecordList = new ArrayList<>();
114 |
115 | List fragmentList = SupportHelper.getActiveFragments(mActivity.getSupportFragmentManager());
116 |
117 | if (fragmentList.size() < 1) return null;
118 |
119 | for (Fragment fragment : fragmentList) {
120 | addDebugFragmentRecord(fragmentRecordList, fragment);
121 | }
122 | return fragmentRecordList;
123 | }
124 |
125 | private List getChildFragmentRecords(Fragment parentFragment) {
126 | List fragmentRecords = new ArrayList<>();
127 |
128 | List fragmentList = SupportHelper.getActiveFragments(parentFragment.getChildFragmentManager());
129 | if (fragmentList.size() < 1) return null;
130 |
131 | for (int i = fragmentList.size() - 1; i >= 0; i--) {
132 | Fragment fragment = fragmentList.get(i);
133 | addDebugFragmentRecord(fragmentRecords, fragment);
134 | }
135 | return fragmentRecords;
136 | }
137 |
138 | private void addDebugFragmentRecord(List fragmentRecords, Fragment fragment) {
139 | if (fragment != null) {
140 | CharSequence name = fragment.getClass().getSimpleName();
141 |
142 | if (fragment instanceof ISupportFragment && ((ISupportFragment)fragment).getSupportDelegate().isVisible()) {
143 | name = span(name, " ☀");
144 | }
145 |
146 | fragmentRecords.add(new DebugFragmentRecord(name, getChildFragmentRecords(fragment)));
147 | }
148 | }
149 |
150 | @NonNull
151 | private CharSequence span(CharSequence name, String str) {
152 | name = name + str;
153 | return name;
154 | }
155 |
156 | private static class StackViewTouchListener implements View.OnTouchListener {
157 | private final View stackView;
158 | private float dX, dY = 0f;
159 | private float downX, downY = 0f;
160 | private boolean isClickState;
161 | private final int clickLimitValue;
162 |
163 | StackViewTouchListener(View stackView, int clickLimitValue) {
164 | this.stackView = stackView;
165 | this.clickLimitValue = clickLimitValue;
166 | }
167 |
168 | @Override
169 | public boolean onTouch(View v, MotionEvent event) {
170 | float X = event.getRawX();
171 | float Y = event.getRawY();
172 | switch (event.getAction()) {
173 | case MotionEvent.ACTION_DOWN:
174 | isClickState = true;
175 | downX = X;
176 | downY = Y;
177 | dX = stackView.getX() - event.getRawX();
178 | dY = stackView.getY() - event.getRawY();
179 | break;
180 | case MotionEvent.ACTION_MOVE:
181 | if (Math.abs(X - downX) < clickLimitValue && Math.abs(Y - downY) < clickLimitValue && isClickState) {
182 | isClickState = true;
183 | } else {
184 | isClickState = false;
185 | stackView.setX(event.getRawX() + dX);
186 | stackView.setY(event.getRawY() + dY);
187 | }
188 | break;
189 | case MotionEvent.ACTION_CANCEL:
190 | case MotionEvent.ACTION_UP:
191 | if (X - downX < clickLimitValue && isClickState) {
192 | stackView.performClick();
193 | }
194 | break;
195 | default:
196 | return false;
197 | }
198 | return true;
199 | }
200 | }
201 | }
202 |
--------------------------------------------------------------------------------
/fragmentation/src/main/java/com/weikaiyun/fragmentation/queue/Action.java:
--------------------------------------------------------------------------------
1 | package com.weikaiyun.fragmentation.queue;
2 |
3 | import androidx.fragment.app.FragmentManager;
4 |
5 | public abstract class Action {
6 | public static final long DEFAULT_POP_TIME = 320L;
7 |
8 | public static final int ACTION_NORMAL = 0;
9 | public static final int ACTION_POP = 1;
10 | public static final int ACTION_BACK = 2;
11 | public static final int ACTION_LOAD = 3;
12 |
13 | public FragmentManager fragmentManager;
14 | public int action = ACTION_NORMAL;
15 | public long duration = 0;
16 |
17 | public Action() {
18 | }
19 |
20 | public Action(int action) {
21 | this.action = action;
22 | }
23 |
24 | public Action(int action, FragmentManager fragmentManager) {
25 | this(action);
26 | this.fragmentManager = fragmentManager;
27 | }
28 |
29 | public abstract void run();
30 | }
31 |
--------------------------------------------------------------------------------
/fragmentation/src/main/java/com/weikaiyun/fragmentation/queue/ActionQueue.java:
--------------------------------------------------------------------------------
1 | package com.weikaiyun.fragmentation.queue;
2 |
3 | import android.os.Handler;
4 | import android.os.Looper;
5 |
6 | import java.util.LinkedList;
7 | import java.util.Queue;
8 |
9 | public class ActionQueue {
10 | private final Queue mQueue = new LinkedList<>();
11 | private final Handler mMainHandler;
12 |
13 | public ActionQueue(Handler mainHandler) {
14 | this.mMainHandler = mainHandler;
15 | }
16 |
17 | public void enqueue(final Action action) {
18 | if (isThrottleBACK(action)) return;
19 |
20 | if (action.action == Action.ACTION_LOAD && mQueue.isEmpty()
21 | && Thread.currentThread() == Looper.getMainLooper().getThread()) {
22 | action.run();
23 | return;
24 | }
25 |
26 | mMainHandler.post(new Runnable() {
27 | @Override
28 | public void run() {
29 | enqueueAction(action);
30 | }
31 | });
32 | }
33 |
34 | private void enqueueAction(Action action) {
35 | mQueue.add(action);
36 | if (mQueue.size() == 1) {
37 | handleAction();
38 | }
39 | }
40 |
41 | private void handleAction() {
42 | if (mQueue.isEmpty()) return;
43 |
44 | Action action = mQueue.peek();
45 | assert action != null;
46 | action.run();
47 |
48 | executeNextAction(action);
49 | }
50 |
51 | private void executeNextAction(Action action) {
52 | if (action.action == Action.ACTION_POP) {
53 | action.duration = Action.DEFAULT_POP_TIME;
54 | }
55 |
56 | mMainHandler.postDelayed(new Runnable() {
57 | @Override
58 | public void run() {
59 | mQueue.poll();
60 | handleAction();
61 | }
62 | }, action.duration);
63 | }
64 |
65 | private boolean isThrottleBACK(Action action) {
66 | if (action.action == Action.ACTION_BACK) {
67 | Action head = mQueue.peek();
68 | return head != null && head.action == Action.ACTION_POP;
69 | }
70 | return false;
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/fragmentation/src/main/java/com/weikaiyun/fragmentation/record/ResultRecord.java:
--------------------------------------------------------------------------------
1 | package com.weikaiyun.fragmentation.record;
2 |
3 | import android.os.Bundle;
4 | import android.os.Parcel;
5 | import android.os.Parcelable;
6 |
7 | public final class ResultRecord implements Parcelable {
8 | public int requestCode;
9 | public int resultCode = 0;
10 | public Bundle resultBundle;
11 |
12 | public ResultRecord() {
13 | }
14 |
15 | protected ResultRecord(Parcel in) {
16 | requestCode = in.readInt();
17 | resultCode = in.readInt();
18 | resultBundle = in.readBundle(getClass().getClassLoader());
19 | }
20 |
21 | public static final Creator CREATOR = new Creator() {
22 | @Override
23 | public ResultRecord createFromParcel(Parcel in) {
24 | return new ResultRecord(in);
25 | }
26 |
27 | @Override
28 | public ResultRecord[] newArray(int size) {
29 | return new ResultRecord[size];
30 | }
31 | };
32 |
33 | @Override
34 | public int describeContents() {
35 | return 0;
36 | }
37 |
38 | @Override
39 | public void writeToParcel(Parcel dest, int flags) {
40 | dest.writeInt(requestCode);
41 | dest.writeInt(resultCode);
42 | dest.writeBundle(resultBundle);
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/fragmentation/src/main/java/com/weikaiyun/fragmentation/record/TransactionRecord.java:
--------------------------------------------------------------------------------
1 | package com.weikaiyun.fragmentation.record;
2 |
3 | public final class TransactionRecord {
4 | public String tag;
5 | public int targetFragmentEnter = Integer.MIN_VALUE;
6 | public int currentFragmentPopExit = Integer.MIN_VALUE;
7 | public int currentFragmentPopEnter = Integer.MIN_VALUE;
8 | public int targetFragmentExit = Integer.MIN_VALUE;
9 | }
10 |
--------------------------------------------------------------------------------
/fragmentation/src/main/res/anim/h_fragment_enter.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
8 |
--------------------------------------------------------------------------------
/fragmentation/src/main/res/anim/h_fragment_exit.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
9 |
--------------------------------------------------------------------------------
/fragmentation/src/main/res/anim/h_fragment_pop_enter.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
7 |
--------------------------------------------------------------------------------
/fragmentation/src/main/res/anim/h_fragment_pop_exit.xml:
--------------------------------------------------------------------------------
1 |
2 |
5 |
8 |
--------------------------------------------------------------------------------
/fragmentation/src/main/res/anim/v_fragment_enter.xml:
--------------------------------------------------------------------------------
1 |
2 |
19 |
20 |
23 |
28 |
32 |
--------------------------------------------------------------------------------
/fragmentation/src/main/res/anim/v_fragment_exit.xml:
--------------------------------------------------------------------------------
1 |
2 |
19 |
20 |
22 |
28 |
32 |
--------------------------------------------------------------------------------
/fragmentation/src/main/res/anim/v_fragment_pop_enter.xml:
--------------------------------------------------------------------------------
1 |
2 |
19 |
20 |
21 |
25 |
--------------------------------------------------------------------------------
/fragmentation/src/main/res/anim/v_fragment_pop_exit.xml:
--------------------------------------------------------------------------------
1 |
2 |
19 |
20 |
22 |
26 |
--------------------------------------------------------------------------------
/fragmentation/src/main/res/drawable-xxhdpi/fragmentation_help.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/weikaiyun/SFragmentation/bd500d1fde6fa45651a6abd331c5b4ff4dc7acce/fragmentation/src/main/res/drawable-xxhdpi/fragmentation_help.png
--------------------------------------------------------------------------------
/fragmentation/src/main/res/drawable-xxhdpi/fragmentation_ic_expandable.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/weikaiyun/SFragmentation/bd500d1fde6fa45651a6abd331c5b4ff4dc7acce/fragmentation/src/main/res/drawable-xxhdpi/fragmentation_ic_expandable.png
--------------------------------------------------------------------------------
/fragmentation/src/main/res/drawable-xxhdpi/fragmentation_ic_right.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/weikaiyun/SFragmentation/bd500d1fde6fa45651a6abd331c5b4ff4dc7acce/fragmentation/src/main/res/drawable-xxhdpi/fragmentation_ic_right.png
--------------------------------------------------------------------------------
/fragmentation/src/main/res/drawable-xxhdpi/fragmentation_ic_stack.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/weikaiyun/SFragmentation/bd500d1fde6fa45651a6abd331c5b4ff4dc7acce/fragmentation/src/main/res/drawable-xxhdpi/fragmentation_ic_stack.png
--------------------------------------------------------------------------------
/fragmentation/src/main/res/values/ids.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |