美文网首页
Android-绘图-半透明/蒙层引导用户

Android-绘图-半透明/蒙层引导用户

作者: lioilwin | 来源:发表于2017-08-27 15:53 被阅读388次

一.使用半透明图引导

    
// 同时添加两个目标View,即同一层图两个高亮目标View
GuideUserView.show(MainActivity.this,
    new ViewEntity(目标View1, R.layout.guide1, Direction.BOTTOM),
    new ViewEntity(目标View2, R.layout.guide2, Direction.BOTTOM));
    
// 自定义布局guide1.xml
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:orientation="vertical">
    <View
        android:layout_width="64dp"
        android:layout_height="64dp"
        android:background="@drawable/arrow"/>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="使用说明"/>
</LinearLayout>

二.GuideUserView类

1.GuideUserView类继承相对布局      
2.添加自定义布局mCustomLayout,通过Margins设置mCustomLayout的位置  
3.用canvas在mTargetView周围绘制高亮圆圈  
4.用mPaint.setXfermode(xx)去除高亮圆圈和半透明背景的交集  

import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.RectF;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewTreeObserver;
import android.widget.FrameLayout;
import android.widget.RelativeLayout;
import static com.wellcell.view.GuideUserView.Shape.CIRCULAR;
import static com.wellcell.view.GuideUserView.Shape.ELLIPSE;
import static com.wellcell.view.GuideUserView.Shape.RECTANGULAR;

@SuppressLint("ViewConstructor")
public class GuideUserView extends RelativeLayout implements ViewTreeObserver.OnGlobalLayoutListener {
    private final static String TAG = "GuideUserView";
    private final static String PRI = "GuideUserViewID_";
    private final ClickListener mClickListener;
    private Context mContent;
    private final Paint mPaint = new Paint();
    private final RectF mRect = new RectF();
    private ViewEntity[] mViews; // 目标View、自定义布局等参数实体数组
    private boolean handleTouch = false;

    /**
     * 默认显示一次
     */
    public static void show(Context context, ViewEntity... views) {
        GuideUserView.show(true, null, context, views);
    }

    /**
     * 默认显示一次,监听点击
     */
    public static void show(ClickListener clickListener, Context context, ViewEntity... views) {
        GuideUserView.show(true, clickListener, context, views);
    }

    public static void show(boolean showOne, ClickListener clickListener, Context context, ViewEntity... views) {
        try {
            if (showOne) {
                String id = PRI + views[0].mCustomLayoutID;
                if (context.getSharedPreferences(TAG, Context.MODE_PRIVATE).getBoolean(id, false))
                    return;
                context.getSharedPreferences(TAG, Context.MODE_PRIVATE).edit().putBoolean(id, true).apply();
            }
            new GuideUserView(context, clickListener, views);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private GuideUserView(Context context, ClickListener clickListener, ViewEntity... views) {
        super(context);
        mContent = context;
        mClickListener = clickListener;
        mViews = views;
        mPaint.setAntiAlias(true);
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OUT)); // 去除两次绘图的交集
        setBackgroundColor(Color.TRANSPARENT);
        getViewTreeObserver().addOnGlobalLayoutListener(this);
        /*
            在Activity上面添加半透明/蒙层的引导View,有两种方法
            方法一
            ((FrameLayout) ((Activity) mContent).getWindow().getDecorView()).addView(this);
            ((FrameLayout) ((Activity) mContent).getWindow().getDecorView()).removeView(this);
            使用DecorView().addView,引导蒙层界面会被PopupWindow,Dialog等弹窗遮挡

            方法二
            WindowManager.LayoutParams params = new WindowManager.LayoutParams();
            params.format = PixelFormat.TRANSLUCENT;
            ((Activity) mContent).getWindow().getWindowManager().addView(this, params);
            ((Activity) mContent).getWindow().getWindowManager().removeView(this);
            该方法能覆盖PopupWindow,Dialog等弹窗,但有时获取目标View的坐标偶尔会失效,
            获取目标View的坐标方法:View.getLocationOnScreen, View.getLocationOnScreen,
                              View.getGlobalVisibleRect, View.getLocalVisibleRect
        */
        ((FrameLayout) ((Activity) mContent).getWindow().getDecorView()).addView(this); //添加蒙层View
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (!handleTouch) {
            handleTouch = true;
            if (mClickListener != null)
                mClickListener.onClick();
//            ((Activity) mContent).getWindow().getWindowManager().removeView(this);
            ((FrameLayout) ((Activity) mContent).getWindow().getDecorView()).removeView(this);//移除蒙层View
        }
        return true;
    }

    @Override
    public void onGlobalLayout() {// 监听全局视图树开始布局
        getViewTreeObserver().removeOnGlobalLayoutListener(this);
        addCustomView();
    }

    protected void addCustomView() {// 在目标view周围添加自定义布局
        int statusBarHeight = 0;
        int resourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");
        if (resourceId > 0)
            statusBarHeight = getResources().getDimensionPixelSize(resourceId);
        for (final ViewEntity ve : mViews) {
            // 获取targetView的中心坐标
            if (ve.mTargetView != null) {
                ve.targetW = ve.mTargetView.getWidth() / 2;
                ve.targetH = ve.mTargetView.getHeight() / 2;
                ve.mTargetView.getLocationOnScreen(ve.mCenter);
                ve.mCenter[0] += ve.targetW;
                ve.mCenter[1] += ve.targetH;
            }
            // 方位
            View view = LayoutInflater.from(getContext()).inflate(ve.mCustomLayoutID, this, false);
            LayoutParams params = (LayoutParams) view.getLayoutParams();
            if (ve.mDirection != null) {
                int width = getWidth();
                int height = getHeight();
                int left = ve.mCenter[0] - ve.targetW;
                int right = ve.mCenter[0] + ve.targetW;
                int top = ve.mCenter[1] - ve.targetH;
                int bottom = ve.mCenter[1] + ve.targetH;
                switch (ve.mDirection) {
                    case TOP:
                        params.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM);
                        params.setMargins(left, 0, 0, height - top);
                        break;
                    case LEFT:
                        params.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
                        params.setMargins(0, top, width - left, 0);
                        break;
                    case BOTTOM:
                        params.setMargins(left, bottom, 0, 0);
                        break;
                    case RIGHT:
                        params.setMargins(right, top, 0, 0);
                        break;
                    case LEFT_TOP:
                        params.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM);
                        params.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
                        params.setMargins(0, 0, width - left, height - top);
                        break;
                    case LEFT_BOTTOM:
                        params.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
                        params.setMargins(0, bottom, width - left, 0);
                        break;
                    case RIGHT_TOP:
                        params.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM);
                        params.setMargins(right, 0, 0, height - top);
                        break;
                    case RIGHT_BOTTOM:
                        params.setMargins(right, bottom, 0, 0);
                        break;
                }
            } else {
                params.addRule(RelativeLayout.CENTER_IN_PARENT);
            }
            addViewInLayout(view, -1, params, true);// 添加view, 不会重新布局
        }
        requestLayout();// 统一重新布局
    }

    @Override
    protected void onDraw(Canvas canvas) {
        canvas.saveLayer(0, 0, getWidth(), getHeight(), null, Canvas.ALL_SAVE_FLAG); // 新建图层
        canvas.drawColor(0x77000000);// 绘制半透明背景
        // 在目标View周围裁剪出高亮圆圈
        for (ViewEntity ve : mViews) {
            if (ve.targetW == 0 || ve.targetH == 0)
                return;
            if (ve.mShape == ELLIPSE) {
                // 椭圆
                mRect.left = ve.mCenter[0] - ve.targetW;
                mRect.top = ve.mCenter[1] - ve.targetH;
                mRect.right = ve.mCenter[0] + ve.targetW;
                mRect.bottom = ve.mCenter[1] + ve.targetH;
                canvas.drawOval(mRect, mPaint);
            } else if (ve.mShape == RECTANGULAR) {
                // 矩形
                mRect.left = ve.mCenter[0] - ve.targetW;
                mRect.top = ve.mCenter[1] - ve.targetH;
                mRect.right = ve.mCenter[0] + ve.targetW;
                mRect.bottom = ve.mCenter[1] + ve.targetH;
                canvas.drawRoundRect(mRect, 16, 16, mPaint);
            } else if (ve.mShape == CIRCULAR) {
                // 圆形
                canvas.drawCircle(ve.mCenter[0], ve.mCenter[1], ve.targetW, mPaint);
            }
        }
    }

    public interface ClickListener {
        void onClick();
    }

    /**
     * 目标View和自定义布局等参数实体
     */
    public static class ViewEntity {
        private View mTargetView; // 目标wiew
        private int[] mCenter = new int[2]; // 目标wiew中心坐标
        private Shape mShape; // 目标wiew高亮圆圈形状
        private int targetW = -1; // 目标wiew高亮宽半径
        private int targetH = -1; // 目标wiew高亮高半径

        private int mCustomLayoutID; // 自定义布局资源ID
        private Direction mDirection; // 自定义布局相对于目标wiew的方向

        public ViewEntity(View targetView, int customLayoutID, Direction direction) {
            this(targetView, null, Shape.RECTANGULAR, customLayoutID, direction);
        }

        public ViewEntity(View targetView, int[] targetSize, Shape shape, int customLayoutID, Direction direction) {
            this.mTargetView = targetView;
            this.mShape = shape;
            this.mCustomLayoutID = customLayoutID;
            this.mDirection = direction;
            if (targetSize != null) {
                targetW = targetSize[0] / 2;
                targetH = targetSize[1] / 2;
            }
        }
    }

    public enum Direction { // 相对于目标wiew的方位
        LEFT, TOP, RIGHT, BOTTOM, LEFT_TOP, LEFT_BOTTOM, RIGHT_TOP, RIGHT_BOTTOM
    }

    public enum Shape { // 目标wiew的高亮圆圈形状: 圆形,椭圆,圆角矩形
        CIRCULAR, ELLIPSE, RECTANGULAR
    }
}

简书: http://www.jianshu.com/p/48a078632fd4
CSDN博客: http://blog.csdn.net/qq_32115439/article/details/67006241
GitHub博客:http://lioil.win/2017/03/27/Android-GuideUser.html
Coding博客:http://c.lioil.win/2017/03/27/Android-GuideUser.html

相关文章

  • Android-绘图-半透明/蒙层引导用户

    一.使用半透明图引导 二.GuideUserView类 简书: http://www.jianshu.com/p/...

  • 使用PorterDuffXfermode图片合成实现安卓新手引导

    一些APP需要新手引导功能,如下图所示: 一个黑色半透明的浮层盖住页面的大部分,需要引导用户操作的地方突出显示。实...

  • CSS 半透明遮罩层

    很多时候,我们需要通过一层半透明的遮罩层来把后面的一切整体调暗,以便凸显某个特定的UI元素,引导用户关注,比如弹出...

  • 蒙层的写法总结

    背景   前段时间画页面有一个小需求,就是点击「分享」按钮,页面出现一个半透明的蒙层,然后突出显示一个图片,引导用...

  • 网站运营-用户量=用户动机/行动成本

    网站运营-用户量=用户动机/行动成本 产品功能没人用呢?加强UI,大红大紫,增加红点,蒙层提示,做足用户引导,以免...

  • 利用layer的mask属性实现APP半透明引导蒙层

    如今APP中新版本都会有些半透明蒙层引导,例如下面这种的。 之前我都是用一张图片覆盖到相应的位置来完成需求,还要考...

  • iOS页面蒙层新手引导SDK-技术方案

    目标 技术方案 1. 引导页展示逻辑 页面首次展示时,展示引导蒙层 引导蒙层有单独版本号,在版本号不升级的情况下只...

  • 「React Native」引导蒙层

    一、背景 做引导蒙层,效果如图 二、实现 1.获取目标节点的在屏幕的x,y坐标。 1)布局 2)获取元素在屏幕的x...

  • WKViewManager iOS 弹窗架构

    前言 近来由于App中弹窗过多,再加上还有半透明的引导层,时常会出现多个弹窗重叠弹出,甚至会伴随引导层一起弹出,极...

  • Android开发新手引导层

    新手引导是指:用户第一次使用一个新下载的APP时,使用蒙层的技术+文字或图片来提示用户如何操作 APP,或介绍界面...

网友评论

      本文标题:Android-绘图-半透明/蒙层引导用户

      本文链接:https://www.haomeiwen.com/subject/kjzbdxtx.html