AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

下沉式通知的一种实现 | Android悬浮窗Window应用

2022-10-08 371
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云解析 DNS，旗舰版 1个月
全局流量管理 GTM，标准版 1个月
公共DNS（含HTTPDNS解析），每月1000万次HTTP解析
简介： 当你浏览公众号时来了一条新消息，通知在屏幕顶部会以自顶向下动画的形式入场，而且它是跨界面的全局浮窗（效果如下图）。虽然上一篇中抽象的浮窗工具类已经能实现这个需求。但本文在此基础上再封装一些更加友好的

当你浏览公众号时来了一条新消息，通知在屏幕顶部会以自顶向下动画的形式入场，而且它是跨界面的全局浮窗（效果如下图）。虽然上一篇中抽象的浮窗工具类已经能实现这个需求。但本文在此基础上再封装一些更加友好的 API 来实现下沉式通知。

跨界面浮窗

这是 Android Window 应用的第二篇，系列文章目录如下：

  1. 悬浮窗的一种实现 | Android悬浮窗Window应用
  2. 下沉式通知的一种实现 | Android悬浮窗Window应用

预定义常用位置

上一篇抽象的show()接口通过指定x、y能精确地在屏幕任意位置显示浮窗。但有时候业务需求是模糊的，比如“在屏幕右侧中间显示浮窗”。如果能新增一个 API，再预定义一些常用位置，这样业务层就可以不用关心窗口坐标的计算。

屏幕的上下左右 4 个方向是常用位置，每个位置又可以有三种gravity：起点、中点、终点。组合一下就有 12 个常用位置。

当然可以定义 12 个常量，它们的值从 0-11 。但当每个位置新增一种 gravity，则要新增 4 个常量。将上下左右的方位和 gravity 分成两组可以解决这个问题：

object FloatWindow : View.OnTouchListener {
    //'方位常量组'
    const val POSIITION_TOP = 1
    const val POSITION_LEFT = 2
    const val POSITION_RIGHT = 3
    const val POSITION_BOTTOM = 4
    
    //'gravity常量组'
    const val GRAVITY_START = 100
    const val GRAVITY_MID = 101
    const val GRAVITY_END = 102
}

重载一个带有常用位置参数的show()函数：

object FloatWindow : View.OnTouchListener {
    fun show(
        context: Context,
        tag: String,
        windowInfo: WindowInfo? = windowInfoMap[tag],
        //'新增参数：位置'
        position: Int,
        //'新增参数：gravity'
        gravity: Int
    ) {
        //'根据常用位置计算窗口左上角坐标，省略了计算过程'
        when (position){
            POSITION_TOP -> {
                when (gravity) -> {
                    GRAVITY_START -> {...}
                    GRAVITY_MID -> {...}
                    GRAVITY_END -> {...}
                    else -> {...}
                }
            }
            POSITION_LEFT -> {
                when (gravity) -> {
                    GRAVITY_START -> {...}
                    GRAVITY_MID -> {...}
                    GRAVITY_END -> {...}
                    else -> {...}
                }
            }
            POSITION_RIGHT -> {
                when (gravity) -> {
                    GRAVITY_START -> {...}
                    GRAVITY_MID -> {...}
                    GRAVITY_END -> {...}
                    else -> {...}
                }
            }
            POSITION_BOTTOM -> {
                when (gravity) -> {
                    GRAVITY_START -> {...}
                    GRAVITY_MID -> {...}
                    GRAVITY_END -> {...}
                    else -> {...}
                }
            }
            else -> {...}
        }
        //'将计算出的坐标传入上一篇抽象的show函数'
        show( context, tag, windowInfo, x, y, false)
    }
}

没毛病，但show()函数新增了两个参数，而且这两个参数得合起来才表达一个完整的语义：窗口的位置。

二进制位管理多个状态

有没有什么办法将两个参数合并成一个参数？有！更好的解决方案就藏在View的源码里：

public class View {
    /*
     * '状态常量'
     * |-------|-------|-------|-------|
     *                                 1 PFLAG_WANTS_FOCUS
     *                                1  PFLAG_FOCUSED
     *                               1   PFLAG_SELECTED
     *                              1    PFLAG_IS_ROOT_NAMESPACE
     *                             1     PFLAG_HAS_BOUNDS
     *                            1      PFLAG_DRAWN
     *                           1       PFLAG_DRAW_ANIMATION
     *                          1        PFLAG_SKIP_DRAW
     *                        1          PFLAG_REQUEST_TRANSPARENT_REGIONS
     *                       1           PFLAG_DRAWABLE_STATE_DIRTY
     *                      1            PFLAG_MEASURED_DIMENSION_SET
     *                     1             PFLAG_FORCE_LAYOUT
     *                    1              PFLAG_LAYOUT_REQUIRED
     *                   1               PFLAG_PRESSED
     *                  1                PFLAG_DRAWING_CACHE_VALID
     *                 1                 PFLAG_ANIMATION_STARTED
     *                1                  PFLAG_SAVE_STATE_CALLED
     *               1                   PFLAG_ALPHA_SET
     *              1                    PFLAG_SCROLL_CONTAINER
     *             1                     PFLAG_SCROLL_CONTAINER_ADDED
     *            1                      PFLAG_DIRTY
     *            1                      PFLAG_DIRTY_MASK
     *          1                        PFLAG_OPAQUE_BACKGROUND
     *         1                         PFLAG_OPAQUE_SCROLLBARS
     *         11                        PFLAG_OPAQUE_MASK
     *        1                          PFLAG_PREPRESSED
     *       1                           PFLAG_CANCEL_NEXT_UP_EVENT
     *      1                            PFLAG_AWAKEN_SCROLL_BARS_ON_ATTACH
     *     1                             PFLAG_HOVERED
     *    1                              PFLAG_NOTIFY_AUTOFILL_MANAGER_ON_CLICK
     *   1                               PFLAG_ACTIVATED
     *  1                                PFLAG_INVALIDATED
     * |-------|-------|-------|-------|
     */
    /** {@hide} */
    static final int PFLAG_WANTS_FOCUS                 = 0x00000001;
    /** {@hide} */
    static final int PFLAG_FOCUSED                     = 0x00000002;
    /** {@hide} */
    static final int PFLAG_SELECTED                    = 0x00000004;
    /** {@hide} */
    static final int PFLAG_IS_ROOT_NAMESPACE           = 0x00000008;
    //'当前状态'
    public int mPrivateFlags;
}

View将自身的所有状态位存储在一个int类型的mPrivateFlags变量中。int占用 4 个字节，1 个字节包含 8 位二进制，所以它可以存储 32 个二元状态。

状态常量也是一个int值，每个状态常量只和 32 位中的 1 位关联，View将其表示成 8 位的十六进制。（1 个 十六进制位 等价于 4 个二进制位，比如：）

| 十六进制 | 二进制 |
| ------ | ------ |
| 1| 0001 |
| 2 | 0010 |
| 3 | 0011 |

我原先习惯将一个状态位定义成一个int值，现在看来，可以将 32 个int状态值浓缩在一个int值中。

新增状态时，只需进行位或操作：

mPrivateFlags |= PFLAG_DRAWN;

判断当前是否具有某种状态时，只需位与操作：

public boolean hasFocus() {
    return (mPrivateFlags & PFLAG_FOCUSED) != 0;
}

删除状态时，只需取反加位与操作：

mPrivateFlags &= ~PFLAG_OPAQUE_BACKGROUND;

使用二进制位来管理数量众多的状态时不仅节约了内存，而且状态的变更和判断变得轻松，复合状态的表达变得简单

虽然当前业务场景中只包含一种状态，即浮窗的常用位置，但它是一种复合状态，包含了位置和 gravity，使用二进制位管理，可以简化代码：

object FloatWindow : View.OnTouchListener {
    //'使用0-3位表示gravity'
    const val FLAG_START = 0x00000001
    const val FLAG_MID = 0x00000002
    const val FLAG_END = 0x00000004
    //'使用第4-7位表示位置'
    const val FLAG_TOP = 0x00000010
    const val FLAG_LEFT = 0x00000020
    const val FLAG_RIGHT = 0x00000040
    const val FLAG_BOTTOM = 0x00000080
}

这样show()的参数表就可以被简化：

object FloatWindow : View.OnTouchListener {
    fun show(
        context: Context,
        tag: String,
        //包含窗口宽高和坐标的包装类
        windowInfo: WindowInfo? = windowInfoMap[tag],
        //'flag包含了位置和gravity信息'
        flag: Int
    ) {
        //'将 flag 解析成坐标并显示浮窗'
        getShowPoint(
            flag, 
            windowInfo, 
            offset
        ).let { show(context, tag, windowInfo, it.x, it.y, false) }
    }
}

flag 的解析写在getShowPoint()中：

object FloatWindow : View.OnTouchListener {
    private fun getShowPoint(flag: Int, windowInfo: WindowInfo?): Point {
        return when {
            //'构建顶部浮窗坐标'
            flag.and(FLAG_TOP) != 0 -> {
                val y = -windowInfo?.height.value()
                //'解析flag中的gravity部分'
                val x = getValueByGravity(flag, screenWidth, windowInfo?.width.value())
                Point(x, y)
            }
            //'构建底部浮窗坐标'
            flag.and(FLAG_BOTTOM) != 0 -> {
                val y = screenHeight
                val x = getValueByGravity(flag, screenWidth, windowInfo?.width.value())
                Point(x, y)
            }
            //'构建左边浮窗坐标'
            flag.and(FLAG_LEFT) != 0 -> {
                val x = -windowInfo?.width.value()
                val y = getValueByGravity(flag, screenHeight, windowInfo?.height.value())
                Point(x, y)
            }
            //'构建右边浮窗坐标'
            flag.and(FLAG_RIGHT) != 0 -> {
                val x = screenWidth
                val y = getValueByGravity(flag, screenHeight, windowInfo?.height.value())
                Point(x, y)
            }
            else -> Point(0, 0)
        }
    }
}

解析 flag 分两步，先解析位置再解析 gravity。

解析位置时，为了使浮窗有移入屏幕的效果，遂将其初始位置都置于屏幕外且紧贴屏幕边缘。比如顶部浮窗的下边缘贴住屏幕上边缘，所以浮窗左上角 y = -浮窗高度

解析 gravity 逻辑写在getValueByGravity()中：

private fun getValueByGravity(flag: Int, total: Int, actual: Int): Int = when {
    flag.and(FLAG_START) != 0 -> 0
    flag.and(FLAG_MID) != 0 -> (total - actual) / 2
    flag.and(FLAG_END) != 0 -> (total - actual)
    else -> 0
}

其中total表示边屏幕宽(高)，actual表示对应的浮窗宽(高)

移入动画

将浮窗初始位置置于屏幕之外且紧贴屏幕后，只需要再设置一个位移动画即可实现移入屏幕的效果：

object FloatWindow : View.OnTouchListener {
    fun show(
        context: Context,
        tag: String,
        windowInfo: WindowInfo? = windowInfoMap[tag],
        flag: Int,
        //'窗口位移动画回调'
        onAnimateWindow: ((WindowInfo?) -> Unit)?
    ) {
        getShowPoint(flag, windowInfo).let { show(context, tag, windowInfo, it.x, it.y, false) }
        //'在当前消息队列末尾执行窗口位移动画'
        windowInfo?.view?.post { onAnimateWindow?.invoke(windowInfo) }
    }
}

这个重载show()函数将动画的实现交给业务层，动画执行的时间点被安排在消息队列末尾，之所以这样做是因为要确保动画在窗口显示之后执行。

现在业务界面就可以像这样显示顶部下沉窗口：

var handler = Handler(Looper.getMainLooper())
val view = LayoutInflater.from(this).inflate(R.layout.gravity_vertical_window, null)
//'构建窗口宽高参数'
val windowInfo = FloatWindow.WindowInfo(view).apply {
    width = DimensionUtil.dp2px(300.0)
    height = DimensionUtil.dp2px(80.0)
}

//'在屏幕顶部的正中位置显示下沉式窗口'
FloatWindow.show(this, "top", windowInfo, FLAG_TOP or FLAG_MID) { info ->
    val anim = animSet {
        anim {
            values = intArrayOf(info.layoutParams?.y ?: 0, 0)
            interpolator = LinearOutSlowInInterpolator()
            duration = 250L
            action = { value -> FloatWindow.updateWindowView(y = value as Int) }
        }
        start()
    }
    //'1500毫秒后反向播放动画，即隐藏下沉式窗口'
    handler.postDelayed({ anim.reverse() }, 1500)
}

animSet和anim是自定义 DSL，用于简化构建动画代码，其运用的 Kotlin 语法糖分析。

进一步重载提供默认动画

把构建浮窗入场动画的细节交由业务界面实现，这样虽然增加了灵活度，但也增加了业务代码的复杂度。如果能提供默认动画就更好了，重载show()：

object FloatWindow : View.OnTouchListener {
    //'提供默认动画的浮窗显示重载函数'
    fun show(
        context: Context,
        tag: String,
        windowInfo: WindowInfo? = windowInfoMap[tag],
        flag: Int,
        offset: Int = 0,
        //'浮窗显示和隐藏动画时长'
        duration: Long = 250L,
        //'浮窗停留时长'
        stayTime: Long = 1500L
    ) {
        getShowPoint(flag, windowInfo, offset).let { show(context, tag, windowInfo, it.x, it.y, false) }
        windowInfo?.view?.post {
            //'构建浮窗出场动画'
            getShowAnim(flag, windowInfo, duration)?.also { anim ->
                anim.start()
                //'延迟隐藏浮窗'
                handler.postDelayed({
                    anim.reverse()
                    //'隐藏浮窗动画结束后，解散浮窗'
                    anim.onEnd = { dismiss(windowInfo) }
                }, stayTime)
            }
        }
    }
}

getShowAnim()通过解析 flag 构建对应出场动画：

object FloatWindow : View.OnTouchListener {
    private fun getShowAnim(
        flag: Int, 
        windowInfo: WindowInfo?, 
        duration: Long
    ): AnimSet? = when {
        //'构建自顶向下动画'
        flag.and(FLAG_TOP) != 0 -> {
            animSet {
                anim {
                    values = intArrayOf(windowInfo?.layoutParams?.y.value(), 0)
                    this.duration = duration
                    interpolator = LinearOutSlowInInterpolator()
                    action = { value -> updateWindowView(y = value as Int) }
                }
            }
        }
        //'构建自底向上动画'
        flag.and(FLAG_BOTTOM) != 0 -> {
            animSet {
                anim {
                    values = intArrayOf(windowInfo?.layoutParams?.y.value(), windowInfo?.layoutParams?.y.value() - windowInfo?.height.value())
                    this.duration = duration
                    interpolator = LinearOutSlowInInterpolator()
                    action = { value -> updateWindowView(y = value as Int) }
                }
            }
        }
        //'构建从左往右动画'
        flag.and(FLAG_LEFT) != 0 -> {
            animSet {
                anim {
                    values = intArrayOf(windowInfo?.layoutParams?.x.value(), 0)
                    this.duration = duration
                    interpolator = LinearOutSlowInInterpolator()
                    action = { value -> updateWindowView(x = value as Int) }
                }
            }
        }
        //'构建从右往左动画'
        flag.and(FLAG_RIGHT) != 0 -> {
            animSet {
                anim {
                    values = intArrayOf(windowInfo?.layoutParams?.x.value(), windowInfo?.layoutParams?.x.value() - windowInfo?.layoutParams?.width.value())
                    this.duration = duration
                    interpolator = LinearOutSlowInInterpolator()
                    action = { value -> updateWindowView(x = value as Int) }
                }
            }
        }
        else -> null
    }
}

虽然有 12 个常用位置，但浮窗出场动画只有 4 个方位，即自顶向下、自底向上、从左往右、从右往左。

上滑隐藏浮窗

若想实现 “手指上滑隐藏不感兴趣的通知”，只需在监听到 fling 手势时反向播放动画：

object FloatWindow : View.OnTouchListener {
    private var gestureDetector: GestureDetector = GestureDetector(context, GestureListener())
    //'浮窗出入场动画'
    private var inAndOutAnim: Anim? = null
    
    override fun onTouch(v: View, event: MotionEvent): Boolean {
        //'将触摸事件传递给GestureDetector解析'
        gestureDetector.onTouchEvent(event)
        return true
    }
    
    private class GestureListener : GestureDetector.OnGestureListener {
        ...
        //'GestureDetector解析触摸事件成fling事件'
        override fun onFling(
            e1: MotionEvent,
            e2: MotionEvent,
            velocityX: Float,
            velocityY: Float
        ): Boolean {
            //'反转入场动画'
            inAndOutAnim?.let { anim ->
                anim.reverse()
                anim.onEnd = { dismiss(windowInfo) }
                return true
            }
            return false
        }
    }
}

inAndOutAnim应该在两个重载show()函数中被赋值，遂修改show()函数如下：

object FloatWindow : View.OnTouchListener {
    fun show(
        context: Context,
        tag: String,
        windowInfo: WindowInfo? = windowInfoMap[tag],
        flag: Int,
        offset: Int = 0,
        duration: Long = 250L,
        stayTime: Long = 1500L
    ) {
        getShowPoint(flag, windowInfo, offset).let { show(context, tag, windowInfo, it.x, it.y, false) }
        windowInfo?.view?.post {
            //'构建默认出入场动画时给inAndOutAnim赋值'
            inAndOutAnim = getShowAnim(flag, windowInfo, duration)?.also { anim ->
                anim.start()
                handler.postDelayed({
                    anim.reverse()
                    anim.onEnd = { dismiss(windowInfo) }
                }, stayTime)
            }
        }
    }
    
    fun show(
        context: Context,
        tag: String,
        windowInfo: WindowInfo? = windowInfoMap[tag],
        flag: Int,
        offset: Int = 0,
        //'修改lambda返回值为Anim'
        onAnimateWindow: ((WindowInfo) -> Anim)?
    ) {
        getShowPoint(flag, windowInfo, offset).let { show(context, tag, windowInfo, it.x, it.y, false) }
        //'业务界面构建的出入场动画作为lambda的返回值并赋给inAndOutAnim'
        windowInfo?.view?.post { inAndOutAnim = onAnimateWindow?.invoke(windowInfo) }
    }
}

//'业务界面这样显示下沉式通知'
val view = LayoutInflater.from(this).inflate(R.layout.gravity_vertical_window, null)
    val windowInfo = FloatWindow.WindowInfo(view).apply {
        width = DimensionUtil.dp2px(300.0)
        height = DimensionUtil.dp2px(80.0)
    }

    FloatWindow.show(this, "top", windowInfo, FLAG_TOP or FLAG_MID) { info ->
        val anim = animSet {
            anim {
                values = intArrayOf(info.layoutParams?.y ?: 0, 0)
                interpolator = LinearOutSlowInInterpolator()
                duration = 250L
                action = { value -> FloatWindow.updateWindowView(y = value as Int) }
            }
            start()
        }
        handler.postDelayed({ anim.reverse() }, 1500)
        //'将构建的动画实例作为lambda值'
        anim
    }

全局浮窗

通知类型浮窗和其他浮窗不同，它是全局的，当切换 Activity 时要求浮窗持续展示。只需要静态申请一个权限并修改窗口类型即可实现：

<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />

在AndroidManifest.xml中添加这个权限，然后修改show()函数，增加全局参数：

object FloatWindow : View.OnTouchListener {
    fun show(
        context: Context,
        tag: String,
        windowInfo: WindowInfo? = windowInfoMap[tag],
        x: Int = windowInfo?.layoutParams?.x.value(),
        y: Int = windowInfo?.layoutParams?.y.value(),
        dragEnable: Boolean = false,
        //'是否是全局浮窗'
        overall: Boolean = false
    ) {
        ...
        //'构建全局浮窗布局参数'
        windowInfo.layoutParams = createLayoutParam(x, y, overall)
        if (!windowInfo.hasParent().value()) {
            val windowManager = this.context?.getSystemService(Context.WINDOW_SERVICE) as? WindowManager
            prepareScreenDimension(windowManager)
            windowManager?.addView(windowInfo.view, windowInfo.layoutParams)
            updateWindowViewSize()
            onWindowShow?.invoke()
        }
    }
    
    private fun createLayoutParam(x: Int, y: Int, overall: Boolean): WindowManager.LayoutParams {
        if (context == null) {
            return WindowManager.LayoutParams()
        }

        return WindowManager.LayoutParams().apply {
            //'为全局浮窗指定不一样的窗口类型'
            type = if (overall) {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                    WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY
                } else {
                    WindowManager.LayoutParams.TYPE_SYSTEM_ALERT
                }
            } else {
                WindowManager.LayoutParams.TYPE_APPLICATION
            }
            format = PixelFormat.TRANSLUCENT
            flags =
                WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS or WindowManager.LayoutParams.FLAG_DIM_BEHIND
            dimAmount = 0f
            this.gravity = Gravity.START or Gravity.TOP
            width = windowInfo?.width.value()
            height = windowInfo?.height.value()
            this.x = x
            this.y = y
        }
    }
}

当 Window 类型设置为TYPE_APPLICATION_OVERLAY或TYPE_SYSTEM_ALERT时，窗口就不隶属于某一个 Activity。这样就做到了全局展示。

talk is cheap, show me the code

完整代码可点击上面链接。

文章标签：
云解析DNS
Android开发
消息中间件
API
存储
Kotlin
关键词：
Android应用
Android Window
Android悬浮窗
Android实现
Android通知
唐子玄
目录
相关文章
ShaFaChuang-36210
|
2月前
|
IDE Java 开发工具
深入探索安卓应用开发：从环境搭建到第一个"Hello, World!"应用
本文将引导读者完成安卓应用开发的初步入门，包括安装必要的开发工具、配置开发环境、创建第一个简单的安卓项目，以及解释其背后的一些基本概念。通过一步步的指导和解释，本文旨在为安卓开发新手提供一个清晰、易懂的起点，帮助读者顺利地迈出安卓开发的第一步。
ShaFaChuang-36210
224 65
肥猪肥猪-17824
|
2月前
|
存储 Java Android开发
探索安卓应用开发：构建你的第一个"Hello World"应用
【9月更文挑战第24天】在本文中，我们将踏上一段激动人心的旅程，深入安卓应用开发的奥秘。通过一个简单而经典的“Hello World”项目，我们将解锁安卓应用开发的基础概念和步骤。无论你是编程新手还是希望扩展技能的老手，这篇文章都将为你提供一次实操体验。从搭建开发环境到运行你的应用，每一步都清晰易懂，确保你能顺利地迈出安卓开发的第一步。让我们开始吧，探索如何将一行简单的代码转变为一个功能齐全的安卓应用！
肥猪肥猪-17824
44 2
我不是游客20240119
|
20天前
|
JSON Java Android开发
探索安卓开发之旅：打造你的第一个天气应用
【10月更文挑战第30天】在这个数字时代，掌握移动应用开发技能无疑是进入IT行业的敲门砖。本文将引导你开启安卓开发的奇妙之旅，通过构建一个简易的天气应用来实践你的编程技能。无论你是初学者还是有一定经验的开发者，这篇文章都将成为你宝贵的学习资源。我们将一步步地深入到安卓开发的世界中，从搭建开发环境到实现核心功能，每个环节都充满了发现和创造的乐趣。让我们开始吧，一起在代码的海洋中航行！
我不是游客20240119
29 2
请看我回答~
|
21天前
|
存储 搜索推荐 Java
打造个性化安卓应用：从设计到实现
【10月更文挑战第30天】在数字化时代，拥有一个个性化的安卓应用不仅能够提升用户体验，还能加强品牌识别度。本文将引导您了解如何从零开始设计和实现一个安卓应用，涵盖用户界面设计、功能开发和性能优化等关键环节。我们将以一个简单的记事本应用为例，展示如何通过Android Studio工具和Java语言实现基本功能，同时确保应用流畅运行。无论您是初学者还是希望提升现有技能的开发者，这篇文章都将为您提供宝贵的见解和实用的技巧。
请看我回答~
34 1
肥猪肥猪-17824
|
24天前
|
搜索推荐 开发工具 Android开发
打造个性化Android应用：从设计到实现的旅程
【10月更文挑战第26天】在这个数字时代，拥有一个能够脱颖而出的移动应用是成功的关键。本文将引导您了解如何从概念化阶段出发，通过设计、开发直至发布，一步步构建一个既美观又实用的Android应用。我们将探讨用户体验(UX)设计的重要性，介绍Android开发的核心组件，并通过实际案例展示如何克服开发中的挑战。无论您是初学者还是有经验的开发者，这篇文章都将为您提供宝贵的见解和实用的技巧，帮助您在竞争激烈的应用市场中脱颖而出。
肥猪肥猪-17824
37 4
CamilleKing
|
26天前
|
算法 Java 数据库
Android 应用的主线程在什么情况下会被阻塞？
【10月更文挑战第20天】为了避免主线程阻塞，我们需要合理地设计和优化应用的代码。将耗时操作移到后台线程执行，使用异步任务、线程池等技术来提高应用的并发处理能力。同时，要注意避免出现死循环、不合理的锁使用等问题。通过这些措施，可以确保主线程能够高效地运行，提供流畅的用户体验。
CamilleKing
38 2
mrq4nk6ni2neg
|
30天前
|
Java API Android开发
安卓应用程序开发的新手指南：从零开始构建你的第一个应用
【10月更文挑战第20天】在这个数字技术不断进步的时代，掌握移动应用开发技能无疑打开了一扇通往创新世界的大门。对于初学者来说，了解并学习如何从无到有构建一个安卓应用是至关重要的第一步。本文将为你提供一份详尽的入门指南，帮助你理解安卓开发的基础知识，并通过实际示例引导你完成第一个简单的应用项目。无论你是编程新手还是希望扩展你的技能集，这份指南都将是你宝贵的资源。
mrq4nk6ni2neg
48 5
游客moiomvrp3vyac2
|
30天前
|
移动开发 Dart 搜索推荐
打造个性化安卓应用：从零开始的Flutter之旅
【10月更文挑战第20天】本文将引导你开启Flutter开发之旅，通过简单易懂的语言和步骤，让你了解如何从零开始构建一个安卓应用。我们将一起探索Flutter的魅力，实现快速开发，并见证代码示例如何生动地转化为用户界面。无论你是编程新手还是希望扩展技能的开发者，这篇文章都将为你提供价值。
游客moiomvrp3vyac2
48 5
东方睿赢
|
1月前
|
调度 Android开发 开发者
构建高效Android应用：探究Kotlin多线程优化策略
【10月更文挑战第11天】本文探讨了如何在Kotlin中实现高效的多线程方案，特别是在Android应用开发中。通过介绍Kotlin协程的基础知识、异步数据加载的实际案例，以及合理使用不同调度器的方法，帮助开发者提升应用性能和用户体验。
东方睿赢
49 4
东方睿赢
|
1月前
|
编解码 Android开发 UED
构建高效Android应用：从内存优化到用户体验
【10月更文挑战第11天】本文探讨了如何通过内存优化和用户体验改进来构建高效的Android应用。介绍了使用弱引用来减少内存占用、懒加载资源以降低启动时内存消耗、利用Kotlin协程进行异步处理以保持UI流畅，以及采用响应式设计适配不同屏幕尺寸等具体技术手段。
东方睿赢
51 2

热门文章

最新文章

  • 1
    Android逆向笔记 —— AndroidManifest.xml 文件格式解析
  • 2
    Android音视频——NuPlayer框架
  • 3
    android-async-http框架的学习和使用
  • 4
    大叔也说Xamarin~Android篇~Activity之间传递数组
  • 5
    Android UI学习 - Linear Layout, RelativeLayout
  • 6
    [Java][Android][Process] 暴力的服务能够解决一切，暴力的方式运行命令行语句
  • 7
    android按钮main.xm_基础篇
  • 8
    Android响应式编程RxAndroid（1）：简单例程
  • 9
    Android快捷便利但不常被使用的原生工具类
  • 10
    android --静默安装
  • 1
    Android使用ViewPager实现图片轮播系列之三：手动滑动 + 左右箭头(1)
    66
  • 2
    构建高效Android应用：探究Kotlin协程的优势与实践
    50
  • 3
    构建高效Android应用：Kotlin与协程的完美结合
    39
  • 4
    Android自定义View：MeasureSpec的真正意义与View大小控制
    49
  • 5
    Android中的多线程及AsyncTask的引入，最终入职阿里
    60
  • 6
    Android 11 中的存储机制更新，面试心得体会
    91
  • 7
    真的强！借助阿里技术博主分享的Android面试笔记，我拿到了字节跳动的offer
    64
  • 8
    对标腾讯T9架构师的 Android 面试题新鲜出炉，算法真的太重要了
    53
  • 9
    webRTC（十五），2024最新Android中级面试题目汇总解答
    103
  • 10
    Android 开发网易面试凉凉经，面试官：基础不牢，彻底帮你搞懂
    55

    • 相关课程

    更多
  • 开源Android容器化框架Atlas开发者指南

    • 相关电子书

    更多
  • 58同城Android客户端Walle框架演进与实践之路
  • Android组件化实现
  • 蚂蚁聚宝Android秒级编译——Freeline
    • 下一篇
    无影云桌面