-
12 | *
- Activity 之间任意跳转 13 | *
- 关闭任意N个 Activity 14 | *
- 结束应用程序 15 | *
19 | * 20 | * github : https://github.com/Hitomis
21 | * 22 | * Created by hitomi on 2016/10/11. 23 | */ 24 | public class ActivitySwitcher { 25 | 26 | private ActivitySwitcherHelper switcherHelper; 27 | 28 | private boolean switching; 29 | 30 | private float preX, touchSlop; 31 | 32 | private static class SingletonHolder { 33 | public final static ActivitySwitcher instance = new ActivitySwitcher(); 34 | } 35 | 36 | public static ActivitySwitcher getInstance() { 37 | return SingletonHolder.instance; 38 | } 39 | 40 | public void init(Application application) { 41 | switcherHelper = new ActivitySwitcherHelper(this, application); 42 | ViewConfiguration conf = ViewConfiguration.get(application); 43 | touchSlop = conf.getScaledEdgeSlop(); 44 | } 45 | 46 | public void processTouchEvent(MotionEvent event) { 47 | switch (event.getAction()) { 48 | case MotionEvent.ACTION_DOWN: 49 | preX = event.getX(); 50 | break; 51 | case MotionEvent.ACTION_MOVE: 52 | float slideX = event.getX() - preX; 53 | if (preX <= touchSlop && slideX > 50 && !switching) { 54 | showSwitch(); 55 | } 56 | break; 57 | } 58 | } 59 | 60 | public void exit() { 61 | switcherHelper.exit(); 62 | } 63 | 64 | /** 65 | * 关闭 ActivitySwitcher 切换视图 66 | * @param activity 67 | */ 68 | public void finishSwitch(Activity activity) { 69 | if (switcherHelper.isActivityControllerDisplayed()) { 70 | switcherHelper.endSwitch(); 71 | } else if (switcherHelper.isActivityControllerClosed()) { 72 | activity.finish(); 73 | } 74 | } 75 | 76 | /** 77 | * 显示 ActivitySwitcher 切换视图 78 | */ 79 | public void showSwitch() { 80 | switching = true; 81 | switcherHelper.startSwitch(); 82 | } 83 | 84 | void setSwitching(boolean switching) { 85 | this.switching = switching; 86 | } 87 | 88 | public void setOnActivitySwitchListener(OnActivitySwitchListener listener) { 89 | switcherHelper.setOnActivitySwitchListener(listener); 90 | } 91 | 92 | public interface OnActivitySwitchListener { 93 | 94 | void onSwitchStarted(); 95 | 96 | void onSwitchFinished(Activity activity); 97 | } 98 | 99 | } 100 | -------------------------------------------------------------------------------- /app/src/main/java/com/hitomi/activityswitcher/MainActivity.java: -------------------------------------------------------------------------------- 1 | package com.hitomi.activityswitcher; 2 | 3 | import android.app.Activity; 4 | import android.content.Intent; 5 | import android.graphics.Color; 6 | import android.os.Bundle; 7 | import android.support.v7.app.AppCompatActivity; 8 | import android.view.MotionEvent; 9 | import android.view.View; 10 | import android.widget.Button; 11 | import android.widget.RelativeLayout; 12 | import android.widget.TextView; 13 | 14 | import com.hitomi.aslibrary.ActivitySwitcher; 15 | 16 | public class MainActivity extends AppCompatActivity { 17 | 18 | static int index; 19 | static int totalCount = 8; 20 | static int[] bgColors = new int[] { 21 | Color.parseColor("#92c8d0"), 22 | Color.parseColor("#c4dcce"), 23 | Color.parseColor("#cd7b91"), 24 | Color.parseColor("#e5c5dc"), 25 | Color.parseColor("#742a8d"), 26 | Color.parseColor("#2eb2d8"), 27 | Color.parseColor("#b9d84e"), 28 | Color.parseColor("#35fe62") 29 | }; 30 | 31 | private RelativeLayout relativeLayout; 32 | private Button btnNext; 33 | private TextView tvPage; 34 | 35 | private ActivitySwitcher activitySwitcher; 36 | private int tag; 37 | 38 | @Override 39 | protected void onCreate(Bundle savedInstanceState) { 40 | super.onCreate(savedInstanceState); 41 | setContentView(R.layout.activity_main); 42 | activitySwitcher = ActivitySwitcher.getInstance(); 43 | 44 | relativeLayout = (RelativeLayout) findViewById(R.id.relayout); 45 | btnNext = (Button) findViewById(R.id.btn_next); 46 | tvPage = (TextView) findViewById(R.id.tv_page); 47 | 48 | relativeLayout.setBackgroundColor(bgColors[index]); 49 | tag = index; 50 | tvPage.setText("当前第" + (tag + 1) + "页" ); 51 | 52 | if (index == totalCount - 1) { 53 | btnNext.setText("退出程序"); 54 | } 55 | btnNext.setOnClickListener(new View.OnClickListener() { 56 | @Override 57 | public void onClick(View view) { 58 | if (++index > totalCount - 1) { 59 | activitySwitcher.exit(); 60 | } else { 61 | startActivity(new Intent(MainActivity.this, MainActivity.class)); 62 | } 63 | } 64 | }); 65 | 66 | activitySwitcher.setOnActivitySwitchListener(new ActivitySwitcher.OnActivitySwitchListener() { 67 | @Override 68 | public void onSwitchStarted() {} 69 | 70 | @Override 71 | public void onSwitchFinished(Activity activity) { 72 | if (activity instanceof MainActivity) { 73 | MainActivity mainActivity = (MainActivity) activity; 74 | MainActivity.index = mainActivity.getTag(); 75 | } 76 | } 77 | }); 78 | 79 | } 80 | 81 | @Override 82 | public boolean dispatchTouchEvent(MotionEvent ev) { 83 | activitySwitcher.processTouchEvent(ev); 84 | return super.dispatchTouchEvent(ev); 85 | } 86 | 87 | @Override 88 | public void onBackPressed() { 89 | MainActivity.index = tag - 1 <= 0 ? 0 : tag - 1; 90 | activitySwitcher.finishSwitch(this); 91 | } 92 | 93 | public int getTag() { 94 | return tag; 95 | } 96 | } 97 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # ActivitySwitcher 2 | 3 | [](http://android-arsenal.com/details/1/4635) 4 | 5 | ActivitySwitcher 是一个基于 Activity 视图操作管理库，可以实现 Activity 之间任意跳转、关闭任意一个 Activity 6 | 以及结束应用程序等功能。 7 | 8 | 本库中的展现 Activity 视图时，附带阴影的卡片效果抽取自 [CrazyShadow](https://github.com/Hitomis/CrazyShadow) 有兴趣的朋友可以移步看看。 9 | 10 | 欢迎大家给 ActivitySwitcher 提 Issues，有问题我会尽快修复 11 | 12 | # Preview 13 | 14 | 录制图像有丢帧的情况，所以预览图效果不够流畅，背景图显示的也有问题。 15 | 16 |
17 |
18 | # Sample
19 |
20 | [demo.apk](https://github.com/Hitomis/ActivitySwitcher/tree/master/sample/app.apk)
21 |
22 | # Import
23 |
24 | 导入 aslibrary Module 作为依赖库, 或者直接复制 com.hitomi.aslibrary 中所有类文件到自己的项目中即可
25 |
26 | # Usage
27 |
28 | #### 1、Application 中 初始化
29 |
30 | ActivitySwitcher.getInstance().init(this);
31 |
32 | #### 2、在 Activity 中重写 dispatchTouchEvent 处理事件分发。最好直接在 BaseActivity 中处理。万事大吉
33 |
34 | @Override
35 | public boolean dispatchTouchEvent(MotionEvent ev) {
36 | activitySwitcher.processTouchEvent(ev);
37 | return super.dispatchTouchEvent(ev);
38 | }
39 |
40 | 如果不想通过手势打开 ActivitySwitcher，可以通过以下方式手动打开
41 |
42 | activitySwitcher.showSwitcher();
43 |
44 | #### 3、Android 手机默认按下返回键就回 finish 掉当前 Activity，这与本库冲突，所以需要重写 onBackPressed 方法，同样最好在 BaseActivity 中去重写
45 |
46 | @Override
47 | public void onBackPressed() {
48 | activitySwitcher.finishSwitch(this);
49 | }
50 |
51 | #### 4、如果希望监听 ActivitySwitcher 当前的行为状态，可以添加以下代码
52 |
53 | activitySwitcher.setOnActivitySwitchListener(new ActivitySwitcher.OnActivitySwitchListener() {
54 | @Override
55 | public void onSwitchStarted() {}
56 |
57 | @Override
58 | public void onSwitchFinished(Activity activity) {}
59 | });
60 |
61 | onSwitchStarted ：在 ActivitySwitcher 打开后被回调 62 | onSwitchFinished 在 ActivitySwitcher 关闭后被回调 63 | 64 | 全部示例代码详情请前往 [MainActivity](https://github.com/Hitomis/ActivitySwitcher/blob/master/app/src/main/java/com/hitomi/activityswitcher/MainActivity.java) 查看 65 | 66 | #Method 67 | 68 | | 方法 | 说明 | 69 | | :--: | :--: | 70 | | getInstance | 获取 ActivitySwitcher 实例 (ActivitySwitcher 为单例) | 71 | | init | 全局初始化 ActivitySwitcher， 一般在 Application 的 onCreate 方法中调用 | 72 | | processTouchEvent | 用于需要手势打开 ActivitySwitcher 的场景， 一般在 BaseActivity 的 dispatchTouchEvent 方法中调用 | 73 | | showSwitch | 打开 ActivitySwitcher，切换到 Activity 卡片式管理界面 | 74 | | finishSwitch | 关闭 ActivitySwitcher， 退出 Activity 卡片式管理界面，回到选中或者默认的 Activity 界面 | 75 | | exit | 退出当前应用程序 | 76 | | setOnActivitySwitchListener | 设置监听器，监听 ActivitySwitcher 的打开和关闭 | 77 | 78 | 79 | #Licence 80 | 81 | Copyright 2016 Hitomis, Inc. 82 | 83 | Licensed under the Apache License, Version 2.0 (the "License"); 84 | you may not use this file except in compliance with the License. 85 | You may obtain a copy of the License at 86 | 87 | http://www.apache.org/licenses/LICENSE-2.0 88 | 89 | Unless required by applicable law or agreed to in writing, software 90 | distributed under the License is distributed on an "AS IS" BASIS, 91 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 92 | See the License for the specific language governing permissions and 93 | limitations under the License. 94 | 95 | 96 | 97 | -------------------------------------------------------------------------------- /aslibrary/src/main/java/com/hitomi/aslibrary/ActivityContainer.java: -------------------------------------------------------------------------------- 1 | package com.hitomi.aslibrary; 2 | 3 | import android.content.Context; 4 | import android.graphics.RectF; 5 | import android.util.AttributeSet; 6 | import android.view.MotionEvent; 7 | import android.view.ViewGroup; 8 | import android.widget.FrameLayout; 9 | 10 | /** 11 | * 用于 Activity 实际大小、位置以及事件分发处理
12 | * 13 | * email : 196425254@qq.com
14 | * 15 | * github : https://github.com/Hitomis
16 | * 17 | * Created by hitomi on 2016/11/2. 18 | */ 19 | public class ActivityContainer extends FrameLayout { 20 | 21 | private RectF bounds; 22 | 23 | private float offsetX, offsetY; 24 | private float tranX, tranY; 25 | 26 | private boolean intercept; 27 | 28 | public ActivityContainer(Context context) { 29 | this(context, null); 30 | } 31 | 32 | public ActivityContainer(Context context, AttributeSet attrs) { 33 | this(context, attrs, 0); 34 | } 35 | 36 | public ActivityContainer(Context context, AttributeSet attrs, int defStyleAttr) { 37 | super(context, attrs, defStyleAttr); 38 | bounds = new RectF(); 39 | } 40 | 41 | @Override 42 | public boolean onInterceptTouchEvent(MotionEvent ev) { 43 | return intercept; 44 | } 45 | 46 | @Override 47 | public void setLayoutParams(ViewGroup.LayoutParams params) { 48 | super.setLayoutParams(params); 49 | bounds.left = 0; 50 | bounds.top = 0; 51 | bounds.right = params.width; 52 | bounds.bottom = params.height; 53 | } 54 | 55 | @Override 56 | public void setScaleX(float scaleX) { 57 | super.setScaleX(scaleX); 58 | int width = getLayoutParams().width; 59 | float halfScaleX = width * (1 - scaleX) * .5f; 60 | bounds.left += halfScaleX - offsetX; 61 | bounds.right -= halfScaleX - offsetX; 62 | offsetX = halfScaleX; 63 | } 64 | 65 | @Override 66 | public void setScaleY(float scaleY) { 67 | super.setScaleY(scaleY); 68 | int height = getLayoutParams().height; 69 | float halfScaleY = height * (1 - scaleY) * .5f; 70 | bounds.top += halfScaleY - offsetY; 71 | bounds.bottom -= halfScaleY - offsetY; 72 | offsetY = halfScaleY; 73 | } 74 | 75 | @Override 76 | public void setTranslationX(float translationX) { 77 | super.setTranslationX(translationX); 78 | bounds.left += translationX - tranX; 79 | bounds.right += translationX - tranX; 80 | tranX = translationX; 81 | } 82 | 83 | @Override 84 | public void setTranslationY(float translationY) { 85 | super.setTranslationY(translationY); 86 | bounds.top += translationY - tranY; 87 | bounds.bottom += translationY - tranY; 88 | tranY = translationY; 89 | } 90 | 91 | @Override 92 | public void setX(float x) { 93 | super.setX(x); 94 | bounds.left += x - tranX; 95 | bounds.right += x - tranX; 96 | tranX = x; 97 | } 98 | 99 | @Override 100 | public void setY(float y) { 101 | super.setY(y); 102 | bounds.top += y - tranY; 103 | bounds.bottom += y - tranY; 104 | tranY = y; 105 | } 106 | 107 | public void setIntercept(boolean intercept) { 108 | this.intercept = intercept; 109 | } 110 | 111 | public RectF getBounds() { 112 | return bounds; 113 | } 114 | 115 | public float getIntrinsicHeight() { 116 | return bounds.bottom - bounds.top; 117 | } 118 | 119 | public float getIntrinsicWidth() { 120 | return bounds.right - bounds.left; 121 | } 122 | } 123 | -------------------------------------------------------------------------------- /aslibrary/src/main/java/com/hitomi/aslibrary/ActivityManager.java: -------------------------------------------------------------------------------- 1 | package com.hitomi.aslibrary; 2 | 3 | import android.app.Activity; 4 | import android.app.Application; 5 | import android.os.Bundle; 6 | 7 | import java.util.ArrayList; 8 | import java.util.List; 9 | import java.util.Stack; 10 | 11 | /** 12 | * Activity 管理工具类 13 | * 14 | * email : 196425254@qq.com
15 | * 16 | * github : https://github.com/Hitomis
17 | * 18 | * Created by hitomi on 2016/10/11. 19 | */ 20 | class ActivityManager implements Application.ActivityLifecycleCallbacks { 21 | 22 | private static Stack
17 | * 18 | * email : 196425254@qq.com
19 | * 20 | * github : https://github.com/Hitomis
21 | * 22 | * Created by hitomi on 2016/10/17. 23 | */ 24 | public class RoundRectDrawableWithShadow extends Drawable { 25 | // used to calculate content padding 26 | final static double COS_45 = Math.cos(Math.toRadians(45)); 27 | 28 | final static float SHADOW_MULTIPLIER = 1.5f; 29 | 30 | final int mInsetShadow; // extra shadow to avoid gaps between card and shadow 31 | final RectF mCardBounds; 32 | private final int mShadowStartColor; 33 | private final int mShadowCentertColor; 34 | private final int mShadowEndColor; 35 | Paint mPaint; 36 | Paint mCornerShadowPaint; 37 | Paint mEdgeShadowPaint; 38 | float mCornerRadius; 39 | Path mCornerShadowPath; 40 | // updated value with inset 41 | float mMaxShadowSize; 42 | // actual value set by developer 43 | float mRawMaxShadowSize; 44 | // multiplied value to account for shadow offset 45 | float mShadowSize; 46 | // actual value set by developer 47 | float mRawShadowSize; 48 | private boolean mDirty = true; 49 | private boolean mAddPaddingForCorners = true; 50 | private int backgroundColor; 51 | 52 | public RoundRectDrawableWithShadow(int background, float radius, float shadowSize, float maxShadowSize) { 53 | mShadowStartColor = 0x43000000; 54 | mShadowCentertColor = 0x43000000; 55 | mShadowEndColor = 0x00000000; 56 | mInsetShadow = 10; 57 | mPaint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG); 58 | backgroundColor = background; 59 | mPaint.setColor(background); 60 | mCornerShadowPaint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG); 61 | mCornerShadowPaint.setStyle(Paint.Style.FILL); 62 | mCornerRadius = (int) (radius + .5f); 63 | mCardBounds = new RectF(); 64 | mEdgeShadowPaint = new Paint(mCornerShadowPaint); 65 | mEdgeShadowPaint.setAntiAlias(false); 66 | setShadowSize(shadowSize, maxShadowSize); 67 | } 68 | 69 | /** 70 | * Casts the value to an even integer. 71 | */ 72 | private int toEven(float value) { 73 | int i = (int) (value + .5f); 74 | if (i % 2 == 1) { 75 | return i - 1; 76 | } 77 | return i; 78 | } 79 | 80 | public void setAddPaddingForCorners(boolean addPaddingForCorners) { 81 | mAddPaddingForCorners = addPaddingForCorners; 82 | invalidateSelf(); 83 | } 84 | 85 | @Override 86 | public void setAlpha(int alpha) { 87 | mPaint.setAlpha(alpha); 88 | mCornerShadowPaint.setAlpha(alpha); 89 | mEdgeShadowPaint.setAlpha(alpha); 90 | } 91 | 92 | @Override 93 | protected void onBoundsChange(Rect bounds) { 94 | super.onBoundsChange(bounds); 95 | mDirty = true; 96 | } 97 | 98 | void setShadowSize(float shadowSize, float maxShadowSize) { 99 | if (shadowSize < 0f) { 100 | throw new IllegalArgumentException("Invalid shadow size " + shadowSize + 101 | ". Must be >= 0"); 102 | } 103 | if (maxShadowSize < 0f) { 104 | throw new IllegalArgumentException("Invalid max shadow size " + maxShadowSize + 105 | ". Must be >= 0"); 106 | } 107 | shadowSize = toEven(shadowSize); 108 | maxShadowSize = toEven(maxShadowSize); 109 | if (shadowSize > maxShadowSize) { 110 | shadowSize = maxShadowSize; 111 | } 112 | if (mRawShadowSize == shadowSize && mRawMaxShadowSize == maxShadowSize) { 113 | return; 114 | } 115 | mRawShadowSize = shadowSize; 116 | mRawMaxShadowSize = maxShadowSize; 117 | mShadowSize = (int) (shadowSize * SHADOW_MULTIPLIER + mInsetShadow + .5f); 118 | mMaxShadowSize = maxShadowSize + mInsetShadow; 119 | mDirty = true; 120 | invalidateSelf(); 121 | } 122 | 123 | @Override 124 | public boolean getPadding(Rect padding) { 125 | int vOffset = (int) Math.ceil(calculateVerticalPadding(mRawMaxShadowSize, mCornerRadius, 126 | mAddPaddingForCorners)); 127 | int hOffset = (int) Math.ceil(calculateHorizontalPadding(mRawMaxShadowSize, mCornerRadius, 128 | mAddPaddingForCorners)); 129 | padding.set(hOffset, vOffset, hOffset, vOffset); 130 | return true; 131 | } 132 | 133 | float calculateVerticalPadding(float maxShadowSize, float cornerRadius, 134 | boolean addPaddingForCorners) { 135 | if (addPaddingForCorners) { 136 | return (float) (maxShadowSize * SHADOW_MULTIPLIER + (1 - COS_45) * cornerRadius); 137 | } else { 138 | return maxShadowSize * SHADOW_MULTIPLIER; 139 | } 140 | } 141 | 142 | float calculateHorizontalPadding(float maxShadowSize, float cornerRadius, 143 | boolean addPaddingForCorners) { 144 | if (addPaddingForCorners) { 145 | return (float) (maxShadowSize + (1 - COS_45) * cornerRadius); 146 | } else { 147 | return maxShadowSize; 148 | } 149 | } 150 | 151 | @Override 152 | public void setColorFilter(ColorFilter cf) { 153 | mPaint.setColorFilter(cf); 154 | } 155 | 156 | @Override 157 | public int getOpacity() { 158 | return PixelFormat.TRANSLUCENT; 159 | } 160 | 161 | @Override 162 | public void draw(Canvas canvas) { 163 | if (mDirty) { 164 | buildComponents(getBounds()); 165 | mDirty = false; 166 | } 167 | canvas.translate(0, mRawShadowSize / 2); 168 | drawShadow(canvas); 169 | canvas.translate(0, -mRawShadowSize / 2); 170 | canvas.drawRoundRect(mCardBounds, mCornerRadius, mCornerRadius, mPaint); 171 | } 172 | 173 | private void drawShadow(Canvas canvas) { 174 | final float edgeShadowTop = -mCornerRadius - mShadowSize; 175 | final float inset = mCornerRadius + mInsetShadow + mRawShadowSize / 2; 176 | final boolean drawHorizontalEdges = mCardBounds.width() - 2 * inset > 0; 177 | final boolean drawVerticalEdges = mCardBounds.height() - 2 * inset > 0; 178 | // LT 179 | int saved = canvas.save(); 180 | canvas.translate(mCardBounds.left + inset, mCardBounds.top + inset); 181 | canvas.drawPath(mCornerShadowPath, mCornerShadowPaint); 182 | if (drawHorizontalEdges) { 183 | canvas.drawRect(0, edgeShadowTop, 184 | mCardBounds.width() - 2 * inset, -mCornerRadius, 185 | mEdgeShadowPaint); 186 | } 187 | canvas.restoreToCount(saved); 188 | // RB 189 | saved = canvas.save(); 190 | canvas.translate(mCardBounds.right - inset, mCardBounds.bottom - inset); 191 | canvas.rotate(180f); 192 | canvas.drawPath(mCornerShadowPath, mCornerShadowPaint); 193 | if (drawHorizontalEdges) { 194 | canvas.drawRect(0, edgeShadowTop, 195 | mCardBounds.width() - 2 * inset, -mCornerRadius, 196 | mEdgeShadowPaint); 197 | } 198 | canvas.restoreToCount(saved); 199 | // LB 200 | saved = canvas.save(); 201 | canvas.translate(mCardBounds.left + inset, mCardBounds.bottom - inset); 202 | canvas.rotate(270f); 203 | canvas.drawPath(mCornerShadowPath, mCornerShadowPaint); 204 | if (drawVerticalEdges) { 205 | canvas.drawRect(0, edgeShadowTop, 206 | mCardBounds.height() - 2 * inset, -mCornerRadius, mEdgeShadowPaint); 207 | } 208 | canvas.restoreToCount(saved); 209 | // RT 210 | saved = canvas.save(); 211 | canvas.translate(mCardBounds.right - inset, mCardBounds.top + inset); 212 | canvas.rotate(90f); 213 | canvas.drawPath(mCornerShadowPath, mCornerShadowPaint); 214 | if (drawVerticalEdges) { 215 | canvas.drawRect(0, edgeShadowTop, 216 | mCardBounds.height() - 2 * inset, -mCornerRadius, mEdgeShadowPaint); 217 | } 218 | canvas.restoreToCount(saved); 219 | } 220 | 221 | private void buildShadowCorners() { 222 | RectF innerBounds = new RectF(-mCornerRadius, -mCornerRadius, mCornerRadius, mCornerRadius); 223 | RectF outerBounds = new RectF(innerBounds); 224 | outerBounds.inset(-mShadowSize, -mShadowSize); 225 | 226 | if (mCornerShadowPath == null) { 227 | mCornerShadowPath = new Path(); 228 | } else { 229 | mCornerShadowPath.reset(); 230 | } 231 | mCornerShadowPath.setFillType(Path.FillType.EVEN_ODD); 232 | mCornerShadowPath.moveTo(-mCornerRadius, 0); 233 | mCornerShadowPath.rLineTo(-mShadowSize, 0); 234 | // outer arc 235 | mCornerShadowPath.arcTo(outerBounds, 180f, 90f, false); 236 | // inner arc 237 | mCornerShadowPath.arcTo(innerBounds, 270f, -90f, false); 238 | mCornerShadowPath.close(); 239 | float startRatio = mCornerRadius / (mCornerRadius + mShadowSize); 240 | mCornerShadowPaint.setShader(new RadialGradient(0, 0, mCornerRadius + mShadowSize, 241 | new int[]{mShadowStartColor, mShadowCentertColor, mShadowEndColor}, 242 | new float[]{0f, startRatio, 1f} 243 | , Shader.TileMode.CLAMP)); 244 | 245 | // we offset the content shadowSize/2 pixels up to make it more realistic. 246 | // this is why edge shadow shader has some extra space 247 | // When drawing bottom edge shadow, we use that extra space. 248 | mEdgeShadowPaint.setShader(new LinearGradient(0, -mCornerRadius + mShadowSize, 0, 249 | -mCornerRadius - mShadowSize, 250 | new int[]{mShadowStartColor, mShadowCentertColor, mShadowEndColor}, 251 | new float[]{0f, .5f, 1f}, Shader.TileMode.CLAMP)); 252 | mEdgeShadowPaint.setAntiAlias(false); 253 | } 254 | 255 | private void buildComponents(Rect bounds) { 256 | // Card is offset SHADOW_MULTIPLIER * maxShadowSize to account for the shadow shift. 257 | // We could have different top-bottom offsets to avoid extra gap above but in that case 258 | // center aligning Views inside the CardView would be problematic. 259 | final float verticalOffset = mRawMaxShadowSize * SHADOW_MULTIPLIER; 260 | mCardBounds.set(bounds.left + mRawMaxShadowSize, bounds.top + verticalOffset, 261 | bounds.right - mRawMaxShadowSize, bounds.bottom - verticalOffset); 262 | buildShadowCorners(); 263 | } 264 | 265 | float getCornerRadius() { 266 | return mCornerRadius; 267 | } 268 | 269 | void setCornerRadius(float radius) { 270 | if (radius < 0f) { 271 | throw new IllegalArgumentException("Invalid radius " + radius + ". Must be >= 0"); 272 | } 273 | radius = (int) (radius + .5f); 274 | if (mCornerRadius == radius) { 275 | return; 276 | } 277 | mCornerRadius = radius; 278 | mDirty = true; 279 | invalidateSelf(); 280 | } 281 | 282 | void getMaxShadowAndCornerPadding(Rect into) { 283 | getPadding(into); 284 | } 285 | 286 | float getShadowSize() { 287 | return mRawShadowSize; 288 | } 289 | 290 | void setShadowSize(float size) { 291 | setShadowSize(size, mRawMaxShadowSize); 292 | } 293 | 294 | float getMaxShadowSize() { 295 | return mRawMaxShadowSize; 296 | } 297 | 298 | void setMaxShadowSize(float size) { 299 | setShadowSize(mRawShadowSize, size); 300 | } 301 | 302 | int getBackgroundColor() { 303 | return backgroundColor; 304 | } 305 | 306 | float getMinWidth() { 307 | final float content = 2 * 308 | Math.max(mRawMaxShadowSize, mCornerRadius + mInsetShadow + mRawMaxShadowSize / 2); 309 | return content + (mRawMaxShadowSize + mInsetShadow) * 2; 310 | } 311 | 312 | float getMinHeight() { 313 | final float content = 2 * Math.max(mRawMaxShadowSize, mCornerRadius + mInsetShadow 314 | + mRawMaxShadowSize * SHADOW_MULTIPLIER / 2); 315 | return content + (mRawMaxShadowSize * SHADOW_MULTIPLIER + mInsetShadow) * 2; 316 | } 317 | } 318 | -------------------------------------------------------------------------------- /aslibrary/src/main/java/com/hitomi/aslibrary/ActivitySwitcherHelper.java: -------------------------------------------------------------------------------- 1 | package com.hitomi.aslibrary; 2 | 3 | import android.app.Activity; 4 | import android.app.Application; 5 | import android.app.WallpaperManager; 6 | import android.content.Context; 7 | import android.graphics.Bitmap; 8 | import android.graphics.drawable.BitmapDrawable; 9 | import android.graphics.drawable.ColorDrawable; 10 | import android.graphics.drawable.Drawable; 11 | import android.os.AsyncTask; 12 | import android.support.annotation.NonNull; 13 | import android.util.DisplayMetrics; 14 | import android.view.View; 15 | import android.view.ViewGroup; 16 | import android.view.Window; 17 | import android.widget.FrameLayout; 18 | import android.widget.ImageView; 19 | 20 | import java.lang.reflect.Field; 21 | import java.util.ArrayList; 22 | import java.util.List; 23 | 24 | /** 25 | * ActivitySwitch 帮助类。负责： 26 | *
-
27 | *
- 打开/关闭 ActivitySwitcher 28 | *
- ActivitySwitcher 背景处理 29 | *
- Activity关闭，程序结束进程处理 30 | *
33 | * 34 | * github : https://github.com/Hitomis
35 | * 36 | * Created by hitomi on 2016/10/11. 37 | */ 38 | class ActivitySwitcherHelper { 39 | 40 | private ActivitySwitcher actSwitcher; 41 | 42 | private Context appContext; 43 | 44 | private ActivityManager actManager; 45 | 46 | private ActivityControllerLayout actControllerLayout; 47 | 48 | private List
227 | * 228 | * 高斯模糊性能优化，参考文章 ：[here] 229 | */ 230 | private void setContainerBackground() { 231 | new AsyncTask
21 | * 22 | * email : 196425254@qq.com
23 | * 24 | * github : https://github.com/Hitomis
25 | * 26 | * Created by hitomi on 2016/10/11. 27 | */ 28 | class ActivityControllerLayout extends FrameLayout implements View.OnClickListener{ 29 | public static final String TAG = "ActivitySwitcher"; 30 | 31 | public static final int FLAG_DISPLAYING = 100; 32 | public static final int FLAG_DISPLAYED = 200; 33 | public static final int FLAG_CLOSING = -100; 34 | public static final int FLAG_CLOSED = -200; 35 | public static final int FLAG_SLIDING = 0; 36 | 37 | private static final int STYLE_SINGLE = 1; 38 | private static final int STYLE_DOUBLE = 1 << 1; 39 | 40 | private static final int STYLE_MULTIPLE = 1 << 2; 41 | 42 | private static final float CENTER_SCALE_RATE = .65f; 43 | private static final float OFFSET_SCALE_RATE = .02f; 44 | 45 | private static final int MIN_OFFSET_SIZE = 80; 46 | private static final int MAX_OFFSET_SIZE = 180; 47 | 48 | private int maxVelocity = 2500; 49 | private int touchSlop = 8; 50 | 51 | private int flag; 52 | private int width; 53 | 54 | private float pageOffsetSize; 55 | private float preY, diffY; 56 | private float controlViewBottom = 0.f; 57 | 58 | private float[] originalContainerX; 59 | private float[] originalContainerScale; 60 | 61 | private boolean resetBackground; 62 | 63 | private VelocityTracker velocityTracker; 64 | 65 | private OnControlCallback onControlCallback; 66 | private ActivityContainer controlView; 67 | 68 | public ActivityControllerLayout(Context context) { 69 | this(context, null); 70 | } 71 | 72 | public ActivityControllerLayout(Context context, AttributeSet attrs) { 73 | this(context, attrs, 0); 74 | } 75 | 76 | public ActivityControllerLayout(Context context, AttributeSet attrs, int defStyleAttr) { 77 | super(context, attrs, defStyleAttr); 78 | flag = FLAG_CLOSED; 79 | width = getResources().getDisplayMetrics().widthPixels; 80 | } 81 | 82 | @Override 83 | public void addView(View child) { 84 | child.setOnClickListener(this); 85 | super.addView(child); 86 | } 87 | 88 | @Override 89 | public boolean dispatchTouchEvent(MotionEvent ev) { 90 | if (flag == FLAG_DISPLAYED || flag == FLAG_SLIDING) 91 | switch (ev.getAction()) { 92 | case MotionEvent.ACTION_DOWN: 93 | if (null == velocityTracker) { 94 | velocityTracker = VelocityTracker.obtain(); 95 | } else { 96 | velocityTracker.clear(); 97 | } 98 | velocityTracker.addMovement(ev); 99 | 100 | if (findControlView(ev) == null || flag == FLAG_SLIDING) return false; 101 | cacheOrginalContainerParamter(controlView = findControlView(ev)); 102 | 103 | preY = ev.getY(); 104 | break; 105 | case MotionEvent.ACTION_MOVE: 106 | velocityTracker.addMovement(ev); 107 | 108 | diffY = ev.getY() - preY; 109 | float newDiffY = diffY; 110 | if (controlView.getY() <= 0) { // 在中线之上 111 | moveToLastContainerPos(); 112 | } else if (controlView.getY() > 0 && diffY > 0) { // 在中线之下 113 | float slopRate = 1.f - 1.65f * controlView.getY() / (controlView.getIntrinsicHeight()); 114 | newDiffY *= slopRate; 115 | } 116 | controlView.setY(controlView.getY() + newDiffY); 117 | 118 | preY = ev.getY(); 119 | break; 120 | case MotionEvent.ACTION_UP: 121 | velocityTracker.addMovement(ev); 122 | velocityTracker.computeCurrentVelocity(1000); 123 | float velocityY = velocityTracker.getYVelocity(); 124 | 125 | boolean over = Math.abs(controlView.getY()) >= controlView.getIntrinsicHeight() * .618; 126 | if (diffY < touchSlop * .4f && controlView.getY() < 0 && (over || Math.abs(velocityY) >= maxVelocity)) { 127 | // 上移且超出阈值 或者 上移速度超过阈值 -> 移除到窗外 128 | slideOutAnimation(); 129 | } else if (flag != FLAG_CLOSING && Math.abs(controlView.getY()) >= touchSlop) { 130 | // 下移或者上移没有超出阈值- > 回落到原始位置 131 | slideOrignalPosAnimation(); 132 | } 133 | 134 | diffY = 0; 135 | 136 | if (null != velocityTracker) { 137 | velocityTracker.recycle(); 138 | velocityTracker = null; 139 | } 140 | break; 141 | case MotionEvent.ACTION_CANCEL: 142 | if (null != velocityTracker) { 143 | velocityTracker.recycle(); 144 | velocityTracker = null; 145 | } 146 | break; 147 | } 148 | return super.dispatchTouchEvent(ev); 149 | } 150 | 151 | @Override 152 | public void onClick(final View view) { 153 | if (flag == FLAG_DISPLAYED 154 | && Math.abs(diffY) < touchSlop 155 | && Math.abs(view.getY()) < touchSlop) { 156 | closure(false); 157 | } 158 | } 159 | 160 | private void cacheOrginalContainerParamter(ActivityContainer controlContainer) { 161 | controlViewBottom = controlContainer.getBounds().bottom; 162 | int controlIndex = indexOfChild(controlContainer); 163 | if (getChildCount() != 3) { 164 | originalContainerX = new float[getChildCount()]; 165 | originalContainerScale = new float[getChildCount()]; 166 | View child; 167 | for (int i = 0; i < getChildCount(); i++) { 168 | child = getChildAt(i); 169 | originalContainerX[i] = child.getX(); 170 | originalContainerScale[i] = child.getScaleX(); 171 | } 172 | } else { 173 | originalContainerX = new float[2]; 174 | originalContainerScale = new float[2]; 175 | if (controlIndex == 0) { 176 | originalContainerX[0] = getChildAt(1).getX(); 177 | originalContainerX[1] = getChildAt(2).getX(); 178 | 179 | originalContainerScale[0] = getChildAt(1).getScaleX(); 180 | originalContainerScale[1] = getChildAt(2).getScaleX(); 181 | } else if (controlIndex == 1) { 182 | originalContainerX[0] = getChildAt(0).getX(); 183 | originalContainerX[1] = getChildAt(2).getX(); 184 | 185 | originalContainerScale[0] = getChildAt(0).getScaleX(); 186 | originalContainerScale[1] = getChildAt(2).getScaleX(); 187 | } else { 188 | originalContainerX[0] = getChildAt(0).getX(); 189 | originalContainerX[1] = getChildAt(1).getX(); 190 | 191 | originalContainerScale[0] = getChildAt(0).getScaleX(); 192 | originalContainerScale[1] = getChildAt(1).getScaleX(); 193 | } 194 | 195 | } 196 | } 197 | 198 | private void slideOrignalPosAnimation() { 199 | ObjectAnimator tranYAnima = ObjectAnimator.ofFloat(controlView, "Y", controlView.getY(), 0); 200 | tranYAnima.setDuration(350); 201 | tranYAnima.setInterpolator(new DecelerateInterpolator()); 202 | tranYAnima.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { 203 | @Override 204 | public void onAnimationUpdate(ValueAnimator valueAnimator) { 205 | if (controlView.getY() < 0) 206 | moveToLastContainerPos(); 207 | } 208 | }); 209 | tranYAnima.start(); 210 | } 211 | 212 | private void slideOutAnimation() { 213 | flag = FLAG_SLIDING; 214 | float endTranY = controlView.getY() - controlView.getBounds().bottom; 215 | ObjectAnimator tranYAnima = ObjectAnimator.ofFloat(controlView, "Y", controlView.getY(), endTranY); 216 | tranYAnima.setDuration(150); 217 | tranYAnima.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { 218 | @Override 219 | public void onAnimationUpdate(ValueAnimator valueAnimator) { 220 | moveToLastContainerPos(); 221 | } 222 | }); 223 | tranYAnima.addListener(new AnimatorListenerAdapter() { 224 | @Override 225 | public void onAnimationEnd(Animator animation) { 226 | if (onControlCallback != null) { 227 | onControlCallback.onFling(controlView); 228 | } 229 | flag = FLAG_DISPLAYED; 230 | } 231 | }); 232 | tranYAnima.start(); 233 | } 234 | 235 | private void moveToLastContainerPos() { 236 | int controlIndex = indexOfChild(controlView); 237 | if (getChildCount() == 3) { 238 | View belowChild, aboveChild; 239 | float totalOffset, currOffset; 240 | if (controlIndex == 0) { 241 | belowChild = getChildAt(1); 242 | aboveChild = getChildAt(2); 243 | } else if (controlIndex == 1) { 244 | belowChild = getChildAt(0); 245 | aboveChild = getChildAt(2); 246 | } else { 247 | belowChild = getChildAt(0); 248 | aboveChild = getChildAt(1); 249 | } 250 | 251 | totalOffset = originalContainerX[0]; 252 | currOffset = calcOffsetSize(totalOffset); 253 | belowChild.setX(originalContainerX[0] + currOffset); 254 | 255 | totalOffset = CENTER_SCALE_RATE - originalContainerScale[0]; 256 | currOffset = calcOffsetSize(totalOffset); 257 | belowChild.setScaleX(originalContainerScale[0] - currOffset); 258 | belowChild.setScaleY(originalContainerScale[0] - currOffset); 259 | 260 | totalOffset = width * (CENTER_SCALE_RATE + OFFSET_SCALE_RATE) / 2 - originalContainerX[1]; 261 | currOffset = calcOffsetSize(totalOffset); 262 | aboveChild.setX(originalContainerX[1] - currOffset); 263 | 264 | totalOffset = CENTER_SCALE_RATE + OFFSET_SCALE_RATE - originalContainerScale[1]; 265 | currOffset = calcOffsetSize(totalOffset); 266 | aboveChild.setScaleX(originalContainerScale[1] - currOffset); 267 | aboveChild.setScaleY(originalContainerScale[1] - currOffset); 268 | } else if (getChildCount() != 1 && getChildCount() != controlIndex + 1) { 269 | float currOffsetX, currScaleSize; 270 | float totalOffsetX = originalContainerX[controlIndex + 1] - originalContainerX[controlIndex]; 271 | float totalScaleSize = getLayoutStyle() == STYLE_DOUBLE 272 | ? OFFSET_SCALE_RATE : 3 * OFFSET_SCALE_RATE; 273 | 274 | View child; 275 | for (int i = controlIndex + 1; i < getChildCount(); i++) { 276 | if (controlViewBottom == 0.f) continue; 277 | child = getChildAt(i); 278 | 279 | currOffsetX = calcOffsetSize(totalOffsetX); 280 | child.setX(originalContainerX[i] + currOffsetX); 281 | 282 | currScaleSize = calcOffsetSize(totalScaleSize); 283 | child.setScaleX(originalContainerScale[i] + currScaleSize); 284 | child.setScaleY(originalContainerScale[i] + currScaleSize); 285 | } 286 | } 287 | } 288 | 289 | private float calcOffsetSize(float totalSize) { 290 | return controlView.getY() * totalSize / controlViewBottom; 291 | } 292 | 293 | 294 | private ActivityContainer findControlView(MotionEvent ev) { 295 | int childCount = getChildCount(); 296 | ActivityContainer controlView = null; 297 | ActivityContainer container; 298 | for (int i = childCount - 1; i >= 0; i--) { 299 | container = (ActivityContainer) getChildAt(i); 300 | if (container.getBounds().contains(ev.getX(), ev.getY())) { 301 | controlView = container; 302 | break; 303 | } 304 | } 305 | return controlView; 306 | } 307 | 308 | @NonNull 309 | private ObjectAnimator getCheckedScaleXAnima(View view) { 310 | ObjectAnimator chooseScaleXAnima = ObjectAnimator.ofFloat(view, "scaleX", view.getScaleX(), 1.0f); 311 | chooseScaleXAnima.setDuration(200); 312 | return chooseScaleXAnima; 313 | } 314 | 315 | @NonNull 316 | private ObjectAnimator getCheckedScaleYAnima(View view) { 317 | ObjectAnimator chooseScaleYAnima = ObjectAnimator.ofFloat(view, "scaleY", view.getScaleY(), 1.0f); 318 | chooseScaleYAnima.setDuration(200); 319 | chooseScaleYAnima.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { 320 | @Override 321 | public void onAnimationUpdate(ValueAnimator valueAnimator) { 322 | removeShadow(valueAnimator); 323 | } 324 | }); 325 | return chooseScaleYAnima; 326 | } 327 | 328 | @NonNull 329 | private AnimatorSet singleStyleAnimator(View view) { 330 | AnimatorSet animatorSet = new AnimatorSet(); 331 | animatorSet.play(getCheckedScaleXAnima(view)) 332 | .with(getCheckedScaleYAnima(view)); 333 | return animatorSet; 334 | } 335 | 336 | private AnimatorSet doubleStyleAnimator(View view) { 337 | ObjectAnimator preObjAnima; 338 | if (indexOfChild(view) == 0) { 339 | float afterEndTranX = width * .5f; 340 | View afterChild = getChildAt(1); 341 | preObjAnima = ObjectAnimator.ofFloat(afterChild, "X", 342 | afterChild.getX(), afterChild.getX() + afterEndTranX); 343 | preObjAnima.setDuration(300); 344 | } else { 345 | preObjAnima = ObjectAnimator.ofFloat(view, "X", view.getX(), 0); 346 | preObjAnima.setDuration(200); 347 | } 348 | AnimatorSet animatorSet = new AnimatorSet(); 349 | animatorSet.play(preObjAnima) 350 | .before(getCheckedScaleXAnima(view)) 351 | .before(getCheckedScaleYAnima(view)); 352 | return animatorSet; 353 | } 354 | 355 | private AnimatorSet multipleStyleAnimator(final View view) { 356 | final int chooseIndex = indexOfChild(view); 357 | ValueAnimator afterTranXAnima = null; 358 | if (chooseIndex < getChildCount() - 1) { 359 | float afterEndTranX = width - (chooseIndex + 2) * pageOffsetSize; 360 | final float[] currX = new float[getChildCount() - chooseIndex -1]; 361 | for (int i = chooseIndex + 1; i < getChildCount(); i++) { 362 | currX[i - chooseIndex - 1] = getChildAt(i).getX(); 363 | } 364 | afterTranXAnima = ValueAnimator.ofFloat(0, afterEndTranX); 365 | afterTranXAnima.setDuration(300); 366 | afterTranXAnima.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { 367 | @Override 368 | public void onAnimationUpdate(ValueAnimator valueAnimator) { 369 | float valueX = Float.parseFloat(valueAnimator.getAnimatedValue().toString()); 370 | View afterChild; 371 | for (int i = chooseIndex + 1; i < getChildCount(); i++) { 372 | afterChild = getChildAt(i); 373 | afterChild.setX(currX[i - chooseIndex - 1] + valueX); 374 | } 375 | } 376 | }); 377 | } 378 | ObjectAnimator chooseTranXAnima = ObjectAnimator.ofFloat(view, "X", view.getX(), 0); 379 | chooseTranXAnima.setDuration(200); 380 | AnimatorSet animatorSet = new AnimatorSet(); 381 | AnimatorSet.Builder animaBuilder = animatorSet 382 | .play(chooseTranXAnima) 383 | .before(getCheckedScaleXAnima(view)) 384 | .before(getCheckedScaleYAnima(view)); 385 | if (afterTranXAnima != null) { 386 | animaBuilder.after(afterTranXAnima); 387 | } 388 | return animatorSet; 389 | } 390 | 391 | private Animator displayBySingleStyle() { 392 | final View singleChild = getChildAt(0); 393 | ValueAnimator scaleAnima = ValueAnimator.ofFloat(1, 100); 394 | scaleAnima.setDuration(200); 395 | scaleAnima.setInterpolator(new DecelerateInterpolator()); 396 | scaleAnima.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { 397 | @Override 398 | public void onAnimationUpdate(ValueAnimator valueAnimator) { 399 | float fraction = valueAnimator.getAnimatedFraction(); 400 | float scaleValue = 1 - (1 - CENTER_SCALE_RATE) * fraction; 401 | singleChild.setScaleX(scaleValue); 402 | singleChild.setScaleY(scaleValue); 403 | } 404 | }); 405 | return scaleAnima; 406 | } 407 | 408 | private Animator displayByDoubleStyle() { 409 | final View belowChild = getChildAt(0); 410 | final View aboveChild = getChildAt(1); 411 | ValueAnimator scaleAnima = ValueAnimator.ofFloat(1, 100); 412 | scaleAnima.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { 413 | @Override 414 | public void onAnimationUpdate(ValueAnimator valueAnimator) { 415 | float fraction = valueAnimator.getAnimatedFraction(); 416 | float scaleValue = 1 - (1 - CENTER_SCALE_RATE) * fraction; 417 | belowChild.setScaleX(scaleValue); 418 | belowChild.setScaleY(scaleValue); 419 | 420 | scaleValue = 1 - (1 - (CENTER_SCALE_RATE + OFFSET_SCALE_RATE)) * fraction; 421 | aboveChild.setScaleX(scaleValue); 422 | aboveChild.setScaleY(scaleValue); 423 | } 424 | }); 425 | 426 | float endTranX = width * (CENTER_SCALE_RATE + OFFSET_SCALE_RATE) / 2; 427 | ObjectAnimator tranXAnima = ObjectAnimator.ofFloat(aboveChild, "X", aboveChild.getX(), endTranX); 428 | 429 | AnimatorSet animatorSet = new AnimatorSet(); 430 | animatorSet.setDuration(200); 431 | animatorSet.setInterpolator(new DecelerateInterpolator()); 432 | animatorSet.play(scaleAnima).with(tranXAnima); 433 | return animatorSet; 434 | } 435 | 436 | private Animator displayByMultipleStyle() { 437 | ValueAnimator scaleAnima = ValueAnimator.ofFloat(1, 100); 438 | scaleAnima.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { 439 | @Override 440 | public void onAnimationUpdate(ValueAnimator valueAnimator) { 441 | float fraction = valueAnimator.getAnimatedFraction(); 442 | float scaleValue; 443 | int childCount = getChildCount(); 444 | View child; 445 | for (int i = 0; i < childCount; i++) { 446 | child = getChildAt(i); 447 | scaleValue = CENTER_SCALE_RATE + 3 * OFFSET_SCALE_RATE * (i - 1); 448 | scaleValue = 1 - (1 - scaleValue) * fraction; 449 | child.setScaleX(scaleValue); 450 | child.setScaleY(scaleValue); 451 | } 452 | } 453 | }); 454 | 455 | 456 | ValueAnimator tranXAnima = ValueAnimator.ofFloat(1, 100); 457 | tranXAnima.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { 458 | @Override 459 | public void onAnimationUpdate(ValueAnimator valueAnimator) { 460 | float fraction = valueAnimator.getAnimatedFraction(); 461 | int childCount = getChildCount(); 462 | float tranX; 463 | View child; 464 | float initTranX; 465 | for (int i = 0; i < childCount; i++) { 466 | child = getChildAt(i); 467 | initTranX = (width - width * (CENTER_SCALE_RATE + 3 * OFFSET_SCALE_RATE * (i - 1))) * .5f; 468 | tranX = pageOffsetSize * i; 469 | tranX = fraction * tranX - initTranX + pageOffsetSize; 470 | child.setX(tranX); 471 | } 472 | } 473 | }); 474 | AnimatorSet animatorSet = new AnimatorSet(); 475 | animatorSet.setDuration(200); 476 | animatorSet.setInterpolator(new DecelerateInterpolator()); 477 | animatorSet.play(scaleAnima).with(tranXAnima); 478 | return animatorSet; 479 | } 480 | 481 | private void removeShadow(ValueAnimator valueAnimator) { 482 | ViewGroup vgChild; 483 | RoundRectDrawableWithShadow drawable; 484 | if (valueAnimator.getAnimatedFraction() > .3f && !resetBackground) { 485 | for (int i = 0; i < getChildCount(); i++) { 486 | vgChild = (ViewGroup) getChildAt(i); 487 | if (vgChild.getBackground() instanceof RoundRectDrawableWithShadow) { 488 | drawable = (RoundRectDrawableWithShadow) vgChild.getBackground(); 489 | vgChild.setBackgroundColor(drawable.getBackgroundColor()); 490 | } 491 | } 492 | resetBackground = true; 493 | } 494 | } 495 | 496 | private int getLayoutStyle() { 497 | int style = 0; 498 | int childCount = getChildCount(); 499 | if (childCount == 1) { 500 | style = STYLE_SINGLE; 501 | } else if (childCount == 2) { 502 | style = STYLE_DOUBLE; 503 | } else if (childCount >=3) { 504 | style = STYLE_MULTIPLE; 505 | } 506 | return style; 507 | } 508 | 509 | private void updateContainerIntercept(boolean interceptEvent) { 510 | ActivityContainer container; 511 | for (int i = 0; i < getChildCount(); i++) { 512 | container = (ActivityContainer) getChildAt(i); 513 | container.setIntercept(interceptEvent); 514 | } 515 | } 516 | 517 | public void display(@NonNull OnControlCallback callback) { 518 | onControlCallback = callback; 519 | flag = FLAG_DISPLAYING; 520 | Animator animator; 521 | int childCount = getChildCount(); 522 | if (childCount <=0) return ; 523 | if (childCount == 1) { 524 | animator = displayBySingleStyle(); 525 | } else if (childCount == 2) { 526 | animator = displayByDoubleStyle(); 527 | } else { 528 | pageOffsetSize = width * 1.f / (childCount + 1); 529 | pageOffsetSize = pageOffsetSize < MIN_OFFSET_SIZE ? MIN_OFFSET_SIZE : pageOffsetSize; 530 | pageOffsetSize = pageOffsetSize > MAX_OFFSET_SIZE ? MAX_OFFSET_SIZE : pageOffsetSize; 531 | animator = displayByMultipleStyle(); 532 | } 533 | animator.addListener(new AnimatorListenerAdapter() { 534 | @Override 535 | public void onAnimationStart(Animator animation) { 536 | updateContainerIntercept(true); 537 | } 538 | 539 | @Override 540 | public void onAnimationEnd(Animator animation) { 541 | flag = FLAG_DISPLAYED; 542 | if (onControlCallback != null) 543 | onControlCallback.onDisplayed(); 544 | } 545 | }); 546 | animator.start(); 547 | } 548 | 549 | public void closure(boolean back) { 550 | controlView = controlView == null || indexOfChild(controlView) == -1 || back 551 | ? (ActivityContainer) getChildAt(getChildCount() - 1) 552 | : controlView; 553 | flag = FLAG_CLOSING; 554 | AnimatorSet animatorSet = null; 555 | resetBackground = false; 556 | switch (getLayoutStyle()) { 557 | case STYLE_SINGLE: 558 | animatorSet = singleStyleAnimator(controlView); 559 | break; 560 | case STYLE_DOUBLE: 561 | animatorSet = doubleStyleAnimator(controlView); 562 | break; 563 | case STYLE_MULTIPLE: 564 | animatorSet = multipleStyleAnimator(controlView); 565 | break; 566 | } 567 | if (animatorSet == null) return ; 568 | animatorSet.addListener(new AnimatorListenerAdapter() { 569 | @Override 570 | public void onAnimationEnd(Animator animation) { 571 | if (onControlCallback != null) 572 | onControlCallback.onSelected(controlView); 573 | 574 | updateContainerIntercept(false); 575 | controlView.setOnClickListener(null); 576 | controlView = null; 577 | flag = FLAG_CLOSED; 578 | } 579 | }); 580 | animatorSet.start(); 581 | } 582 | 583 | public int getFlag() { 584 | return flag; 585 | } 586 | 587 | public void log(String text) { 588 | Log.d(TAG, text); 589 | } 590 | 591 | public interface OnControlCallback { 592 | 593 | void onDisplayed(); 594 | 595 | void onSelected(ActivityContainer selectedContainer); 596 | 597 | void onFling(ActivityContainer flingContainer); 598 | 599 | } 600 | } 601 | --------------------------------------------------------------------------------