EasyFloat:浮窗从未如此简单

作者 : 开心源码 本文共19344个字,预计阅读时间需要49分钟 发布时间: 2022-05-13 共300人阅读

应用浮窗因为良好的便捷性和拓展性,在某些场景下有着不错的交互体验。
凑巧项目需求有用到,可是逛了一圈GitHub,并没有找到满意的浮窗控件。
索性造个好用的轮子,方便你我他,遂成此文。
GitHub地址:EasyFloat

需求:我们想要什么

  • 要能浮在某个单独的页面上,或者者多个页面上;
  • 要支持拖拽,这样才够灵活;
  • 可能需要吸附边缘,也可能不需要吸附;
  • 要支持浮窗内部的点击、拖拽;
  • 要灵活的控制浮窗的显示、隐藏、销毁等;
  • 要能够自行设定出入动画,这样才够炫酷、个性;
  • 要能够过滤不需要显示的页面;
  • 要能够指定位置、设置对齐方式和偏移量;
  • 权限管理要简单,能不需要最好;
  • 要能有各个状态的监测、方便拓展;
  • 还得使用方便、兼容性要强;
  • 反正想要的很多…

这么多需求,应该能满足非极端使用场景了。可是这么多需求,我们需要如何一步步实现呐?

分析:伪装头脑风暴

1,如何浮在其余视图之上:

我们知道想要把View浮在其余视图之上,有两种实现方式:

  • 将View增加到Activity的根布局,因为根布局是个FrameLayout,所以后增加的上层显示;
  • 创立Window窗口,直接将View增加到WindowManager中,这样可以实现在所有的页面显示。

增加到Activity根布局相比照较简单,也不需要额外的权限。可是最大的问题是跟随Activity生命周期,只能在当前Activity显示。

Window窗口则能很好的处理全局显示的问题,可是在Android 6.0之后(特殊机型除外),使用TYPE_APPLICATION_OVERLAY属性,需要进行悬浮窗权限的申请,必需手动受权。假如我们只要要在当前页面使用浮窗功能,又会觉得太重,使用不方便。

那我们改如何抉择两者?答案:都用,根据浮窗类型使用不同的创立方式。

2,怎样拖拽、怎样设置View:

既然要实现拖拽,一定要从Touch事件下手,是单纯的onTouchEvent重写,还是要结合onInterceptTouchEvent作操作,我们后面再细说。但无论我们是以哪种方式创立的浮窗,都可以通过Touch事件实现拖拽效果,只是少量实现细节的不同。

既然说两种浮窗的拖拽过程,有些许不同,那我们最好不要把自己设置的拖拽View放在xml的根节点。由于那样我们写布局文件的时候,还需要进行区分;所以我们把拖拽View作为壳,放在浮窗控件的内部,我们只要设置要展现的xml布局,而后将xml布局增加到拖拽壳里面,各司其职。

3,系统浮窗需要权限申请,权限如何解决:

既然是权限相关的操作,一定包括下面三个部分:

  • 悬浮窗权限的检测;
  • 有权限则直接创立,没有权限则跳转到权限受权页;
  • 根据受权结果,继续创立浮窗或者者回调创立失败。

这些操作可以由开发人员一步步完成,但作为喜欢偷懒的我们,一定希望轮子能够自主完成这一切。但是我们应该怎样做呐?

因为权限申请,需要在onActivityResult解决受权结果,所以只能在Activity或者者Fragment中进行。
作为一个合格的轮子,我们一定不能选择在Activity中操作;所以我们选择在轮子内部维护一个不可见的Fragment,进行权限的申请和受权结果的后续操作,在不需要的时候移除Fragment。

4,系统浮窗生命周期很长,如何创立、如何管理:

因为系统浮窗是作为全局使用的,生命周期很长。假如直接在Activity创立,当遇到Activity被销毁时,这时的浮窗将是不可控的,满足不了我们的需求啊。

怎样办呐?我们可以选择Service,通过StartService启动一个浮窗Service,通过这个Service专门用来管理系统浮窗。

因为StartService启动的Service,不受启动者公告周期的影响,使用场景更广泛;想要控制浮窗的显示、隐藏、销毁,也只要用发送动态广播,在Service内部进行相应的广播接收,并做出解决就可。

5,假如只需前端显示、或者者有页面不需要显示怎样办:

想要只在前端显示,我们首先要做的就是获取前后端的状态,这个应该怎样做呐?

我们可以通过ActivityLifecycleCallbacks感知各个Activity的生命周期,通过计算打开和关闭Activity的数目,即可以知道当前APP处于前端还是后端;而后根据前后端发广播控制浮窗显示或者者隐藏。

同理,有需要过滤的Activity,我们只要要监听它的生命周期变化,而后去控制显示和隐藏就好了。

6,我们需要出入动画,还不想每个都一样:

学过策略模式的都应该知道,只需实现相应的接口或者者复写笼统方法,即可以去做你想要的结果。
我们把入场动画、退场动画的方法,定义在策略基类中;稍加操作,应有尽有…

分析过程就阐述这么多吧,这里进行了粗略的逻辑整理,我们一起看下:

EasyFloat流程图.png

说一千道一万,还是图片来的更直观,那有没有更直观的呐?
还真有,我们一起看一下效果图吧:

权限申请系统浮窗
前端和过滤状态回调拓展使用

效果大致就是这个样子,假如感兴趣,我们一起看看是怎样实现的…

实施:那我们动手了

1,属性管理:

工欲善其事,必先利其器。
既然浮窗属性比较多,为了方便管理,我们建个属性管理类,将各属性放在一起,统一管理:

data class FloatConfig(    // 浮窗的xml布局文件    var layoutId: Int? = null,    // 当前浮窗的tag    var floatTag: String? = null,    // 能否可拖拽    var dragEnable: Boolean = true,    // 能否正在被拖拽    var isDrag: Boolean = false,    // 能否正在执行动画    var isAnim: Boolean = false,    // 能否显示    var isShow: Boolean = false,    // 浮窗的吸附方式(默认不吸附,拖到哪里是哪里)    var sidePattern: SidePattern = SidePattern.DEFAULT,    // 浮窗显示类型(默认只在当前页显示)    var showPattern: ShowPattern = ShowPattern.CURRENT_ACTIVITY,    // 宽高能否充满父布局    var widthMatch: Boolean = false,    var heightMatch: Boolean = false,    // 浮窗的摆放方式,使用系统的Gravity属性    var gravity: Int = 0,    // 坐标的偏移量    var offsetPair: Pair<Int,Int> = Pair(0,0),    // 固定的初始坐标,左上角坐标    var locationPair: Pair<Int, Int> = Pair(0, 0),    // ps:优先使用固定坐标,若固定坐标不为原点坐标,gravity属性和offset属性无效    // Callbacks    var invokeView: OnInvokeView? = null,    var callbacks: OnFloatCallbacks? = null,    // 出入动画    var floatAnimator: OnFloatAnimator? = DefaultAnimator(),    var appFloatAnimator: OnAppFloatAnimator? = AppFloatDefaultAnimator(),    // 不需要显示系统浮窗的页面集合,参数为类名    val filterSet: MutableSet<String> = mutableSetOf(),    // 能否需要显示,当过滤信息匹配上时,该值为false    internal var needShow: Boolean = true)

属性都是一步步增加的,这里我们直接展现了最终的属性列表。
为了使用方便,我们还为每个属性设置了默认值,这样即便不配什么参数,也可以创立一个简易的浮窗。

2,写一个支持拖拽的普通控件:

前面我们有说过,拖拽功能在于重写Touch事件。所以我们就写一个自己的控件,继承自ViewGroup,这里我们使用的是FrameLayout,而后重写onTouchEvent方法:

override fun onTouchEvent(event: MotionEvent?): Boolean {    // updateView(event)是拖拽功能的具体实现    if (event != null) updateView(event)    // 假如是拖拽,这消费此事件,否则返回默认情况,防止影响子View事件的消费    return config.isDrag || super.onTouchEvent(event)}

拖拽功能的实现思路就是:记录ACTION_DOWN的坐标信息,在发生ACTION_MOVE的时候,计算两者的差值,为View设置新的坐标;并且记录升级后的坐标,为下次ACTION_MOVE提供新的基准。

private fun updateView(event: MotionEvent) {    // 关闭拖拽/执行动画阶段,不可拖动    if (!config.dragEnable || config.isAnim) {        config.isDrag = false        isPressed = true        return    }    val rawX = event.rawX.toInt()    val rawY = event.rawY.toInt()    when (event.action and MotionEvent.ACTION_MASK) {        MotionEvent.ACTION_DOWN -> {            // 默认是点击事件,而非拖拽事件            config.isDrag = false            isPressed = true            lastX = rawX            lastY = rawY            // 父布局不要阻拦子布局的监听            parent.requestDisallowInterceptTouchEvent(true)            initParent()        }        MotionEvent.ACTION_MOVE -> {            // 只有父布局存在才可以拖动            if (parentHeight <= 0 || parentWidth <= 0) return            val dx = rawX - lastX            val dy = rawY - lastY            // 忽略过小的移动,防止点击无效            if (!config.isDrag && dx * dx + dy * dy < 81) return            config.isDrag = true            var tempX = x + dx            var tempY = y + dy            // 检测能否到达边缘            tempX = when {                tempX < 0 -> 0f                tempX > parentWidth - width -> parentWidth - width.toFloat()                else -> tempX            }            tempY = when {                tempY < 0 -> 0f                tempY > parentHeight - height -> parentHeight - height.toFloat()                else -> tempY            }            // 升级位置            x = tempX            y = tempY            lastX = rawX            lastY = rawY        }        // 假如是拖动状态下即非点击按压事件        MotionEvent.ACTION_UP ->  isPressed = !config.isDrag        else -> return    }}

因为项目支持多种吸附方式和回调,真实情况比示例代码复杂许多,但核心代码如此。

这下拖拽效果是有的,可是在使用中发现了新的问题:假如子View有点击事件,会导致该控件的拖拽失效。

这是因为安卓的Touch事件传递机制导致的,子View优先享用Touch事件;默认情况下,只有在子View不消费事件的情况下,父控件才能够接受到事件。

那我们有什么方法改变这一现状呐?好在父控件存在阻拦机制,使用onInterceptTouchEvent方法可以对Touch事件进行阻拦,优先使用Touch事件。

当返回值为true的时候,代表我们将事件进行了阻拦,子View将不会在收到Touch事件,并且会调用当前控件的onTouchEvent方法。

所以我们需要在onTouchEvent方法和onInterceptTouchEvent方法都进行拖拽的逻辑解决,那么我们还需要加上下面这段代码:

override fun onInterceptTouchEvent(event: MotionEvent?): Boolean {    if (event != null) updateView(event)    // 是拖拽事件就进行阻拦,反之不阻拦    // ps:阻拦后将不再回调该方法,所以后续事件需要在onTouchEvent中回调    return config.isDrag || super.onInterceptTouchEvent(event)}

至此,我们处理了控件的拖拽问题,和子View的点击问题。

拖拽控件不仅作为Activity浮窗的壳使用,也可以作为单独的控件使用,直接在xml布局文件里包裹其余控件,即可以实现相应的拖拽效果。

系统浮窗的拖拽实现有些许的不同,主要是修改坐标的方式不同,核心思想也是一样的。这里就不进行展现了,有需要的话,可以看一下相关代码。

3,创立一个Activity浮窗:

Activity浮窗的创立相对简单,可以归纳为下面三步:

  • 拖拽效果由自己设置的拖拽布局实现;
  • 将拖拽布局,增加到Activity的根布局;
  • 再将浮窗的xml布局,增加到拖拽布局中,从而实现拖拽效果。

至于Activity根布局,就是屏幕底层FrameLayout,可通过DecorView进行获取:

// 通过DecorView 获取屏幕底层FrameLayout,即activity的根布局,作为浮窗的父布局private var parentFrame: FrameLayout = activity.window.decorView.findViewById(android.R.id.content)

下面就是创立过程:

fun createActivityFloat(config: FloatConfig) {    // 获取可拖拽浮窗的外壳    val shell =        LayoutInflater.from(activity).inflate(R.layout.float_layout, parentFrame, false)    // 为浮窗打上tag,假如未设置tag,使用类名作为tag    shell.tag = config.floatTag ?: activity.componentName.className    // 默认wrap_content,会导致子view的match_parent无效,所以手动设置params    shell.layoutParams = FrameLayout.LayoutParams(        if (config.widthMatch) FrameLayout.LayoutParams.MATCH_PARENT else FrameLayout.LayoutParams.WRAP_CONTENT,        if (config.heightMatch) FrameLayout.LayoutParams.MATCH_PARENT else FrameLayout.LayoutParams.WRAP_CONTENT    ).apply {        // 如若未设置固定坐标,设置浮窗Gravity        if (config.locationPair == Pair(0, 0)) gravity = config.gravity    }    // 将浮窗外壳增加到根布局中    parentFrame.addView(shell)    // 获取浮窗对象,即自己设置的FloatingView    val floatingView = shell.findViewById<FloatingView>(R.id.floatingView).also {        // 同步配置        it.config = config        // 设置浮窗的布局文件,即我们传递过来的xml布局文件        it.setLayout(config.layoutId!!)        // 设置空点击事件,用于接收触摸事件        it.setOnClickListener {}    }    // 设置Callbacks    config.callbacks?.createdResult(true, null, floatingView)}

效果就是我们创立的View浮在当前Activity上了,而且可拖拽;结束当前Activity,浮窗也就不存在了。

4,创立一个系统浮窗:

前面我们有说过,体统浮窗最好在Service里创立,这里我们不考虑那么多,主要看下是如何把一个Window增加到WindowManager里面的。

因为创立一个Window有很多属性需要设置,所以我们先来看一下相关参数的初始化:

private lateinit var windowManager: WindowManagerprivate lateinit var params: WindowManager.LayoutParamsprivate fun initParams() {    windowManager = context.getSystemService(Service.WINDOW_SERVICE) as WindowManager    params = WindowManager.LayoutParams().apply {        // 安卓6.0 以后,全局的Window类别,必需使用TYPE_APPLICATION_OVERLAY        type = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY else WindowManager.LayoutParams.TYPE_PHONE        format = PixelFormat.RGBA_8888        gravity = Gravity.START or Gravity.TOP        // 设置浮窗以外的触摸事件可以传递给后面的窗口、不自动获取焦点、可以延伸到屏幕外(设置动画时能用到,动画结束需要去除该属性,不然旋转屏幕可能置于屏幕外部)        flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL or WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS        width = if (config.widthMatch) WindowManager.LayoutParams.MATCH_PARENT else WindowManager.LayoutParams.WRAP_CONTENT        height = if (config.heightMatch) WindowManager.LayoutParams.MATCH_PARENT else WindowManager.LayoutParams.WRAP_CONTENT        // 如若设置了固定坐标,直接定位        if (config.locationPair != Pair(0, 0)) {            x = config.locationPair.first            y = config.locationPair.second        }    }}

创立思路和Activity浮窗是一致的,只不过这次不是增加到Activity的根布局,而是直接增加到WindowManager:

private fun createAppFloat() {    // 创立一个frameLayout作为浮窗布局的父容器    frameLayout = ParentFrameLayout(context.applicationContext, config)    // 将浮窗布局文件增加到父容器frameLayout中,并返回该浮窗文件    val floatingView = LayoutInflater.from(context.applicationContext)        .inflate(config.layoutId!!, frameLayout, true)    // 将frameLayout增加到系统windowManager中    windowManager.addView(frameLayout, params)    // 通过重写frameLayout的Touch事件,实现拖拽效果    frameLayout?.touchListener = object : OnFloatTouchListener {        override fun onTouch(event: MotionEvent) =            touchUtils.updateFloat(frameLayout!!, event, windowManager, params)    }    ...    // 设置入场动画、设置Callbacks}

5,通过Service来管理系统浮窗:

  • 每次startService,都会调用onStartCommand方法,在该方法中通过AppFloatManager创立浮窗,并将manager增加到map集合中,方便管理;
  • 通过接收广播,管理浮窗的销毁和可见性变化;
  • 在销毁浮窗浮窗后,检测map中能否还有别的浮窗存在,假如没有别的浮窗存在,stopService。
internal class FloatService : Service() {    companion object {        ... // 少量静态常量        var floatMap = mutableMapOf<String, AppFloatManager>()        private var config = FloatConfig()        /**         * 开启创立浮窗的Service         */        fun startService(context: Context, floatConfig: FloatConfig) {            config = floatConfig            context.startService(Intent(context, FloatService::class.java))        }        /**         * 关闭浮窗后,检测能否需要关闭Service         */        fun checkStop(context: Context, floatTag: String?) {            // 先清理当条浮窗信息            if (floatMap.isNotEmpty()) floatMap.remove(floatTag)            // 如有没有其余浮窗存在,关闭Service            if (floatMap.isEmpty()) context.stopService(Intent(context, FloatService::class.java))        }        ...  // 发送广播的静态方法,外部可直接调用    }    // ***************************** Service 内部逻辑 *****************************    // 通过广播,接收少量指令(关闭浮窗、设置可见性)    private val receiver = object : BroadcastReceiver() {        override fun onReceive(context: Context, intent: Intent) {            // 过滤掉不满足的条件            if (intent.action != FLOAT_ACTION || floatMap.isNullOrEmpty()) return            val tag = intent.getStringExtra(FLOAT_TAG) ?: DEFAULT_TAG            when {                // 关闭系统浮窗                intent.getBooleanExtra(FLOAT_DISMISS, false) -> floatMap[tag]?.exitAnim()                // 设置浮窗可见                intent.getBooleanExtra(FLOAT_VISIBLE, true) -> floatMap[tag]?.setVisible(View.VISIBLE)                // 设置浮窗不可见                else -> floatMap[tag]?.setVisible(View.GONE)            }        }    }    override fun onCreate() {        super.onCreate()        // 注册动态广播接收器        registerReceiver(receiver, IntentFilter().apply { addAction(FLOAT_ACTION) })    }    override fun onBind(intent: Intent?): IBinder? = null    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {        if (checkTag()) {            // 通过floatManager创立浮窗,并将floatManager增加到map中            floatMap[config.floatTag!!] = AppFloatManager(this, config).apply { createFloat() }        } else {            config.callbacks?.createdResult(false, "请为系统浮窗设置不同的tag", null)            logger.w("请为系统浮窗设置不同的tag")        }        return START_NOT_STICKY    }    /**     * 检测浮窗的tag能否有效,不同的浮窗必需设置不同的tag     */    private fun checkTag(): Boolean {        // 假如未设置tag,设置默认tag        config.floatTag = config.floatTag ?: DEFAULT_TAG        // map为空使用默认值,有效        if (floatMap.isEmpty()) return true        // map不为空,tag比对,存在相同的无效        floatMap.forEach { (tag, _) -> run { if (tag == config.floatTag) return false } }        return true    }    override fun onDestroy() {        // 取消广播接收        unregisterReceiver(receiver)        super.onDestroy()    }}

Service的代码基本全贴出来了,毕竟它只是起到了中转和管理的作用;具体的系统浮窗功能,还是交由AppFloatManager来实现的。

既然使用Service,不要忘了在AndroidManifest.xml注册:

<service android:name="com.lzf.easyfloat.service.FloatService" />

6,系统浮窗创立前的权限管理:

即便是系统浮窗,安卓6.0之前也是不需要权限申请的,但这只是存在理想的情况下。因为安卓的碎片化严重,尤其神一样的国产手机面前,适配坑,权限适配神坑。

个人能力有限,遇到这种情况只好选择站着前人的肩膀上,Android 悬浮窗权限各机型各系统适配大全,这篇文章的处理方案还是比较全面的。所以本文的权限适配使用的此方案,但是该方案只具备适配性,不具备自主性。

为了提高自主性,我们先进行权限检测;假如发现没有受权,我们通过Fragment进行浮窗权限的申请。这样受权结果就不需要写在我们自己的Activity,直接在Fragment内部进行,并且通过接口受权结果告诉外部。

其实所谓的外部,也就是我们的Builder构建类。在我们的构建类拿到受权结果以后,根据受权情况选择继续创立浮窗,或者者回调创立失败。

internal class PermissionFragment : Fragment() {    companion object {        private var onPermissionResult: OnPermissionResult? = null        @SuppressLint("CommitTransaction")        fun requestPermission(activity: Activity, onPermissionResult: OnPermissionResult) {            this.onPermissionResult = onPermissionResult            activity.fragmentManager                .beginTransaction()                .add(PermissionFragment(), activity.localClassName)                .commitAllowingStateLoss()        }    }    override fun onActivityCreated(savedInstanceState: Bundle?) {        super.onActivityCreated(savedInstanceState)        // 权限申请        PermissionUtils.requestPermission(this)        logger.i("PermissionFragment:requestPermission")    }    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {        if (requestCode == PermissionUtils.requestCode) {            // 需要推迟执行,不然即便受权,仍有部分机型获取不到权限            Handler(Looper.getMainLooper()).postDelayed({                val check = PermissionUtils.checkPermission(activity)                logger.i("PermissionFragment onActivityResult: $check")                // 回调权限结果                onPermissionResult?.permissionResult(check)                // 将Fragment移除                fragmentManager.beginTransaction().remove(this).commitAllowingStateLoss()            }, 500)        }    }}

因为在构建类调用的权限申请,使用在此处需要实现OnPermissionResult接口:

// 悬浮窗权限的申请结果override fun permissionResult(isOpen: Boolean) {    if (isOpen) createAppFloat()    else config.callbacks?.createdResult(false, "系统浮窗权限不足,开启失败", null)}

7,设置出入动画:

说出入动画前,我们先回顾下策略模式:定义一系列的算法,把每一个算法封装起来,并且使它们可相互替换。策略模式使得算法可独立于使用它的用户而独立变化。

  • 定义了一族算法(业务规则);
  • 封装了每个算法;
  • 这族的算法可互换代替(interchangeable)。

上述三点摘抄自维基百科,简单说就是可以通过不同的实现过程,给出想要的实现结果。
如:某接口或者某笼统类,包含排序算法,至于我们怎样排序:使用冒牌排序、快速排序,还是其余的排序都是可以的。

策略模式UML图.jpg

接下来我们一起看轮子中的策略实例,因为Activity浮窗和系统浮窗的创立方式不同,动画实现也有些许不同。但流程相同,这里以Activity浮窗动画作为展现。

  • 首先我们定义一个笼统策略基类,动画接口:
interface OnFloatAnimator {    // 入场动画    fun enterAnim(view: View, parentView: ViewGroup, sidePattern: SidePattern): Animator? = null    // 退出动画    fun exitAnim(view: View, parentView: ViewGroup, sidePattern: SidePattern): Animator? = null}
  • 创立具体策略类,也就是默认动画实现类:
open class DefaultAnimator : OnFloatAnimator {    // 浮窗各边到窗口边框的距离    private var leftDistance = 0    private var rightDistance = 0    private var topDistance = 0    private var bottomDistance = 0    // x轴和y轴距离的最小值    private var minX = 0    private var minY = 0    // 浮窗和窗口所在的矩形    private var floatRect = Rect()    private var parentRect = Rect()    // 实现接口中的入场动画,exitAnim()相似,此处省略了    override fun enterAnim(        view: View,        parentView: ViewGroup,        sidePattern: SidePattern    ): Animator? {        initValue(view, parentView)        val (animType, startValue, endValue) = animTriple(view, sidePattern)        return ObjectAnimator.ofFloat(view, animType, startValue, endValue).setDuration(500)    }    ...  // 退出动画        /**     * 设置动画类型,计算具体数值     */    private fun animTriple(view: View, sidePattern: SidePattern): Triple<String, Float, Float> {        val animType: String        val startValue: Float = when (sidePattern) {            SidePattern.LEFT, SidePattern.RESULT_LEFT -> {                animType = "translationX"                leftValue(view)            }            ...   // 不同的吸附模式,不同的出入方式            else -> {                if (minX <= minY) {                    animType = "translationX"                    if (leftDistance < rightDistance) leftValue(view) else rightValue(view)                } else {                    animType = "translationY"                    if (topDistance < bottomDistance) topValue(view) else bottomValue(view)                }            }        }        val endValue = if (animType == "translationX") view.translationX else view.translationY        return Triple(animType, startValue, endValue)    }    private fun leftValue(view: View) = -(leftDistance + view.width) + view.translationX    private fun rightValue(view: View) = rightDistance + view.width + view.translationX    private fun topValue(view: View) = -(topDistance + view.height) + view.translationY    private fun bottomValue(view: View) = bottomDistance + view.height + view.translationY    /**     * 计算少量数值,方便使用     */    private fun initValue(view: View, parentView: ViewGroup) {        view.getGlobalVisibleRect(floatRect)        parentView.getGlobalVisibleRect(parentRect)        leftDistance = floatRect.left        rightDistance = parentRect.right - floatRect.right        topDistance = floatRect.top - parentRect.top        bottomDistance = parentRect.bottom - floatRect.bottom        minX = min(leftDistance, rightDistance)        minY = min(topDistance, bottomDistance)    }}
  • 创立环境类,也就是动画管理类:
internal class AnimatorManager(    private val onFloatAnimator: OnFloatAnimator?,    private val view: View,    private val parentView: ViewGroup,    private val sidePattern: SidePattern) {    // 通过接口实现具体动画,所以只要要更改接口的具体实现    fun enterAnim(): Animator? = onFloatAnimator?.enterAnim(view, parentView, sidePattern)    fun exitAnim(): Animator? = onFloatAnimator?.exitAnim(view, parentView, sidePattern)}

准备工作都准备妥当了,那我们在哪里调用动画呐?

入场动画:一定是在浮窗创立完成的时候调用,所以我们在拖拽控件的onLayout方法里调用入场动画。不过有个细节要注意,只有在第一次执行onLayout方法时才调用入场动画,由于隐藏再显示,也是会调用onLayout方法的。

退出动画:则在我们调用关闭浮窗时调用。假如退出动画不为空,先执行动画,动画结束的时候销毁浮窗控件;假如退出动画为空,则直接销毁浮窗。

  • 动画的使用,以退出动画为例:
internal fun exitAnim() {    // 正在执行动画,防止重复调用    if (config.isAnim) return    val manager: AnimatorManager? = AnimatorManager(config.floatAnimator, this, parentView, config.sidePattern)    val animator: Animator? = manager?.exitAnim()    if (animator == null) {        config.callbacks?.dismiss()        parentView.removeView(this@AbstractDragFloatingView)    } else {        animator.addListener(object : Animator.AnimatorListener {            override fun onAnimationEnd(animation: Animator?) {                config.isAnim = false                config.callbacks?.dismiss()                parentView.removeView(this@AbstractDragFloatingView)            }            override fun onAnimationStart(animation: Animator?) {                config.isAnim = true            }            ...        })        animator.start()    }}

看得出来,我们内部做了动画的监听和执行,config.floatAnimator就是我们外部传入的动画实现类。

动画类型也没有做过多限制,使用的是动画的超类Animator,所以视图动画和属性动画都是可以的;不需要动画直接在实现类里返回null就可。

8,页面过滤和仅前端显示:

前面我们说属性管理的时候,在FloatConfig数据类里,有下面这个属性:

// 不需要显示系统浮窗的页面集合,参数为类名val filterSet: MutableSet<String> = mutableSetOf()

这个页面过滤集合,可以在创立浮窗的时候就设置,也可以在需要的时候进行设置。集合数据好管理,主要是过滤功能是如何实现的。

在Application类中,ActivityLifecycleCallbacks可以实现各个Activity的生命周期监控,我们只需在特定的Activity显示时控制浮窗隐藏,在Activity不显示时再重新让浮窗显示。

同理,假如让浮窗实现仅前端显示,也可以使用此方式,当所有的Activity都不显示的时候,浮窗隐藏,反正浮窗重新显示。

internal object LifecycleUtils {    private var activityCount = 0    private lateinit var application: Application    fun setLifecycleCallbacks(application: Application) {        this.application = application        application.registerActivityLifecycleCallbacks(object : Application.ActivityLifecycleCallbacks {            override fun onActivityStarted(activity: Activity?) {                if (activity == null) return                activityCount++                FloatService.floatMap.forEach { (tag, manager) ->                    run {                        // 过滤不需要显示浮窗的页面                        manager.config.filterSet.forEach filterSet@{                            if (it == activity.componentName.className) {                                setVisible(false, tag)                                manager.config.needShow = false                                logger.i("过滤浮窗显示: $it, tag: $tag")                                return@filterSet                            }                        }                        // 当过滤信息没有匹配上时,需要发送广播,反正修改needShow为默认值                        if (manager.config.needShow) setVisible(tag = tag)                        else manager.config.needShow = true                    }                }            }            override fun onActivityStopped(activity: Activity?) {                if (activity == null) return                activityCount--                if (isForeground()) return                // 当app处于后端时,检测能否有仅前端显示的系统浮窗                FloatService.floatMap.forEach { (tag, manager) ->                    run { if (manager.config.showPattern == ShowPattern.FOREGROUND) setVisible(tag = tag) }                }            }            ... // 其余的生命周期回调        })    }    private fun isForeground() = activityCount > 0    private fun setVisible(boolean: Boolean = isForeground(), tag: String?) =        FloatService.setVisible(application, boolean, tag)}

不过使用该生命周期监控,需要我们传入Application,即在项目的Application中需要进行浮窗的初始化;假如没使用到过滤和仅前端显示,则不需要。

实施阶段也就说这么多吧,其余少量点和少量注意细节,都在代码中,感兴趣的可以去看下。

使用:上手体验

说了这么多,究竟好不好用呐?我们写个最简单的浮窗:

EasyFloat.with(this).setLayout(R.layout.float_test).show()

对,没有看错,一行代码即可以创立一个拖拽浮窗,默认只在当页显示。

作为结束,我们从上图中挑一个来实现。因为浮窗只支持拖拽,不支持缩放,那我们就选那个支持缩放的系统浮窗吧:

上图中一共包含了这几个属性:设置仅前端显示、过滤SecondActivity、固定坐标、取消出入动画、点击关闭、拖拽缩放。

private fun showAppFloat(tag: String) {    EasyFloat.with(this)        .setLayout(R.layout.float_app_scale)        .setTag(tag)        .setShowPattern(ShowPattern.FOREGROUND)        .setLocation(100, 100)        .setAppFloatAnimator(null)        .setFilter(SecondActivity::class.java)        .invokeView(OnInvokeView {            val content = it.findViewById<RelativeLayout>(R.id.rlContent)            val params = content.layoutParams as FrameLayout.LayoutParams            it.findViewById<ScaleImage>(R.id.ivScale).onScaledListener =  object : ScaleImage.OnScaledListener {                    override fun onScaled(x: Float, y: Float, event: MotionEvent) {                        params.width += x.toInt()                        params.height += y.toInt()                        content.layoutParams = params                    }                }            it.findViewById<ImageView>(R.id.ivClose).setOnClickListener {                EasyFloat.dismissAppFloat(this@MainActivity, tag)            }        })        .show()}

需要指出的是,这里的拖拽缩放不包含在轮子中,在示例代码里。我们一块看下是怎样实现的,如有需要参考示例:

class ScaleImage(context: Context, attrs: AttributeSet? = null) : ImageView(context, attrs) {    private var touchDownX = 0f    private var touchDownY = 0f    var onScaledListener: OnScaledListener? = null    interface OnScaledListener {        fun onScaled(x: Float, y: Float, event: MotionEvent)    }    @SuppressLint("ClickableViewAccessibility")    override fun onTouchEvent(event: MotionEvent?): Boolean {        if (event == null) return super.onTouchEvent(event)        // 屏蔽掉浮窗的事件阻拦,仅由自身消费        parent?.requestDisallowInterceptTouchEvent(true)        when (event.action) {            MotionEvent.ACTION_DOWN -> {                touchDownX = event.x                touchDownY = event.y            }            MotionEvent.ACTION_MOVE ->                onScaledListener?.onScaled(event.x - touchDownX, event.y - touchDownY, event)        }        return true    }}

逻辑很简单,只是记录手指相对于按下时的滑动距离,外部根据这个距离差值,从新设置控件大小。关键一点要屏蔽掉浮窗的事件阻拦,不然接收不到触摸事件。


文章到这里就已经一律结束了,非常感谢大家的阅读。
轮子已上传到GitHub,希望对大家有所帮助,假如能收获个star,那也最开心不过了。

项目地址: princekin-f/EasyFloat

特别感谢:Android 悬浮窗权限各机型各系统适配大全

说明
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » EasyFloat:浮窗从未如此简单

发表回复