1

回想宫崎骏上一部上映的电影，已经是2013年，距今已有十一年之久，那时在唐山的网吧里，在微博偶然刷到了《起风了》的预告片，一开始就被主题曲《ひこうき雲》轻快动听的旋律吸引住了，加上当时的说法是，这部《起风了》应该是收官之作了，所以当时情绪很复杂，既有期待又有不舍，不像《你想活出怎样的人生》，只是隐约看到一两则新闻，其他没有过多关注，虽然也有说是告别之作，但是竟没觉得有何特别之处，心态还是很坦然的，不过想到宫崎骏老爷子都八十四高龄了，这次应该真的是最后一部了。

2

你想活出怎样的人生？

通过电影名字，就可以知道这部电影的主旨，剩下的就是我们怎么能在这场奇幻旅途之中，寻找到想要的答案。

3

整部影片的剧情用一句话概括就是，二战之后，一个丧母的少年和一只会说话的苍鹭去寻找继母的奇幻旅程。

我本来想着，要把电影剧情一五一十地表述完整，但是，我感觉这个东西很容易变成流水账，完全是为了充字数，并不会有什么价值可言，是个人只要想写，都可以写出来，所以就此作罢。

我觉得观后感，是很自我的东西，不用非常刻意去挖掘多高深的内容，也不需要每看一部电影，好像带着写观后感的任务一样，那就违背了初衷，我不是为了写观后感才去看电影的，我是喜欢电影，喜欢这部电影才有感而发，是很纯粹的一些感受。

4

在电影院观看时，我一开始并不觉得音乐有多出色，至少相比之前那些作品而言，没有觉得很惊艳。但是现在在敲这些文字时，QQ音乐正好放着配乐《Ask me why》，居然觉得很好听，仿佛有一股暖流，慢慢流淌遍及我的全身，而《青サギ》则是清冽的感觉，像在深山的竹林，偶然听见风铃一样冰凉的声音。

5

宫崎骏的电影，没有绝对的善与恶，不同的立场，不同的选择，大家都只不过是为了自己坚持的正义而战罢了。

我很感恩，在我很小的时候，遇到了《千与千寻》和《哈尔的移动城堡》这两部电影，不管岁月如何变迁，不管社会如何险恶，不管人心如何复杂多变，我始终相信，会有那么一样东西，是如此纯粹，如此干净而美好的。

哪怕做不到具体的某个事物，只是某个瞬间，让我们回归到最初的自己，就好像从未改变过一样。

想到《火影忍者》里大蛇丸，找到君麻吕的时候，说的那一段话，抛开PUA洗脑这些因素不谈，整段话还是很有哲理的，带着对美好事物的向往。

“并没有所谓的活着一定就有意义这种事情，但是活下去，说不定能找到有趣的事情，就像你找到了那朵花一样，就像我找到了你一样。”

我又想起来2015年加入的QQ群，叫作06年神雕侠侣，里面就有位大兄弟说的一段话，我很喜欢，所以截图一直保存至今，我想这就是宫崎骏的电影，之所以如此迷人的原因。

“无论这个人走过怎么样的一条路，经历过什么样的沧桑浮华，对美好事物的爱永远都不会消失。”

6

这部电影中，让我印象比较深刻的是苍鹭，太好玩了，他的造型让我眼前一亮，本体是一个留着大鼻子的老头，披着苍鹭的外形，出场的画面都很滑稽，补鸟喙窟窿那段笑死我了哈哈哈，还有就是戴眼罩的样子，太可爱了。然后苍鹭露出原型振翅滑稽的飞行样子，让我想到了《千与千寻》里的苍蝇带着坊宝宝变的小白鼠起飞的样子。除此之外，从影片中还是能看出，有之前很多作品的影子，比如任意门就是对应的《哈尔的移动城堡》，进入异世界的入口就对应了《千与千寻》等等，想必宫崎骏老爷子也是想在告别之作，缅怀自己已逝去的岁月吧。

7

“我不怕火，能生下你，是我的荣幸。”

当时看到这一幕的时候，想到了丹尼斯·维伦纽瓦的电影《降临》里的剧情，对，就是《沙丘》的导演，女主因为接触到外星人，所以有了预知未来的能力，当她知道和男主在一起，会面临未来女儿死亡的结果时，当她只能眼睁睁看着结果发生时，拥有的同时就正在失去。

“如果你已经能一览自己的人生，从始到终，你会想做改变吗？”

“就算知晓整段旅程，知晓它如何终结，我也选择接受。选择去拥抱其中每个瞬间。”

有异曲同工之处，这一切都源自于爱。我还想到韩寒《乘风波浪》里最后那一声“妈咪”，也是很感人的。

8

要说影片觉得不好之处，应该是结局突然就结束了，感觉太匆忙了些，然后就是火美在看到真人老爸，也就是自己未来老公的时候，稍微多一些表情变化就好了，表现出一丝细腻的联系，电影中整得好像陌生人一样，缺少了一点温情。其他的都还好。

9

最后那段塔主人对真人说的那些话，其实也是本片的高潮之处。

“我穿越时间和空间，旅行了很远，才找到它们，你可以建造自己的塔，创造一个没有邪恶的国度，一个富裕和平而美好的世界。”

“你想回到那个充满了凶杀和盗窃的疯狂世界吗？它很快就会变成一片火海。”

“随你交朋友，回你的世界去，但你必须堆积这些石头。”

“我的塔撑不了多久时间了。”

有人说，真人其实是宫崎骏自己，但我觉得塔主人才是宫崎骏自己，在自己即将告别之际，让屏幕前的你我，勇敢地做出一个选择，你能活出怎样的人生？你敢活出怎样的人生？你想活出怎样的人生？

想到的是东野圭吾的《解忧杂货店》里的结尾，那个一张白纸的回信，十年前就很受感动，所以一直保留这个照片，而以这个作为结尾，同样很适用于《你想活出怎样的人生》这部电影想要传达的美好祝愿。

简介

众所周知，Android平台的管理机制下，App进入后台后，为了提供持续的及时服务（如推送、音乐），或进行驻留获取收益（跟踪、信息收集、广告）等，会利用一些方法来让自身保持活跃，躲过被Android系统或用户发觉、清理，实现后台驻留。

其中，后台驻留的广义概念，除了保持在后台运行外，被其他组件拉起也属于驻留（唤醒）。

由于驻留会对系统的性能、响应延迟、续航、发热等带来负面影响，令系统的资源管理效果降低，属于违背用户意愿和知情的恶劣行为，因此将这些App称为顽固（Diehard）应用，其利用的方法称为顽固方法。

除了App利用的一些黑科技（甚至是在违法边缘的擦边手段）以外，Android系统本身自带的机制也可以实现保活和拉起。这些保活、拉起机制，粗略划分为两类：

本文总结上述这两类会被顽固App利用的机制。

进程和Task管理

首先简单梳理一下Android Framework层基本的进程管理。

Android平台基于Linux，除了基于Linux的“进程”维度来进行管理外，还按照Task的概念来管理应用进程，分别为ProcessRecord和TaskRecord。系统可以按Task也可以按Process来管理进程。

Android提供接口直接杀死Linux进程：1. ProcessRecord的kill()方法，其实现是向对应的进程发送SIGNAL_KILL信号；2. libc的kill()函数，也是发送信号

OOM终止进程（LMK）

App进程在系统中根据OOM（Out of Memory）ADJ（Adjustment）级别和进程状态来确定优先级，当系统需要杀死进程来释放内存时，优先级越低的会优先终止。OOM ADJ分数越小优先级越高。

由于顽固App进程后台驻留时可能会被系统回收，因此顽固App通常通过一些手段（services、弹窗）等来降低OOM（提高优先级），减少自身被系统回收的几率。

最近任务列表结束Task

用户在多任务界面（Recents）移除应用，系统会结束应用对应的Task：Removing Recent Task Item（RRT）。

该操作会结束掉与Task关联的进程，但在一些场景下仍然会有对应App的进程没有被杀死。

这类终止机制由用户操作触发，当顽固应用借助多进程、多任务、唤醒拉起、互拉等操作，被终止后仍在后台运行（或后续又被唤醒），给用户感受为“杀不干净”。

强制结束App

强制结束（Force-Stop）时Android内建的功能，由ActivityManagerService提供接口，可以在设置-应用程序界面由用户手动调用。

强制结束的范畴是App对应的所有Task（即可以杀死一般App所有进程）。FSA还额外会将App设置为“STOPPED“状态，禁止应用在下一次被用户手动启用或应用跳转前被广播、服务等唤醒。强制结束对顽固App的效果不佳，许多顽固App具备Native保活能力、互拉保活、唤醒拉起等对抗措施。

此外，Android提供KILL_BACKGROUND_PROCESSES权限，允许具备权限的App调用API杀死ADJ大于SERVICE_ADJ的后台进程（即没有Service的后台进程可以被杀掉）。

保持活跃或唤醒

从最近任务隐藏或多个最近任务

Android平台提供的excludeFromRecents功能可以让App的Task在多任务中隐藏。此外一个进程可以属于不同的Task，产生多个Task并隐藏其中几个Task可以实现”杀不干净“的效果。

提升App进程优先级、阻止部分回收场景

LMK和OOM ADJ会受到进程状态和优先级的影响，提高优先级可以降低被系统回收的几率，阻止部分会杀进程的场景。

其中，将借助前台进程绑定后台服务进程保活的手段，是较常见的“杀不死、杀不干净”的情况（最近任务移除后仍有进程）。

借助Sticky Service唤醒

黏性Service是系统提供的机制，被杀死后会由系统调度进行重启。前述的force-stop杀死的进程，由于设置的“STOPPED”状态是会被跳过的，因此这种情况杀死的进程不会再自动重启。大多数ROM对此都有限制（次数、频率）。

借助广播唤醒

通过系统或其他App、组件发出的广播可以唤醒应用，顽固应用可以借助广播来完成唤醒自启。同样的，force-stop设置的“STOPPED”状态也会让广播跳过这些App，不会唤醒这些App来传递广播。但广播带有一个特例功能，带有FLAG_INCLUDE_STOPPED_PACKAGES的广播可以无视“STOPPED状态”，仍会唤醒force-stop的App。通常系统广播没有这个FLAG，基本上是其他应用发出的广播带有。

高版本的Android已经不再触发静态广播和隐式广播，这种唤醒方式少了很多。（但有FLAG_RECEIVER_INCLUDE_BACKGROUND和FLAG_INCLUDE_STOPPED_PACKAGES规避）

借助Alarm Service定时器唤醒

Alarm是Android提供的定时器功能，定时器timeout时会唤醒App。被force-stop的应用会自动移除掉注册的定时器，因此不会被唤醒。

借助Job Scheduling Service任务调度唤醒

与Alarm类似，定时唤醒App。但是受到电源管理策略、功耗管理策略、系统休眠状态、WorkManager等的影响，唤醒的定时精度较低，且不同ROM可能表现一致性较差。同样的，会跳过被force-stop的App。

借助其他App拉起唤醒

这是国内互联网App最恶心的一种机制，一群App（或集成的SDK）互相拉起对方、互相绑定提高优先级、互相拉起唤醒。其中，唤醒方式除了常规的四大组件外，还有一些黑科技、Native的方法。其中，App发出的广播带上FLAG_RECEIVER_INCLUDE_BACKGROUND和FLAG_INCLUDE_STOPPED_PACKAGES完全可以规避force-stop后"STOPPED"的应用，实现唤醒。

总结

可以说，Android本身的管理机、提供的组件间通信功能，叠加App们的流氓行为，可以说后台驻留、拉起唤醒是防不胜防的，实现较好的后台驻留管理需要较高的投入，且对系统稳定性、App基本功能的影响较大，是高投入高难度的研究方向。其中，App互拉唤醒和保活的机制，让force-stop机制做不到太好的效果，其"STOPPED"实现的类似的轻度冻结状态几乎报废，也是各大ROM厂商在后台管理部分大展身手的重要因素。

为了实现好的功耗、续航、性能，就需要在应用唤醒、冻结、暂停执行等方面下功夫了。

在做小程序开发的过程中，经常会涉及到用户身份的问题，最普遍的就是要获取用户的手机号码，通过微信获取手机号码后可以减少很多操作，比如用户手机号码验证等，以及给用户发送提示短信等等。

※ 正常情况下，小程序可获取的公开信息有：昵称，城市，ip等公开信息，如果想要手机号等非公开信息，前提是需要已认证的非个人小程序账号。

小程序具有非常简洁的api，通过小程序内部封装，只要通过一个类型 调取他们的api方法，便可直接拉起授权。

接下来和大家聊聊，获取用户手机号码的api：getPhoneNumber

官方文档：developers.weixin.qq.com/miniprogram…

大致实现思路：

获取用户手机号码 分为以下几步：

第一步，点击页面获取授权按钮

第二步，获取用户授权参数

第三步，根据加解密算法解密手机号码

接下来我们来实现以上三步（包含前后端）

前端

代码:

<button open-type="getPhoneNumber" bindgetphonenumber="getPhoneNumber"></button>

只要在你的view里将此button放上，便可拉起授权。

分析：
open-type=“getPhoneNumber” 这个是官方给出的api。

bindgetphonenumber=“getPhoneNumber”,是调起授权框之后用户操作的回调 用户点击了拒绝还是接受，由此方法接收通知。

bindgetphonenumber：官方指定点击事件。 如果使用uniapp则需要改为@getphonenumber，并遵循uniapp开发规范。

至于getPhoneNumber

下面看代码

getPhoneNumber (e) {

var that = this;

    if (e.detail.errMsg == 'getPhoneNumber:fail user deny') { //用户点击拒绝

      wx.showToast({

    title: '请绑定手机号',

    duration: 5000,

    icon: 'none',

      });

    } else {

}

 } 

getPhoneNumber:fail user deny 拒绝与否，这个是依据
※ 很多博客上写着 getPhoneNumber:user deny 缺少了fail 。

以下为获取手机号封装方法：

getPhoneNumber(e) {

var that = this;

wx.login({

  success (res) {

    if (res.code) {

      console.log('步骤2获检查用户登录状态，获取用户电话号码！', res)

      wx.request({

        url: '这里写自己的获取授权的服务器地址',

        data: {code: res.code},

        header: {'content-type': 'application/json'},

        success: function(res) {

          console.log("步骤三获取授权码，获取授权openid，session_key",res);

          var userphone=res.data.data;

          wx.setStorageSync('userphoneKey',userphone);

          //解密手机号

          var msg = e.detail.errMsg;

          var sessionID=wx.getStorageSync("userphoneKey").session_key;

          var encryptedData=e.detail.encryptedData;

          var iv=e.detail.iv;

          if (msg == 'getPhoneNumber:ok') {//这里表示获取授权成功

            wx.checkSession({

              success:function(){

                    //这里进行请求服务端解密手机号

                that.deciyption(sessionID,encryptedData,iv);

              },

              fail:function(){

                // that.userlogin()

              }

            })

          }



        },fail:function(res){

            console.log("fail",res);

        }

      })

    } else {

      console.log('登录失败！' + res.errMsg)

    }

  }

}) 

以上

e.detail.iv
e.detail.encryptedData

两个必传 传到后台 换取mobile

后端

不管是spring还是servlet只要请求能进到该方法即可，所以重点关注中间部分，把参数值传正确即可

工具类方法 WxUtil.doGetStr(url)

以上值可以返回给前端，前端可以收到三个参数：openid，session_key，expires_in。

接着我们通过授权之后，获取第三个参数iv，调用下面方法进行服务端解密

服务端解密代码参考：

deciphering解密方法参考：

以上

我二姨既养猪也养牛，收益是赔的时候更多。

如果你有投资猪肉股经验，一定知道猪周期。要是在猪肉下行周期中囤猪，那就等着赔吧，赔多少而已。

我年轻的时候就想，为啥二姨自己养的猪，自己却不能决定卖多少价格？多年过去这个问题总算是有点眉目。

本质是二姨在利用市场销售自己养的猪，而市场有其自身的规则，单一家庭养猪户是没有办法决定市场猪价的。

一 市场

市场准确的说是市场经济，自我国宋代就已诞生。

然而现代市场经济理论的奠基人是一位西方经济学家——亚当·斯密，就是写了《国富论》的作者。

在《国富论》中其详细阐述了自由市场经济的原理。他提出了“看不见的手”理论，认为在自由竞争的市场中，每个人都在追求自己的利益，这种追求会像一只“看不见的手”一样，引导市场资源向最有利于社会的方向分配。

在姚洋的《经济学的意义》中提到福利经济学第一定律：如果由市场自己去生产和交换，最后经济总会达到帕累托最优。提到福利经济学第二定律：任何的帕累托最优状态，通过调整初始的禀赋分配，最后都能在市场机制下实现。帕累托最优指的是不可能在不牺牲任何人利益的情况下改善其他人的福利的状态。

所以市场经济被认为是配置资源最好的方式，至少目前还没找到比她更好的方式。

曾经一位伟大的国人说，他所做的事情不过是对我们的国家做了一次市场化改革。

现在我们建设的是具有中国特色的市场经济。

二 边际与均衡价格

边际是一种思维方式，就是永远看市场中最后一个人的行为或者最后一个产品的情况。比如在劳动力市场上，工资不是市场中的平均水平的劳动者决定的，而是最后一个参加劳动的人决定的，要看给他多高的工资他才愿意去做这份工作，同时也要看他有多大的贡献工厂才雇用他，两者相等的时候才是市场里的均衡工资。

边际能够解释一些实际问题。比如高速费的收取，如果不收取高速费，会导致高速拥堵，收取高速费导致对高速使用价格敏感者退出，所以说高速价格不是由第一个人决定的，而是最后一些人决定的。

边际也是新商品上市后价格的演化，直到形成均衡价格。就生猪市场而言，其是成熟市场，均衡价格已经形成。在均衡价格下，价格决定于供求关系，决定于价值链，决定于生猪出厂价格和猪肉消费价格。

我的老家在河北，我从我妈那里了解到我们老家农村的猪肉价格是10/斤元上下；而我在北京小区超市看到的是13/斤元上下。这个价格我认为肯定不是大家口袋里没钱造成的。

我又看了下A股几家上规模的生猪养殖集团：牧原股份、温氏股份、正邦科技。三者在2023年都是大幅亏损，其中正邦科技更是st了。而2020年牧原股份大幅度盈利200多个亿，我还查到2020年河北9月份的平均生猪价格，为33.73元/公斤，这都赶上今年的猪肉价了。

这样的数据结果表明今年的猪肉或者生猪价格，主要是供给导致，是生猪太多，生猪养殖太卷，不得不低价销售导致。

总结一下，生猪养殖市场均衡价格由供求关系决定，供求关系就像是天平，只有其上的砝码发生较大变化时才会影响平衡。就生猪市场来说，供求关系可以被牧原股份这种千万生猪体量的养殖集团影响，可以被一场范围特别大的猪瘟影响。

单一家庭养猪户因为生猪体量非常非常小，影响力微乎其微，不可能影响供求关系，也就不可能决定生猪价格，这也就是我二姨不能决定卖猪价格的原因。

三 周期

这部分属于题外话。不仅猪市场存在周期；文明也有周期，表现为王朝的兴衰更替；经济本身也存在周期，比如加息周期和降息周期；现在更有万物皆周期一说。

一种解释是，周期的产生源于人的贪婪。有一句话著名的话：人们从历史中吸取的教训就是从不吸取教训。

文明周期源于王朝的后期统治者普遍开始奢侈，导致统治力衰弱，最终王朝灭亡，比如烽火戏诸侯。

经济周期源于债务，也是贪婪。债务越借越大，越借越不想还，就比如现在的美利坚，你看他的国债多大了，一年利息都1w多亿。

或许周期本源于人性，源于这个世界本身，且看那天地有四季，有日月更替。

尾声

现在二姨已经不养猪了。如果还养猪，我会建议要当有大猪场倒闭时再进入，这个时候市场上能卖猪的少了，而想买猪的没变，均衡价格该起来了。

需求简介

轮播图是我们前端开发中的一个常见需求，在项目开发中，我们可以使用element、ant等UI库实现。某些场景，为了一个简单的功能安装一个库是没必要的，我们最好的选择就是手搓。

我们来看一个需求

上述需求核心就是实现一个无缝轮播的切换效果。以这个需求为例，我们看看最终实现效果：

实现思路

要想实现一个无缝的轮播效果，其实非常简单，核心思想就是动态改变显示的列表而已。比如我们有这样一个数组

const list = ref([

    { name: 1, id: 1 }, 

    { name: 2, id: 2 },

    { name: 3, id: 3 }

])

如果我们想无缝切换的展示这个数据，最简单的代码就是动态的改变下面的代码的index

<template>

    <div>

       {{ list[index] }}

    </div>

</template>

<script setup>

    const index = ref(0)

    const list = ref([{ name: 1, id: 1 }, { name: 2, id: 2 }, { name: 2, id: 2 }])

<scriptp>

那如何实现切换的样式呢？也非常简单，我们只要给元素添加一个出现样式和离开样式即可。现在，我们来具体实现这样一个需求。

技术方案

数据的动态切换

要想实现一个数据的动态循环切换效果，是非常容易的：

<template>

 <div v-for="(build, index) in list" :key="index">

    <div v-show="index === selectIndex">

       卡片自定义内容

    </div>

 </div>

</template>

<script setup>

const selectIndex = ref(0)

const list = ref(

    [{ name: "卡片1", id: 1 }, { name: "卡片1", id: 2 }, { name: "卡片1", id: 2 }]

)



// #计时器实例

let timer: any = null



// >计时器逻辑

const timeFuc = () => {

    timer = setInterval(() => {

      // 更改选中的index

      if (selectIndex.value >= list.value.length - 1) {

        selectIndex.value = 0

      } else {

        selectIndex.value++

      }

    }, 5000)

}



timeFuc()

<scriptp>

上述代码中，我们设置了一个定时器，定时器每5s执行一次，每次执行都会动态更改当前要显示的数据索引值，当索引值达到最大实，在将其重置。通过上述的简单代码，我们就实现了一个可以自动切换的循环渲染的卡片。

动画添加

要想实现最终效果的动态效果也非常容易，我们只需要给每个元素出现时设置一些样式，离开时设置一些样式即可。借助vue的Transition组件，我们能很容易实现这样一个效果。

如果你不了解vue的Transition组件，请去官网补充下知识：cn.vuejs.org/guide/built…

<template>

<div class="main-content">

    <Transition v-for="(build, index) in list" :key="selectIndex">

        <div class="banner-scroll-wrap" v-show="index === selectIndex">

            卡片自定义内容

        </div>

    </Transition>

</div>

</template>

<script setup>

const selectIndex = ref(0)

const list = ref(

    [{ name: "卡片1", id: 1 }, { name: "卡片1", id: 2 }, { name: "卡片1", id: 2 }]

)



// #计时器实例

let timer: any = null



// >计时器逻辑

const timeFuc = () => {

    timer = setInterval(() => {

      // 更改选中的index

      if (selectIndex.value >= list.value.length - 1) {

        selectIndex.value = 0

      } else {

        selectIndex.value++

      }

    }, 5000)

}



timeFuc()

<scriptp>

<style lang="less" scoped>

.main-content {

    position: relative;

    height: 100%;

    .banner-scroll-wrap {

        position: absolute;

        top: 0;

        bottom: 0;

        right: 0;

        left: 0;

    }

}



.v-enter-from {

    transform: translateX(100%);

    opacity: 0;

}



.v-enter-active,

.v-leave-active {

    transition: transform 600ms ease-in-out, opacity 600ms ease-in-out;

}



.v-enter-to {

    transform: translateX(0);

    opacity: 1;

}



.v-leave-from {

    transform: translateX(0);

    opacity: 1;

}



.v-leave-to {

    transform: translateX(-100%);

    opacity: 0;

}

<style/>

上述代码中，由于 selectIndex是动态的，元素不断地在显示与隐藏。因此，Transition标签的进入样式和离开样式会动态触发，从而形成切换效果。

v-enter是元素的进入样式，进入时，我们从最右边偏移100%的距离到正常位置，透明度从0到1，这个过程持续0.6s，实现了元素左移淡入的效果。

v-leave是元素的离开样式，离开时，我们从正常位置偏移到100%的左侧位置，透明度从1到0，这个过程持续0.6s，实现了元素左移淡出的效果。

在这些类的共同作用下，我们实现了元素的动态切换。

你可能注意到了我给元素设置了一个banner-scroll-wrap类名，并使用了position: absolute，这样设置的注意目的是保证切换离开元素的淡出效果和进入元素的淡入效果是连贯的。如果你不这样写，可能会出现样式问题。

此外，注意我给Transition设置了key="Transition"，这样些会保证每次数据在切换时，transition能够重新渲染，触发元素离开和进入的样式。

至此，我们就完成了基本功能样式

轮播的停止与恢复

很常见的一种情况就是我们需要鼠标放在卡片上时停止轮播，离开卡片的时候恢复轮播，这非常容易。

<template>

<div class="main-content"  @mouseenter="stop()" @mouseleave="start()">

    <Transition v-for="(build, index) in list" :key="selectIndex">

        <div class="banner-scroll-wrap" v-show="index === selectIndex">

            卡片自定义内容

        </div>

    </Transition>

</div>

</template>

<script setup>

const selectIndex = ref(0)

const list = ref(

    [{ name: "卡片1", id: 1 }, { name: "卡片1", id: 2 }, { name: "卡片1", id: 2 }]

)



// #计时器实例

let timer: any = null



// >计时器逻辑

const timeFuc = () => {

    timer = setInterval(() => {

      // 更改选中的index

      if (selectIndex.value >= list.value.length - 1) {

        selectIndex.value = 0

      } else {

        selectIndex.value++

      }

    }, 5000)

}



  // >开启轮播

  const start = () => {

    if (timer) return

    timeFuc()

  }



  // >关闭轮播

  const stop = () => {

    clearInterval(timer)

    timer = null

  }



timeFuc()

<scriptp>

<style lang="less" scoped>

<style/>

解决重影问题

在某些情况下，我们离开这个页面很久后（浏览器切换到其他选项卡），然后在切回来的时候，可能会出现短暂的画面重影问题，这个问题也很好解决，加上下面的代码即可

<script setup>



    //...



    // 解决切屏后重影的问题

  onMounted(() => {

    document.addEventListener('visibilitychange', () => {

      // 用户息屏、或者切到后台运行 （离开页面）

      if (document.visibilityState === 'hidden') {

        stop()

      }

      // 用户打开或回到页面

      if (document.visibilityState === 'visible') {

        start()

      }

    })

  })

    

  onBeforeUnmount(() => stop())



<scriptp>

visibilitychange 事件：当其选项卡的内容变得可见或被隐藏时，会在 document 上触发 visibilitychange 事件。该事件不可取消。

总结

在本教程中，我们通过简单代码实现了无缝轮播效果，样式是左右切换，我们也可以通过样式控制实现上下切换的效果，比如将translateX设置为translateY即可。

 .v-enter-from {

    transform: translateY(100%);

    opacity: 0;

}

时间原因，本教程也没有对技术上做深究，也希望各位大佬能提供自己的思路与建议，感谢大家分享！

逐字渲染的挑战

最近在开发AI聊天助手的时候，遇到了一个很有趣的滚动问题。我们需要开发一个类似微信聊天框的交互体验：

每当聊天框中展示新消息时，需要将聊天框滚动到底部，展示最新消息。

如果在 web 什么也不做，聊天体验可能是这样的，需要用户手动滚动到最新消息：

试想一下如何在 web 中实现微信的效果。每当聊天框中接收到新消息时，都需要调用滚动方法滚动到消息底部。

element.scrollIntoView({ behavior: "smooth", block: "end");

对于普通的聊天工具来说，这样实现没有什么大问题，因为聊天框接收到每条消息的长度都是确定的。但是 AI 大模型一般都是逐字渲染的，AI 助手聊天框接受的消息体大小不是固定的，而是会随着 AI 大模型的输出不断变大。如果仍使用 scrollIntoView 来滚动到底部，就需要监听消息体的变化，每次消息更新时都要通过 JavaScript 调用一次滚动方法，会造成一些问题：

自然列表：灵感来源

聊天框接收到新消息时滚动到最新位置，总感觉这应该是一个很自然的行为，不需要这么多 Javascript 代码去实现滚动行为。

于是联想到了 Excel 表格，当我们在表格中第一行插入一行，这一行后边的内容会被很自然的挤下去。并不需要做什么滚动，这一行就会出现在最顶部的位置。

想到这里惊讶的发现，聊天框实际上不就是一个倒过来的列表吗？ 列表最上边新增的行会把后边的行往下挤，而聊天框最下边新增消息需要把上边的消息往上挤。那假如我们将聊天框旋转 180° 呢...?

聊天框的翻转实现

翻转聊天框

利用 CSS transform: rotate(180deg) 将整个聊天框倒转，并且把接收到最新的消息插入到消息列表的头部。发现我们的设想确实是行得通的，新增的消息很自然的把历史消息顶了上去，消息卡片内容增加也能很自然的撑开。并且在消息输出时，也可以随意滚动查看历史记录。

滚动条调整与滚动行为反转

最核心的问题已经解决了，但总觉得哪里看起来怪怪的。滚动条怎么跑到左边，并且滚动行为和鼠标滚轮的方向反了，滚轮向上滚，聊天框却向下滚。（让人想起了 MacOS 连鼠标滚轮的反人类体验）

查阅文档发现 CSS 有个 direction: rtl; 属性可以改变内容的排布的方向。这样我们就可以把滚动条放回右边了。然后在通过监听滚动事件，改变滚动方向就可以恢复鼠标滚轮的滚动行为。

element.addEventListener('wheel', event => {

      event.preventDefault(); // 阻止默认滚动行为

      const { deltaY } = event; // 获取滚动方向和速度

      chatContent.current.scrollTop -= deltaY; //  反转方向

    });

消息卡片翻转恢复

可以看到目前就只剩下聊天框中的消息卡片是反的，接下来把聊天框中的消息卡片转正就大功告成了。我们在聊天框中，给每个消息卡片都添加 transform: rotate(180deg);direction: ltr; 样式，把消息重新转正。

这样就把翻转的行为全部隔离在了聊天框组件中。消息卡片组件完全感知不到自己其实已经被旋转了 180° 后又旋转了 180° 了。聊天框的父组件也完全不知道自己的子节点被转了又转。

总结

最后总结一下，我们通过两行 CSS 代码 + 反转滚动行为，利用浏览器的默认行为完美的实现了 AI 聊天框中的滚动体验。

transform: rotate(180deg);

direction: rtl;

element.addEventListener('wheel', event => {

      event.preventDefault(); // 阻止默认滚动行为

      const { deltaY } = event; // 获取滚动方向和速度

      chatContent.current.scrollTop -= deltaY; //  反转方向

    });

DEMO 仓库：github.com/lrwlf/messa…

更新：

想到一个更简洁的办法可以达到相同的效果，只用把聊天框 CSS 设置为:

display: flex;

flex-direction: column-reverse;

让列表倒序渲染，并且像原来的方法一样，在消息列表的头部插入消息，就可以实现一样的效果。不需要对聊天框和消息体再进行旋转操作，也不需要反转滚动条的行为。

以上两种方法都存在一个相同的问题，当一开始聊天消息还很少时，聊天消息也会紧贴着底部，顶部会留出一片空白。

这时只需要在聊天列表的最开始设置一个空白的占位元素，把它的 CSS 设置为：

flex-grow: 1;

flex-shrink: 1;

就可以实现消息少的时候自动撑开，把消息撑到顶部。消息列表开始滚动时，占位元素又会被挤压消失，不影响列表滚动效果。

(为了演示，把占位元素设置为了黑色)

更新部分代码见： github.com/lrwlf/messa…

将 App.js 的 chat 组件，替换为 src/components/chat-flex

近期产品期望在后台发布帖子或视频时，需要添加 @用户 的功能，以便用户收到通知，例如“xxx在xxx提及了您！”。然而，现有的开源库未能满足我们的需求，例如 ant-design 的 Mentions 组件：

但是不难发现跟微信飞书对比下，有两个细节没有处理。

然后也是找了其他的库都没达到产品的期望效果，那么好，自己实现一个，先看看最终实现的效果：

封装之后使用：

<AtInput

    height={150}

    onRequest={async (searchStr) => {

        const { data } = await UserFindAll({ nickname: searchStr });

        return data?.list?.map((v) => ({

            id: v.uid,

            name: v.nickname,

            wechatAvatarUrl: v.wechatAvatarUrl,

        }));

    }}

    onChange={(content, selected) => {

        setAtUsers(selected);

    }}

/>

那么实现这么一个输入框大概有以下几个点：

大多数文本输入框我们会使用input,或者textarea,很明显以上1,2两点实现不了，antd也是使用的textarea，所以也是没有实现这两个效果。所以这块使用富文本编辑，设置contentEditable,将其变为可编辑去做。输入框以及选择器的dom就如下:

 <div style={{ height, position: 'relative' }}>

       {/* 编辑器 */}

       <div 

           id="atInput" 

           ref={atRef} 

           className={'editorDiv'} 

           contentEditable 

           onInput={editorChange} 

           onClick={editorClick} 

       />

       {/* 选择用户框 */}

       <SelectUser 

           options={options} 

           visible={visible} 

           cursorPosition={cursorPosition} 

           onSelect={onSelect} 

       />

 </div>

实现思路：

以上提到了监听@文本变化，通常绑定onChange事件就行，但是还有一种用户通过点击移动光标，这块需要绑定change,click两个时间，他们里边的逻辑基本一样，只需要额外处理点击选中输入框中用户时，整体选中g功能，那么代码如下：

    const onObserveInput = () => {

        let cursorBeforeStr = '';

        const selection: any = window.getSelection();

        if (selection?.focusNode?.data) {

            cursorBeforeStr = selection.focusNode?.data.slice(0, selection.focusOffset);

        }

        setFocusNode(selection.focusNode);

        const lastAtIndex = cursorBeforeStr?.lastIndexOf('@');

        setCurrentAtIdx(lastAtIndex);

        if (lastAtIndex !== -1) {

            getCursorPosition();

            const searchStr = cursorBeforeStr.slice(lastAtIndex + 1);

            if (!StringTools.isIncludeSpacesOrLineBreak(searchStr)) {

                setSearchStr(searchStr);

                fetchOptions(searchStr);

                setVisible(true);

            } else {

                setVisible(false);

                setSearchStr('');

            }

        } else {

            setVisible(false);

        }

    };



    const selectAtSpanTag = (target: Node) => {

        window.getSelection()?.getRangeAt(0).selectNode(target);

    };



    const editorClick = async (event) => {

        onObserveInput();

        // 判断当前标签名是否为span 是的话选中当做一个整体

        if (e.target.localName === 'span') {

            selectAtSpanTag(e.target);

        }

    };



    const editorChange = (event) => {

        const { innerText } = event.target;

        setContent(innerText);

        onObserveInput();

    };

每次点击或者文本改变时都会去调用onObserveInput，以上onObserveInput该方法中主要做了以下逻辑：

• 在此之前需要先了解 Selection的一些方法

 const getCursorPosition = () => {

        // 坐标相对浏览器的坐标

        const { x, y } = window.getSelection()?.getRangeAt(0).getBoundingClientRect() as any;

        // 获取编辑器的坐标

        const editorDom = window.document.querySelector('#atInput');

        const { x: eX, y: eY } = editorDom?.getBoundingClientRect() as any;

        // 光标所在位置

        setCursorPosition({ x: x - eX, y: y - eY });

};

选择器弹出后，那么下面就到了选择用户之后的流程了，

 /**

     * @param id 唯一的id 可以uid

     * @param name 用户姓名

     * @param color 回显颜色

     * @returns

     */

    const createAtSpanTag = (id: number | string, name: string, color = 'blue') => {

        const ele = document.createElement('span');

        ele.className = 'at-span';

        ele.style.color = color;

        ele.id = id.toString();

        ele.contentEditable = 'false';

        ele.innerText = `@${name}`;

        return ele;

    };



    /**

     * 选择用户时回调

     */

    const onSelect = (item: Options) => {

        const selection = window.getSelection();

        const range = selection?.getRangeAt(0) as Range;

        // 选中输入的 @关键字  -> @郑

        range.setStart(focusNode as Node, currentAtIdx!);

        range.setEnd(focusNode as Node, currentAtIdx! + 1 + searchStr.length);

        // 删除输入的 @关键字

        range.deleteContents();

        // 创建元素节点

        const atEle = createAtSpanTag(item.id, item.name);

        // 插入元素节点

        range.insertNode(atEle);

        // 光标移动到末尾

        range.collapse();

        // 缓存已选中的用户

        setSelected([...selected, item]);

        // 选择用户后重新计算content

        setContent(document.getElementById('atInput')?.innerText as string);

        // 关闭弹框

        setVisible(false);

        // 输入框聚焦

        atRef.current.focus();

    };

选择用户的时候需要做的以下以下几点：

最后

在选择的用户或者内容发生改变时将数据抛给父组件

 const getAttrIds = () => {

        const spans = document.querySelectorAll('.at-span');

        let ids = new Set();

        spans.forEach((span) => ids.add(span.id));

        return selected.filter((s) => ids.has(s.id));

    };



    /**  @的用户列表发生改变时，将最新值暴露给父组件 */

    useEffect(() => {

        const selectUsers = getAttrIds();

        onChange(content, selectUsers);

    }, [selected, content]);

完整组件代码

输入框主要逻辑代码：

let timer: NodeJS.Timeout | null = null;



const AtInput = (props: AtInputProps) => {

    const { height = 300, onRequest, onChange, value, onBlur } = props;

    // 输入框的内容=innerText

    const [content, setContent] = useState<string>('');

    // 选择用户弹框

    const [visible, setVisible] = useState<boolean>(false);

    // 用户数据

    const [options, setOptions] = useState<Options[]>([]);

    // @的索引

    const [currentAtIdx, setCurrentAtIdx] = useState<number>();

    // 输入@之前的字符串

    const [focusNode, setFocusNode] = useState<Node | string>();

    // @后关键字 @郑 = 郑

    const [searchStr, setSearchStr] = useState<string>('');

    // 弹框的x,y轴的坐标

    const [cursorPosition, setCursorPosition] = useState<Position>({

        x: 0,

        y: 0,

    });

    // 选择的用户

    const [selected, setSelected] = useState<Options[]>([]);

    const atRef = useRef<any>();



    /** 获取选择器弹框坐标 */

    const getCursorPosition = () => {

        // 坐标相对浏览器的坐标

        const { x, y } = window.getSelection()?.getRangeAt(0).getBoundingClientRect() as any;

        // 获取编辑器的坐标

        const editorDom = window.document.querySelector('#atInput');

        const { x: eX, y: eY } = editorDom?.getBoundingClientRect() as any;

        // 光标所在位置

        setCursorPosition({ x: x - eX, y: y - eY });

    };



    /**获取用户下拉列表 */

    const fetchOptions = (key?: string) => {

        if (timer) {

            clearTimeout(timer);

            timer = null;

        }

        timer = setTimeout(async () => {

            const _options = await onRequest(key);

            setOptions(_options);

        }, 500);

    };



    useEffect(() => {

        fetchOptions();

        // if (value) {

        //     /** 判断value中是否有at用户 */

        //     const atUsers: any = StringTools.filterUsers(value);

        //     setSelected(atUsers);

        //     atRef.current.innerHTML = value;

        //     setContent(value.replace(/<\/?.+?\/?>/g, '')); //全局匹配内html标签)

        // }

    }, []);



    const onObserveInput = () => {

        let cursorBeforeStr = '';

        const selection: any = window.getSelection();

        if (selection?.focusNode?.data) {

            cursorBeforeStr = selection.focusNode?.data.slice(0, selection.focusOffset);

        }

        setFocusNode(selection.focusNode);

        const lastAtIndex = cursorBeforeStr?.lastIndexOf('@');

        setCurrentAtIdx(lastAtIndex);

        if (lastAtIndex !== -1) {

            getCursorPosition();

            const searchStr = cursorBeforeStr.slice(lastAtIndex + 1);

            if (!StringTools.isIncludeSpacesOrLineBreak(searchStr)) {

                setSearchStr(searchStr);

                fetchOptions(searchStr);

                setVisible(true);

            } else {

                setVisible(false);

                setSearchStr('');

            }

        } else {

            setVisible(false);

        }

    };



    const selectAtSpanTag = (target: Node) => {

        window.getSelection()?.getRangeAt(0).selectNode(target);

    };



    const editorClick = async (e?: any) => {

        onObserveInput();

        // 判断当前标签名是否为span 是的话选中当做一个整体

        if (e.target.localName === 'span') {

            selectAtSpanTag(e.target);

        }

    };



    const editorChange = (event: any) => {

        const { innerText } = event.target;

        setContent(innerText);

        onObserveInput();

    };



    /**

     * @param id 唯一的id 可以uid

     * @param name 用户姓名

     * @param color 回显颜色

     * @returns

     */

    const createAtSpanTag = (id: number | string, name: string, color = 'blue') => {

        const ele = document.createElement('span');

        ele.className = 'at-span';

        ele.style.color = color;

        ele.id = id.toString();

        ele.contentEditable = 'false';

        ele.innerText = `@${name}`;

        return ele;

    };



    /**

     * 选择用户时回调

     */

    const onSelect = (item: Options) => {

        const selection = window.getSelection();

        const range = selection?.getRangeAt(0) as Range;

        // 选中输入的 @关键字  -> @郑

        range.setStart(focusNode as Node, currentAtIdx!);

        range.setEnd(focusNode as Node, currentAtIdx! + 1 + searchStr.length);

        // 删除输入的 @关键字

        range.deleteContents();

        // 创建元素节点

        const atEle = createAtSpanTag(item.id, item.name);

        // 插入元素节点

        range.insertNode(atEle);

        // 光标移动到末尾

        range.collapse();

        // 缓存已选中的用户

        setSelected([...selected, item]);

        // 选择用户后重新计算content

        setContent(document.getElementById('atInput')?.innerText as string);

        // 关闭弹框

        setVisible(false);

        // 输入框聚焦

        atRef.current.focus();

    };



    const getAttrIds = () => {

        const spans = document.querySelectorAll('.at-span');

        let ids = new Set();

        spans.forEach((span) => ids.add(span.id));

        return selected.filter((s) => ids.has(s.id));

    };



    /**  @的用户列表发生改变时，将最新值暴露给父组件 */

    useEffect(() => {

        const selectUsers = getAttrIds();

        onChange(content, selectUsers);

    }, [selected, content]);



    return (

        <div style={{ height, position: 'relative' }}>

            {/* 编辑器 */}

            <div id="atInput" ref={atRef} className={'editorDiv'} contentEditable onInput={editorChange} onClick={editorClick} />

            {/* 选择用户框 */}

            <SelectUser options={options} visible={visible} cursorPosition={cursorPosition} onSelect={onSelect} />

        </div>

    );

};

选择器代码

const SelectUser = React.memo((props: SelectComProps) => {

  const { options, visible, cursorPosition, onSelect } = props;



  const { x, y } = cursorPosition;



  return (

    <div

      className={'selectWrap'}

      style={{

        display: `${visible ? 'block' : 'none'}`,

        position: 'absolute',

        left: x,

        top: y + 20,

      }}

    >

      <ul>

        {options.map((item) => {

          return (

            <li

              key={item.id}

              onClick={() => {

                onSelect(item);

              }}

            >

              <img src={item.wechatAvatarUrl} alt="" />

              <span>{item.name}</span>

            </li>

          );

        })}

      </ul>

    </div>

  );

});

export default SelectUser;

以上就是实现一个支持@用户的输入框功能，就目前而言，比较死板，不支持自定义颜色，自定义选择器等等，未来，可以进一步扩展功能，例如添加@用户的高亮样式定制、支持键盘快捷键操作等，从而提升用户体验和功能性。

一、前言

Android 多屏互联的时代，必然会出现多屏连接的问题，通常意义上的多屏连接包括HDMI/USB、WifiDisplay，除此之外Android 还有OverlayDisplay和VirtualDisplay，其中VirtualDisplay相比不少人录屏的时候都会用到，在Android中他们都是Display，除了物理屏幕，你在OverlayDisplay和VirtualDisplay同样也可以展示弹窗或者展示Activity，所有的Display的差异化通过DisplayManagerService 进行了兼容，同样任意一种Display都拥有自己的密度和大小以及display Id，对于测试双屏应用，一般也可以通过VirtualDisplay进行模拟操作。

需求

本篇主要解决副屏Dialog 组建展示问题。存在任意类型的副屏时，让 Dialog 展示在副屏上，如果不存在，就需要让它自动展示在主屏上。

为什么会有这种需求呢？默认情况下，实现双屏异显的时候， 通常不是使用Presentation就是Activity，然而，Dialog只能展示在主屏上，而Presentation只能展示的副屏上。想象一下这种双屏场景，在切换视频的时候，Loading展示应该是在主屏还是副屏呢 ？毫无疑问，答案当然是副屏。

问题

我们要解决的问题当然是随着场景的切换，Dialog展示在不同的屏幕上。同样，内容也可以这样展示，当存在副屏的时候在副屏上展示内容，当只有主屏的时候在主屏上展示内容。

二、方案

我们这里梳理一下两种方案。

方案：自定义Presentation

作为Presentation的核心点有两个，其中一个是displayId，另一个是WindowType，第一个是通常意义上指定Display Id，第二个是窗口类型。如果是副屏，那么displayId是必须的参数，且不能和DefaultDisplay的id一样，除此之外WindowType是一个需要重点关注的东西。

早期的 TYPE_PRESENTATION 存在指纹信息 “被借用” 而造成用户资产损失的风险，即便外部无法获取，但是早期的Android 8.0版本利用 （TYPE_PRESENTATION=TYPE_APPLICATION_OVERLAY-1）可以实现屏幕外弹框，在之后的版本做了修复，同时对 TYPE_PRESENTATION 展示必须有 Token 等校验，但是在这种过程中，Presentation的WindowType 变了又变，因此，我们如何获取到兼容每个版本的WindowType呢？

原理

Display Id的问题我们不需要重点处理，从display 获取即可。WindowType才是重点，方法当然是有的，我们不继承Presentation，而是继承Dialog因此自行实现可以参考 Presentation 中的代码，当然难点是 WindowManagerImpl 和WindowType类获取，前者 @hide 标注的，而后者不固定。

早期我们可以利用 compileOnly layoutlib.jar 的方式导入 WindowManagerImpl，但是新版本中 layoutlib.jar 中的类已经几乎被删，另外如果要使用 layoutlib.jar，那么你的项目中的 kotlin 版本就会和 layoutlib.jar 产生冲突，虽然可以删除相关的类，但是这种维护方式非常繁琐，因此我们这里借助反射实现。当然除了反射也可以利用Dexmaker或者xposed Hook方式，只是复杂性会很多。

WindowType问题解决

我们知道，创建Presentation的时候，framework源码是设置了WindowType的，我们完全在我们自己的Dialog创建Presentation对象，读取出来设置上到我们自己的Dialog上即可。

不过，我们先要对Display进行隔离，避免主屏走这段逻辑

WindowManager wm = (WindowManager) outerContext.getSystemService(WINDOW_SERVICE); 

if(display==null || wm.getDefaultDisplay().getDisplayId()==display.getDisplayId()){  

return; 

}

//注意，这里需要借助Presentation的一些属性，否则无法正常弹出弹框，要么有权限问题、要么有token问题

Presentation presentation = new Presentation(outerContext, display, theme);  

WindowManager.LayoutParams standardAttributes =presentation.getWindow().getAttributes();  

final Window w = getWindow(); 

final WindowManager.LayoutParams attr = w.getAttributes(); 

attr.token = standardAttributes.token; w.setAttributes(attr);

//type 源码中是TYPE_PRESENTATION，事实上每个版本是不一样的，因此这里动态获取 w.setGravity(Gravity.FILL);

w.setType(standardAttributes.type); 

WindowManagerImpl 问题

其实我们知道，Presentation的WindowManagerImpl并不是给自己用的，而是给Dialog上的其他组件（如Menu、PopWindow等），将其他组件加到Dialog的 Window上，因为在Android系统中，WindowManager都是parent Window所具备的能力，所以创建这个不是为了把Dialog加进去，而是为了把基于Dialog的Window组件加到Dialog上，这和Activity是一样的。那么，其实如果我们没有Menu、PopWindow，这里实际上是可以不处理的，但是作为一个完整的类，我们这里使用反射处理一下。

怎么处理呢？

我们知道，异显屏的Context是通过createDisplayContext创建的，但是我们这里并不是Hook这个方法，只是在创建这个Display Context之后，再通过ContextThemeWrapper，设置进去即可。

private static Context createPresentationContext(

      Context outerContext, Display display, int theme) {

   if (outerContext == null) {

      throw new IllegalArgumentException("outerContext must not be null");

   }

   WindowManager outerWindowManager = (WindowManager) outerContext.getSystemService(WINDOW_SERVICE);

   if (display == null || display.getDisplayId()==outerWindowManager.getDefaultDisplay().getDisplayId()) {

      return outerContext;

   }

   Context displayContext = outerContext.createDisplayContext(display);

   if (theme == 0) {

      TypedValue outValue = new TypedValue();

      displayContext.getTheme().resolveAttribute(

            android.R.attr.presentationTheme, outValue, true);

      theme = outValue.resourceId;

   }



   // Derive the display's window manager from the outer window manager.

   // We do this because the outer window manager have some extra information

   // such as the parent window, which is important if the presentation uses

   // an application window type.

   //  final WindowManager outerWindowManager =

   //        (WindowManager) outerContext.getSystemService(WINDOW_SERVICE);

   //   final WindowManagerImpl displayWindowManager =

   //         outerWindowManager.createPresentationWindowManager(displayContext);



   WindowManager displayWindowManager = null;

   try {

      ClassLoader classLoader = ComplexPresentationV1.class.getClassLoader();

      Class<?> loadClass = classLoader.loadClass("android.view.WindowManagerImpl");

      Method createPresentationWindowManager = loadClass.getDeclaredMethod("createPresentationWindowManager", Context.class);

      displayWindowManager = (WindowManager) loadClass.cast(createPresentationWindowManager.invoke(outerWindowManager,displayContext));

   } catch (ClassNotFoundException | NoSuchMethodException e) {

      e.printStackTrace();

   } catch (IllegalAccessException e) {

      e.printStackTrace();

   } catch (InvocationTargetException e) {

      e.printStackTrace();

   }

   final WindowManager windowManager = displayWindowManager;

   return new ContextThemeWrapper(displayContext, theme) {

      @Override

      public Object getSystemService(String name) {

         if (WINDOW_SERVICE.equals(name)) {

            return windowManager;

         }

         return super.getSystemService(name);

      }

   };

}

全部源码

public class ComplexPresentationV1 extends Dialog  {



    private static final String TAG = "ComplexPresentationV1";

    private static final int MSG_CANCEL = 1;



    private  Display mPresentationDisplay;

    private  DisplayManager mDisplayManager;

    /**

     * Creates a new presentation that is attached to the specified display

     * using the default theme.

     *

     * @param outerContext The context of the application that is showing the presentation.

     * The presentation will create its own context (see {@link #getContext()}) based

     * on this context and information about the associated display.

     * @param display The display to which the presentation should be attached.

     */

    public ComplexPresentationV1(Context outerContext, Display display) {

        this(outerContext, display, 0);

    }



    /**

     * Creates a new presentation that is attached to the specified display

     * using the optionally specified theme.

     *

     * @param outerContext The context of the application that is showing the presentation.

     * The presentation will create its own context (see {@link #getContext()}) based

     * on this context and information about the associated display.

     * @param display The display to which the presentation should be attached.

     * @param theme A style resource describing the theme to use for the window.

     * See <a href="{@docRoot}guide/topics/resources/available-resources.html#stylesandthemes">

     * Style and Theme Resources</a> for more information about defining and using

     * styles.  This theme is applied on top of the current theme in

     * <var>outerContext</var>.  If 0, the default presentation theme will be used.

     */

    public ComplexPresentationV1(Context outerContext, Display display, int theme) {

        super(createPresentationContext(outerContext, display, theme), theme);

        WindowManager wm = (WindowManager) outerContext.getSystemService(WINDOW_SERVICE);

        if(display==null || wm.getDefaultDisplay().getDisplayId()==display.getDisplayId()){

            return;

        }

        mPresentationDisplay = display;

        mDisplayManager = (DisplayManager)getContext().getSystemService(DISPLAY_SERVICE);



        //注意，这里需要借助Presentation的一些属性，否则无法正常弹出弹框，要么有权限问题、要么有token问题

        Presentation presentation = new Presentation(outerContext, display, theme);

        WindowManager.LayoutParams standardAttributes = presentation.getWindow().getAttributes();



        final Window w = getWindow();

        final WindowManager.LayoutParams attr = w.getAttributes();

        attr.token = standardAttributes.token;

        w.setAttributes(attr);

        w.setType(standardAttributes.type); 

//type 源码中是TYPE_PRESENTATION，事实上每个版本是不一样的，因此这里动态获取

        w.setGravity(Gravity.FILL);

        setCanceledOnTouchOutside(false);

    }



    /**

     * Gets the {@link Display} that this presentation appears on.

     *

     * @return The display.

     */

    public Display getDisplay() {

        return mPresentationDisplay;

    }



    /**

     * Gets the {@link Resources} that should be used to inflate the layout of this presentation.

     * This resources object has been configured according to the metrics of the

     * display that the presentation appears on.

     *

     * @return The presentation resources object.

     */

    public Resources getResources() {

        return getContext().getResources();

    }



    @Override

    protected void onStart() {

        super.onStart();



        if(mPresentationDisplay ==null){

            return;

        }

        mDisplayManager.registerDisplayListener(mDisplayListener, mHandler);



        // Since we were not watching for display changes until just now, there is a

        // chance that the display metrics have changed.  If so, we will need to

        // dismiss the presentation immediately.  This case is expected

        // to be rare but surprising, so we'll write a log message about it.

        if (!isConfigurationStillValid()) {

            Log.i(TAG, "Presentation is being dismissed because the "

                    + "display metrics have changed since it was created.");

            mHandler.sendEmptyMessage(MSG_CANCEL);

        }

    }



    @Override

    protected void onStop() {

        if(mPresentationDisplay ==null){

            return;

        }

        mDisplayManager.unregisterDisplayListener(mDisplayListener);

        super.onStop();

    }



    /**

     * Inherited from {@link Dialog#show}. Will throw

     * {@link android.view.WindowManager.InvalidDisplayException} if the specified secondary

     * {@link Display} can't be found.

     */

    @Override

    public void show() {

        super.show();

    }



    /**

     * Called by the system when the {@link Display} to which the presentation

     * is attached has been removed.

     *

     * The system automatically calls {@link #cancel} to dismiss the presentation

     * after sending this event.

     *

     * @see #getDisplay

     */

    public void onDisplayRemoved() {

    }



    /**

     * Called by the system when the properties of the {@link Display} to which

     * the presentation is attached have changed.

     *

     * If the display metrics have changed (for example, if the display has been

     * resized or rotated), then the system automatically calls

     * {@link #cancel} to dismiss the presentation.

     *

     * @see #getDisplay

     */

    public void onDisplayChanged() {

    }



    private void handleDisplayRemoved() {

        onDisplayRemoved();

        cancel();

    }



    private void handleDisplayChanged() {

        onDisplayChanged();



        // We currently do not support configuration changes for presentations

        // (although we could add that feature with a bit more work).

        // If the display metrics have changed in any way then the current configuration

        // is invalid and the application must recreate the presentation to get

        // a new context.

        if (!isConfigurationStillValid()) {

            Log.i(TAG, "Presentation is being dismissed because the "

                    + "display metrics have changed since it was created.");

            cancel();

        }

    }



    private boolean isConfigurationStillValid() {

        if(mPresentationDisplay ==null){

            return true;

        }

        DisplayMetrics dm = new DisplayMetrics();

        mPresentationDisplay.getMetrics(dm);

        try {

            Method equalsPhysical = DisplayMetrics.class.getDeclaredMethod("equalsPhysical", DisplayMetrics.class);

            return (boolean) equalsPhysical.invoke(dm,getResources().getDisplayMetrics());

        } catch (NoSuchMethodException e) {

            e.printStackTrace();

        } catch (IllegalAccessException e) {

            e.printStackTrace();

        } catch (InvocationTargetException e) {

            e.printStackTrace();

        }

        return false;

    }



    private static Context createPresentationContext(

            Context outerContext, Display display, int theme) {

        if (outerContext == null) {

            throw new IllegalArgumentException("outerContext must not be null");

        }

        WindowManager outerWindowManager = (WindowManager) outerContext.getSystemService(WINDOW_SERVICE);

        if (display == null || display.getDisplayId()==outerWindowManager.getDefaultDisplay().getDisplayId()) {

            return outerContext;

        }

        Context displayContext = outerContext.createDisplayContext(display);

        if (theme == 0) {

            TypedValue outValue = new TypedValue();

            displayContext.getTheme().resolveAttribute(

                    android.R.attr.presentationTheme, outValue, true);

            theme = outValue.resourceId;

        }



        // Derive the display's window manager from the outer window manager.

        // We do this because the outer window manager have some extra information

        // such as the parent window, which is important if the presentation uses

        // an application window type.

      //  final WindowManager outerWindowManager =

        //        (WindowManager) outerContext.getSystemService(WINDOW_SERVICE);

     //   final WindowManagerImpl displayWindowManager =

       //         outerWindowManager.createPresentationWindowManager(displayContext);



        WindowManager displayWindowManager = null;

        try {

            ClassLoader classLoader = ComplexPresentationV1.class.getClassLoader();

            Class<?> loadClass = classLoader.loadClass("android.view.WindowManagerImpl");

            Method createPresentationWindowManager = loadClass.getDeclaredMethod("createPresentationWindowManager", Context.class);

            displayWindowManager = (WindowManager) loadClass.cast(createPresentationWindowManager.invoke(outerWindowManager,displayContext));

        } catch (ClassNotFoundException | NoSuchMethodException e) {

            e.printStackTrace();

        } catch (IllegalAccessException e) {

            e.printStackTrace();

        } catch (InvocationTargetException e) {

            e.printStackTrace();

        }

        final WindowManager windowManager = displayWindowManager;

        return new ContextThemeWrapper(displayContext, theme) {

            @Override

            public Object getSystemService(String name) {

                if (WINDOW_SERVICE.equals(name)) {

                    return windowManager;

                }

                return super.getSystemService(name);

            }

        };

    }



    private final DisplayManager.DisplayListener mDisplayListener = new DisplayManager.DisplayListener() {

        @Override

        public void onDisplayAdded(int displayId) {

        }



        @Override

        public void onDisplayRemoved(int displayId) {

            if (displayId == mPresentationDisplay.getDisplayId()) {

                handleDisplayRemoved();

            }

        }



        @Override

        public void onDisplayChanged(int displayId) {

            if (displayId == mPresentationDisplay.getDisplayId()) {

                handleDisplayChanged();

            }

        }

    };



    private final Handler mHandler = new Handler() {

        @Override

        public void handleMessage(Message msg) {

            switch (msg.what) {

                case MSG_CANCEL:

                    cancel();

                    break;

            }

        }

    };

}

方案：Delegate方式：

第一种方案利用反射，但是android 9 开始，很多 @hide 反射不被允许，但是办法也是很多的，比如 freeflection 开源项目，不过对于开发者，能减少对@hide的使用也是为了后续的维护。此外还有一个需要注意的是 Presentation 继承的是 Dialog 构造方法是无法被包外的子类使用，但是影响不大，我们在和Presentation的包名下创建我们的自己的Dialog依然可以解决。不过，对于反射天然厌恶的人来说，可以使用代理。

这种方式借壳 Dialog，套用 Dialog 一层，以代理方式实现，不过相比前一种方案来说，这种方案也有很多缺陷，比如他的onCreate\onShow\onStop\onAttachToWindow\onDetatchFromWindow等方法并没有完全和Dialog同步，需要做下兼容。

兼容

onAttachToWindow\onDetatchFromWindow

WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);

if (display != null && display.getDisplayId() != wm.getDefaultDisplay().getDisplayId()) {

    dialog = new Presentation(context, display, themeResId);

} else {

    dialog = new Dialog(context, themeResId);

}

//下面兼容attach和detatch问题

mDecorView = dialog.getWindow().getDecorView();

mDecorView.addOnAttachStateChangeListener(this);

onShow和\onStop

@Override

public void show() {

    if (!isCreate) {

        onCreate(null);

        isCreate = true;

    }

    dialog.show();

    if (!isStart) {

        onStart();

        isStart = true;

    }

}





@Override

public void dismiss() {

    dialog.dismiss();

    if (isStart) {

        onStop();

        isStart = false;

    }

}

从兼容代码上来看，显然没有做到Dialog那种同步，因此只适合在单一线程中使用。

总结

本篇总结了2种异显屏弹窗，总体上来说，都有一定的瑕疵，但是第一种方案显然要好的多，主要是View更新上和可扩展上，当然第二种对于非多线程且不关注严格回调的需求，也是足以应付，在实际情况中，合适的才是最重要的。

如今市面上APP的输入框可以说是千奇百怪，不搞点花样出来貌似代表格局没打开。还在使用系统自带的输入框的兄弟可以停下脚步，哥带你实现一个简易的带边框输入框。

话不多说，直接上图：

要实现这个效果，不得不再回顾下自定义View的流程，感兴趣的童鞋可以自行网上搜索，这里只提及该效果涉及到的内容。总体实现大致流程：

• 继承AppCompatEditText


• 配置可定义的资源属性


• onDraw() 方法的重写

首先还得分析：效果图中最多只能输入6个数字，需要计算出每个文字的宽高和间隙，再分别绘制文字背景和文字本身。从中我们需要提取背景颜色、高度、边距等私有属性，通过新建attrs.xml文件进行配置：

<declare-styleable name="RoundRectEditText">

    <attr name="count" format="integer"/>

    <attr name="itemPading" format="dimension"/>

    <attr name="strokeHight" format="dimension"/>

    <attr name="strokeColor" format="color"/>/>

</declare-styleable>

这样在初始化的时候即可给你默认值：

val typedArray =context.obtainStyledAttributes(it, R.styleable.RoundRectEditText)

count = typedArray.getInt(R.styleable.RoundRectEditText_count, count)

itemPading = typedArray.getDimension(R.styleable.RoundRectEditText_itemPading,0f)

strokeHight = typedArray.getDimension(R.styleable.RoundRectEditText_strokeHight,0f)

strokeColor = typedArray.getColor(R.styleable.RoundRectEditText_strokeColor,strokeColor)

typedArray.recycle()

接下来便是重头戏，如何绘制文字和背景色。思路其实很简单，通过for循环去遍历绘制每一个数字。关键点还在于去计算每个文字的位置及宽高，只要得到了位置和宽高，绘制背景和绘制文字易如反掌。

获取每个文字宽度：

strokeWith =(width.toFloat() - paddingLeft.toFloat() - paddingRight.toFloat() - (count - 1) * itemPading) / count

文字居中需要计算出对应Y值：

val fontMetrics = paint.fontMetrics

val textHeight = fontMetrics.bottom - fontMetrics.top

val distance = textHeight / 2 - fontMetrics.bottom

val baseline = height / 2f + distance

文字的X值则根据当前index和文字宽度以及各边距得出：

private fun getIndexOfX(index: Int): Float {

    return paddingLeft.toFloat() + index * (itemPading + strokeWith) + 0.5f * strokeWith

}

得到了位置，宽高接下来的步骤再简单不过了。使用drawText 绘制文字，使用drawRoundRect 绘制背景。这里有一个细节一定要注意，绘制背景一定要在绘制文字之前，否则背景会把文字给覆盖。

另外，还需要注意一点。如果onDraw方法中不注释掉超类方法，底部会多出一段输入的数字。其实很好理解，这是AppCompatEditText 自身绘制的数字，所以我们把它注释即可，包括光标也是一样。如果想要光标则需要自己在onDraw方法中绘制即可。

//隐藏自带光标

super.setCursorVisible(false)



override fun onDraw(canvas: Canvas) {

        //不注释掉会显示在最底部

//        super.onDraw(canvas)

          ......

}

以上便是实现带边框的输入框的全部类型，希望对大家有所帮助！

探索EdgeEffect的花样玩法

1、EdgeEffect是什么

当用户在一个可滑动的控件内（如RecyclerView），滑动内容已经超过了内容边界时，RecyclerView通过EdgeEffect绘制一个边界图形来提醒用户，滑动已经到边界了，不要再滑动啦。

简言之：就是通过边界图形来提醒用户，没啥内容了，别滑了。

2、EdgeEffect在RecyclerView的现象是什么

1、到达边界后的阴影效果

在RecyclerView列表中，滑动到边界还继续滑动或者快速滑动到边界，则现象如下图中的到达边界后产生的阴影效果。

2、如何去掉阴影效果

在布局中，可以设置overScrollMode的属性值为never即可。

或者在代码中设置，即可取消

recyclerView?.overScrollMode = View.OVER_SCROLL_NEVER

3、EdgeEffect在RecyclerView的实现原理是什么

1、onMove事件对应EdgeEffect的onPull

EdgeEffect在RecyclerView中大致流程可以参考下面这个图，以onMove事件举例

通过上面这个图，并结合下面的源码，就能对这个流程有个大致的理解。

@Override

public boolean onTouchEvent(MotionEvent e) {

    ...

    switch (action) {

       ...

        case MotionEvent.ACTION_MOVE: {

          ...

          // (1) move事件

                if (scrollByInternal(

                        canScrollHorizontally ? dx : 0,

                        canScrollVertically ? dy : 0,

                        e, TYPE_TOUCH)) {

                    getParent().requestDisallowInterceptTouchEvent(true);

                }

               ...

            }

        }

        break;

     }

 }

 

 

boolean scrollByInternal(int x, int y, MotionEvent ev, int type) {

  ...

     // （2）判断是否设置了过度滑动，所以通过布局设置overScrollMode的属性值为never就走不进了分支逻辑中了

    if (getOverScrollMode() != View.OVER_SCROLL_NEVER) {

        if (ev != null && !MotionEventCompat.isFromSource(ev, InputDevice.SOURCE_MOUSE)) {

            pullGlows(ev.getX(), unconsumedX, ev.getY(), unconsumedY);

        }

        considerReleasingGlowsOnScroll(x, y);

    }

   ...

   

    if (!awakenScrollBars()) {

        // 刷新当前界面

        invalidate();

    }

    return consumedNestedScroll || consumedX != 0 || consumedY != 0;

}



private void pullGlows(float x, float overscrollX, float y, float overscrollY) {

    boolean invalidate = false;

   ...

   // 顶部边界

    if (overscrollY < 0) {

        // 构建顶部边界的EdgeEffect对象

        ensureTopGlow();

        // 调用EdgeEffect的onPull方法 设置些属性

        EdgeEffectCompat.onPull(mTopGlow, -overscrollY / getHeight(), x / getWidth());

        invalidate = true;

    } 

    ...



    if (invalidate || overscrollX != 0 || overscrollY != 0) {

        // 刷新界面

        ViewCompat.postInvalidateOnAnimation(this);

    }

}



void ensureTopGlow() {

   ...

    mTopGlow = mEdgeEffectFactory.createEdgeEffect(this, EdgeEffectFactory.DIRECTION_TOP);

    // 设置边界图形的大小

    if (mClipToPadding) {

        mTopGlow.setSize(getMeasuredWidth() - getPaddingLeft() - getPaddingRight(),

                getMeasuredHeight() - getPaddingTop() - getPaddingBottom());

    } else {

        mTopGlow.setSize(getMeasuredWidth(), getMeasuredHeight());

    }



}



// RecyclerView的绘制

@Override

public void draw(Canvas c) {

    super.draw(c);

    ...

    if (mTopGlow != null && !mTopGlow.isFinished()) {

        final int restore = c.save();

        if (mClipToPadding) {

            c.translate(getPaddingLeft(), getPaddingTop());

        }

        // 调用 EdgeEffect的draw方法

        needsInvalidate |= mTopGlow != null && mTopGlow.draw(c);

        c.restoreToCount(restore);

    }

    ...

}



// EdgeEffect的draw方法

public boolean draw(Canvas canvas) {

   ...

    update();

    final int count = canvas.save();

    final float centerX = mBounds.centerX();

    final float centerY = mBounds.height() - mRadius;

   

    canvas.scale(1.f, Math.min(mGlowScaleY, 1.f) * mBaseGlowScale, centerX, 0);



    final float displacement = Math.max(0, Math.min(mDisplacement, 1.f)) - 0.5f;

    float translateX = mBounds.width() * displacement / 2;



    canvas.clipRect(mBounds);

    canvas.translate(translateX, 0);

    mPaint.setAlpha((int) (0xff * mGlowAlpha));

    // 绘制扇弧

    canvas.drawCircle(centerX, centerY, mRadius, mPaint);

    canvas.restoreToCount(count);

        ...

同理：RecyclerView的 up 及Cancel事件对应调用EdgeEffect的onRelease；fling过度滑动对应EdgeEffect的onAbsorb方法

2、EdgeEffect的onPull、onRelease、onAbsorb方法

（1）onPull

对于RecyclerView列表而言，内容已经在顶部到达边界了，此时用户仍向下滑动时，会调用onPull方法及后续流畅，来更新当前视图，提示用户已经到边界了。

（2）onRelease

对于（1）的情况，用户松开了，不向下滑动了，此时释放拉动的距离，并刷新界面消失当前的图形界面。

（3）onAbsorb

用户过度滑动时，RecyclerView调用Fling方法，把内容到达边界后消耗不掉的距离传递给onAbsorb方法，让其显示图形界面提示用户已到达内容边界。

4、使用EdgeEffect在RecyclerView中实现列表阻尼滑动等效果

（1）先看下效果

上述gif图中展示了两个效果：RecyclerView的阻尼下拉 及 复位，这就是使用上面的EdgeEffect的三个方法可以实现。

上述的gif图中，使用MultiTypeAdapter实现RecyclerView的多类型页面（ViewModel、json数据源），可以参考这篇文章快速写个RecyclerView的多类型页面

下面主要展示如何构建一个EdgeEffect，充分地使用onPull、onRelease及onAbsorb能力

（2）代码示意

// 构建一个自定义的EdgeEffectFactory 并设置给RecyclerView

recyclerView?.edgeEffectFactory = SpringEdgeEffect()



// SpringEdgeEffect

class SpringEdgeEffect : RecyclerView\.EdgeEffectFactory() {



        override fun createEdgeEffect(recyclerView: RecyclerView, direction: Int): EdgeEffect {



            return object : EdgeEffect(recyclerView.context) {



                override fun onPull(deltaDistance: Float) {

                    super.onPull(deltaDistance)

                    handlePull(deltaDistance)

                }



                override fun onPull(deltaDistance: Float, displacement: Float) {

                    super.onPull(deltaDistance, displacement)

                    handlePull(deltaDistance)

                }



                private fun handlePull(deltaDistance: Float) {

                    val sign = if (direction == DIRECTION_BOTTOM) -1 else 1

                    val translationYDelta =

                        sign * recyclerView.width * deltaDistance * 0.8f

                    Log.d("qlli1234-pull", "deltDistance: " + translationYDelta)

                    recyclerView.forEach {

                        if (it.isVisible) {

                        // 设置每个RecyclerView的子item的translationY属性

                            recyclerView.getChildViewHolder(it).itemView.translationY += translationYDelta

                        }

                    }

                }



                override fun onRelease() {

                    super.onRelease()

                    Log.d("qlli1234-onRelease", "onRelease")

                    recyclerView.forEach {

                        //复位

                        val animator = ValueAnimator.ofFloat(recyclerView.getChildViewHolder(it).itemView.translationY, 0f).setDuration(500)

                        animator.interpolator = DecelerateInterpolator(2.0f)

                        animator.addUpdateListener { valueAnimator ->

                            recyclerView.getChildViewHolder(it).itemView.translationY = valueAnimator.animatedValue as Float

                        }

                        animator.start()

                    }

                }



                override fun onAbsorb(velocity: Int) {

                    super.onAbsorb(velocity)

                    val sign = if (direction == DIRECTION_BOTTOM) -1 else 1

                    Log.d("qlli1234-onAbsorb", "onAbsorb")

                    val translationVelocity = sign * velocity * FLING_TRANSLATION_MAGNITUDE

                    recyclerView.forEach {

                        if (it.isVisible) {

                          // 在这个可以做动画

                        }

                    }

                }



                override fun draw(canvas: Canvas?): Boolean {

                    // 设置大小之后，就不会有绘画阴影效果

                    setSize(0, 0)

                    val result =  super.draw(canvas)

                    return result

                }

            }

    }

这里有一个小细节，如何在使用onPull等方法时，去掉绘制的阴影部分：其实，可以重写draw方法，重置大小为0即可，如上述代码中的这一小块内容：

override fun draw(canvas: Canvas?): Boolean {

    // 设置大小之后，就不会有绘画阴影效果

    setSize(0, 0)

    val result =  super.draw(canvas)

    return result

}

5、参考

1、google的motion示例中的ChessAdapter内容

2、仿QQ的recyclerview效果实现

底部弹出菜单是什么

底部弹出菜单，即从app界面底部弹出的一个菜单列表，这种UI形式被众多app所采用，是一种主流的布局方式。

思路分析

我们先分析一下，这样一种UI应该由哪些布局组成？首先在原界面上以一小块区域显示界面的这种形式，很明显就是对话框Dialog做的事情吧！最底部是一个取消菜单，上面的功能菜单可以是一个，也可以是两个、三个甚至更多。所以，我们可以使用RecyclerView实现。需要注意一点的是，最上面那个菜单的样式稍微有点不一样，因为它上面是圆滑的，有圆角，这样的界面显示更加和谐。我们主要考虑的就是弹出对话框的动画样式，另外注意一点就是可以多支持几个语种，让框架更加专业，这里只需要翻译“取消”文字。

开始看代码

package dora.widget



import android.app.Activity

import android.app.Dialog

import android.view.Gravity

import android.view.LayoutInflater

import android.view.View

import android.view.WindowManager

import android.widget.TextView

import androidx.recyclerview.widget.DividerItemDecoration

import androidx.recyclerview.widget.RecyclerView

import com.chad.library.adapter.base.BaseQuickAdapter

import com.chad.library.adapter.base.listener.OnItemChildClickListener

import dora.widget.bean.BottomMenu

import dora.widget.bottomdialog.R



class DoraBottomMenuDialog : View.OnClickListener, OnItemChildClickListener {



    private var bottomDialog: Dialog? = null

    private var listener: OnMenuClickListener? = null



    interface OnMenuClickListener {

        fun onMenuClick(position: Int, menu: String)

    }



    fun setOnMenuClickListener(listener: OnMenuClickListener) : DoraBottomMenuDialog {

        this.listener = listener

        return this

    }



    fun show(activity: Activity, menus: Array<String>): DoraBottomMenuDialog {

        if (bottomDialog == null && !activity.isFinishing) {

            bottomDialog = Dialog(activity, R.style.DoraView_AlertDialog)

            val contentView =

                LayoutInflater.from(activity).inflate(R.layout.dview_dialog_content, null)

            initView(contentView, menus)

            bottomDialog!!.setContentView(contentView)

            bottomDialog!!.setCanceledOnTouchOutside(true)

            bottomDialog!!.setCancelable(true)

            bottomDialog!!.window!!.setGravity(Gravity.BOTTOM)

            bottomDialog!!.window!!.setWindowAnimations(R.style.DoraView_BottomDialog_Animation)

            bottomDialog!!.show()

            val window = bottomDialog!!.window

            window!!.decorView.setPadding(0, 0, 0, 0)

            val lp = window.attributes

            lp.width = WindowManager.LayoutParams.MATCH_PARENT

            lp.height = WindowManager.LayoutParams.WRAP_CONTENT

            window.attributes = lp

        } else {

            bottomDialog!!.show()

        }

        return this

    }



    private fun initView(contentView: View, menus: Array<String>) {

        val recyclerView = contentView.findViewById<RecyclerView>(R.id.dview_recycler_view)

        val adapter = MenuAdapter()

        val list = mutableListOf<BottomMenu>()

        menus.forEachIndexed { index, s ->

            when (index) {

                0 -> {

                    list.add(BottomMenu(s, BottomMenu.TOP_MENU))

                }

                else -> {

                    list.add(BottomMenu(s, BottomMenu.NORMAL_MENU))

                }

            }

        }

        adapter.setList(list)

        recyclerView.adapter = adapter

        val decoration = DividerItemDecoration(contentView.context, DividerItemDecoration.VERTICAL)

        recyclerView.addItemDecoration(decoration)

        adapter.addChildClickViewIds(R.id.tv_menu)

        adapter.setOnItemChildClickListener(this)

        val tvCancel = contentView.findViewById<TextView>(R.id.tv_cancel)

        tvCancel.setOnClickListener(this)

    }



    private fun dismiss() {

        bottomDialog?.dismiss()

        bottomDialog = null

    }



    override fun onClick(v: View) {

        when (v.id) {

            R.id.tv_cancel -> dismiss()

        }

    }



    override fun onItemChildClick(adapter: BaseQuickAdapter<*, *>, view: View, position: Int) {

        listener?.onMenuClick(position, adapter.getItem(position) as String)

        dismiss()

    }

}

类的结构不仅可以继承，还可以使用聚合和组合的方式，我们这里就不直接继承Dialog了，使用一种更接近代理的一种方式。条条大路通罗马，能抓到老鼠的就是好猫。这里的设计是通过调用show方法，传入一个菜单列表的数组来显示菜单，调用dismiss方法来关闭菜单。最后添加一个菜单点击的事件，把点击item的内容和位置暴露给调用方。

package dora.widget



import com.chad.library.adapter.base.BaseMultiItemQuickAdapter

import com.chad.library.adapter.base.viewholder.BaseViewHolder

import dora.widget.bean.BottomMenu

import dora.widget.bottomdialog.R



class MenuAdapter : BaseMultiItemQuickAdapter<BottomMenu, BaseViewHolder>() {



    init {

        addItemType(BottomMenu.NORMAL_MENU, R.layout.dview_item_menu)

        addItemType(BottomMenu.TOP_MENU, R.layout.dview_item_menu_top)

    }



    override fun convert(holder: BaseViewHolder, item: BottomMenu) {

        holder.setText(R.id.tv_menu, item.menu)

    }

}

多类型的列表布局我们采用BRVAH，

implementation("io.github.cymchad:BaseRecyclerViewAdapterHelper:3.0.10")

来区分有圆角和没圆角的item条目。

<?xml version="1.0" encoding="utf-8"?>



<resources>

    <style name="DoraView.AlertDialog" parent="@android:style/Theme.Dialog">

        <!-- 是否启用标题栏 -->

        <item name="android:windowIsFloating">true</item>

        <item name="android:windowIsTranslucent">true</item>

        <item name="android:windowNoTitle">true</item>



        <!-- 是否使用背景半透明 -->

        <item name="android:windowBackground">@android:color/transparent</item>

        <item name="android:background">@android:color/transparent</item>

        <item name="android:backgroundDimEnabled">true</item>

    </style>



    <style name="DoraView.BottomDialog.Animation" parent="Animation.AppCompat.Dialog">

        <item name="android:windowEnterAnimation">@anim/translate_dialog_in</item>

        <item name="android:windowExitAnimation">@anim/translate_dialog_out</item>

    </style>

</resources>

以上是对话框的样式。我们再来看一下进入和退出对话框的动画。

translate_dialog_in.xml

<?xml version="1.0" encoding="utf-8"?>

<translate xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools"

    android:duration="300"

           android:fromXDelta="0"

           android:fromYDelta="100%"

           android:toXDelta="0"

           android:toYDelta="0">

</translate>

translate_dialog_out.xml

<?xml version="1.0" encoding="utf-8"?>

<translate xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools"

    android:duration="300"

           android:fromXDelta="0"

           android:fromYDelta="0"

           android:toXDelta="0"

           android:toYDelta="100%">

</translate>

最后给你们证明一下我是做了语言国际化的。

使用方式

// 打开底部弹窗

val dialog = DoraBottomMenuDialog()

dialog.setOnMenuClickListener(object : DoraBottomMenuDialog.OnMenuClickListener {

    override fun onMenuClick(position: Int, menu: String) {

        val intent = Intent(Intent.ACTION_VIEW)

        intent.data = Uri.parse(url)

        startActivity(intent)

    }

})

dialog.show(this, arrayOf("外部浏览器打开"))

开源项目

github.com/dora4/dview…

大家好，我是时曾相识2022。不喜欢唱跳篮球，但对杰伦的Rap却情有独钟。

今天给大家讲讲酷炫的动画成员——LayoutAnimation。话不多说，直接上一个简单的效果图：

怎么样，和往常自己写的没有动画效果的页面比起来是不是更加酷炫。效果图只展示了从右到左叠加渐变的效果，只要脑洞够大，LayoutAnimation是可以帮你实现各类动画的。接下来就让我们看看LayoutAnimation如何实现这样的效果。

首先，新建一个XML动画文件slide_from_right.xml：

<set xmlns:android="http://schemas.android.com/apk/res/android"

    android:duration="600">

    <translate

        android:fromXDelta="100%p"

        android:interpolator="@android:anim/decelerate_interpolator"

        android:toXDelta="0" />



    <alpha

        android:fromAlpha="0.5"

        android:interpolator="@android:anim/accelerate_decelerate_interpolator"

        android:toAlpha="1" />

</set>

set标签下由translate（移动）和alpha（渐变）动画组成。

其中translate（移动）动画由100%p移动到0。这里需要注意使用的是100%p，其中加这个p是指按父容器的宽度进行百分比计算。插值器就根据自己想要的效果设置，这里使用了一个decelerate_interpolator（减速）插值器。

第二个动画是alpha（渐变）动画，由半透明到不透明，其中插值器是先加速后减速的效果。

接着我们还需要创建一个layoutAnimation，其实也是一个XML文件layout_slid_from_right.xml：

<layoutAnimation xmlns:android="http://schemas.android.com/apk/res/android"

    android:animation="@anim/slide_from_right"

    android:animationOrder="normal"

    android:delay="15%"/>

其中animation指定的就是我们创建的第一个xml文件。animationOrder是指动画执行的顺序模式，包含normal, reverse 和random。normal就是从上到下依次进行，reverse根据名字就知道是反序，random那当然是随机了，我们就使用mormal即可。delay则是每个子视图执行动画的延迟比例，这里需要注意的是这是相对于上个子视图执行动画延时比例。

最后我们只需要在咱们的ViewGr0up中设置layoutAnimation属性即可：

android:layoutAnimation="@anim/layout_slid_from_right"

当然也可在代码中手动设置：

val lin = findViewById<LinearLayout>(R.id.linParent)

val resId = R.anim.layout_slid_from_right

lin.layoutAnimation = AnimationUtils.loadLayoutAnimation(lin.context, resId)

总结：

• layoutAnimation可以使用在任何一个ViewGr0up上


• 在使用set标签做动画叠加的时候一定要注意，set标签内需要添加duration属性，也就是动画时间。如果不加动画是没有效果的。


• 使用移动动画时，在百分比后面添加p的意思是基于父容器宽度进行百分比计算

以上便是LayoutAnimation的简单使用，只要你脑洞大开，各种各样的效果都能玩出来。实现起来也很简单，赶紧在项目中使用起来吧。

hello啊各位老铁，这篇文章我们重新回到Android当中的自定义View，其实最近一直在搞Flutter，初步想法是，把Flutter当中的基础组件先封装一遍，然后接着各个工具类，列表，网络，统统由浅入深的搞一遍，弄完Flutter之后，再逐步的更新Android当中的技术点，回头一想，还是穿插着来吧，再系统的规划，难免也有变化，想到啥就写啥吧，能够坚持输出就行。

今天的这个知识点，是一个自定义View，一个省份的简称键盘，主要用到的地方，比如车牌输入等地方，相对来说还是比较的简单，我们先看下最终的实现效果：

实现方式呢有很多种，我相信大家也有自己的一套实现机制，这里，我采用的是组合View，用的是LinearLayout的方式。

今天的内容大致如下：

1、分析UI，如何布局

2、设置属性和方法，制定可扩展效果

3、部分源码剖析

4、开源地址及实用总结

一、分析UI，如何布局

拿到UI效果图后，其实也没什么好分析的，无非就是两块，顶部的完成按钮和底部的省份简称格子，一开始，打算用RecyclerView网格布局来实现，但是最后的删除按钮如何摆放就成了问题，直接悬浮在网格上边，动态计算位置，显然不太合适，也没有这样去搞的，索性直接抛弃这个方案，多布局的想法也实验过，但最终还是选择了最简单的LinearLayout组合View形式。

所谓简单，就是在省份简称数组的遍历中，不断的给LinearLayout进行追加子View，需要注意的是，本身的View，也就是我们自定义View，继承LinearLayout后，默认的是垂直方向的，往本身View追加的是横向属性的LinearLayout，这也是换行的效果，也就是，一行一个横向的LinearLayout，记住，横向属性的LinearLayout，才是最终添加View的直接父类。

换行的条件就是基于UI效果，当模于设置length等于0时，我们就重新创建一个水平的LinearLayout，这就可以了，是不是非常的简单。

至于最后的删除按钮，使其靠右，占据两个格子的权重设置即可。

二、设置属性和方法，制定可扩展效果

当我们绘制完这个身份简称键盘后，肯定是要给他人用的，基于灵活多变的需求，那么相对应的我们也需要动态的进行配置，比如背景颜色，文字的颜色，大小，还有边距，以及点击效果等等，这些都是需要外露，让使用者选择性使用的，目前所有的属性如下，大家在使用的时候，也可以对照设置。

设置属性

定义方法

三、关键源码剖析

这里只贴出部分的关键性代码，整体的代码，大家滑到底部查看源码地址即可。

定义身份简称数组

    //省份简称数据

    private val mLicensePlateList = arrayListOf(

        "京", "津", "渝", "沪", "冀", "晋", "辽", "吉", "黑", "苏",

        "浙", "皖", "闽", "赣", "鲁", "豫", "鄂", "湘", "粤", "琼",

        "川", "贵", "云", "陕", "甘", "青", "蒙", "桂", "宁", "新",

        "藏", "使", "领", "学", "港", "澳",

    )

遍历省份简称

mLength为一行展示多少个，当取模为0时，就需要换行，也就是再次创建一个水平的LinearLayout，添加至外层的垂直LinearLayout中，每个水平的LinearLayout中，则是一个一个的TextView。

  //每行对应的省份简称

        var layout: LinearLayout? = null

        //遍历车牌号

        mLicensePlateList.forEachIndexed { index, s ->

            if (index % mLength == 0) {

                //重新创建，并添加View

                layout = createLinearLayout()

                layout?.weightSum = 1f

                addView(layout)

                val params = layout?.layoutParams as LayoutParams

                params.apply {

                    topMargin = mRectMarginTop.toInt()

                    height = mRectHeight.toInt()

                    leftMargin = mMarginLeftRight.toInt()

                    rightMargin = mMarginLeftRight.toInt() - mSpacing.toInt()

                    layout?.layoutParams = this

                }

            }



            //创建文字视图

            val textView = TextView(context).apply {

                text = s

                //设置文字的属性

                textSize = px2sp(mRectTextSize)

                //最后五个是否禁止

                if (mNumProhibit && index > (mLicensePlateList.size - 6)) {

                    setTextColor(mNumProhibitColor)

                    mTempTextViewList.add(this)

                } else {

                    setTextColor(mRectTextColor)

                }



                setBackgroundResource(mRectBackGround)

                gravity = Gravity.CENTER

                setOnClickListener {

                    if (mNumProhibit && index > (mLicensePlateList.size - 6)) {

                        return@setOnClickListener

                    }

                    //每个格子的点击事件

                    changeTextViewState(this)

                }

            }



            addRectView(textView, layout, 0.1f)

        }

追加最后一个View

由于最后一个视图是一个图片，占据了两个格子的大小，所以需要特殊处理，需要做的就是，单独设置权重weight和单独设置宽度width，如下所示：

  /**

     * AUTHOR:AbnerMing

     * INTRODUCE:追加最后一个View

     */

    private fun addEndView(layout: LinearLayout?) {

        val endViewLayout = LinearLayout(context)

        endViewLayout.gravity = Gravity.RIGHT

        //删除按钮

        val endView = RelativeLayout(context)

        //添加删除按钮

        val deleteImage = ImageView(context)

        deleteImage.setImageResource(R.drawable.view_ic_key_delete)

        endView.addView(deleteImage)



        val imageParams = deleteImage.layoutParams as RelativeLayout.LayoutParams

        imageParams.addRule(RelativeLayout.CENTER_IN_PARENT)

        deleteImage.layoutParams = imageParams

        endView.setOnClickListener {

            //删除

            mKeyboardDelete?.invoke()

            invalidate()

        }

        endView.setBackgroundResource(mRectBackGround)

        endViewLayout.addView(endView)

        val params = endView.layoutParams as LayoutParams

        params.width = (getScreenWidth() / mLength) * 2 - mMarginLeftRight.toInt()

        params.height = LayoutParams.MATCH_PARENT



        endView.layoutParams = params



        layout?.addView(endViewLayout)

        val endParams = endViewLayout.layoutParams as LayoutParams

        endParams.apply {

            width = (mSpacing * 3).toInt()

            height = LayoutParams.MATCH_PARENT

            weight = 0.4f

            rightMargin = mSpacing.toInt()

            endViewLayout.layoutParams = this

        }





    }

四、开源地址及使用总结

开源地址：github.com/AbnerMing88…

关于使用，其实就是一个类，大家可以下载源码，直接复制即可使用，还可以进行修改里面的代码，非常的方便，如果懒得下载源码，没关系，我也上传到了远程Maven，大家可以按照下面的方式进行使用。

Maven具体调用

1、在你的根项目下的build.gradle文件下，引入maven。

 allprojects {

            repositories {

                maven { url "https://gitee.com/AbnerAndroid/almighty/raw/master" }

            }

        }

2、在你需要使用的Module中build.gradle文件下，引入依赖。

 dependencies {

            implementation 'com.vip:plate:1.0.0'

        }

代码使用

   <com.vip.plate.LicensePlateView

            android:id="@+id/lp_view"

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            app:layout_constraintBottom_toBottomOf="parent"

            app:lp_complete_text_size="14sp"

            app:lp_margin_left_right="10dp"

            app:lp_rect_spacing="6dp"

            app:lp_rect_text_size="19sp"

            app:lp_text_click_effect="false" />

总结

大家在使用的时候，一定对照属性表进行选择性使用；关于这个省份简称自定义View，实现方式有很多种，我目前的这种也不是最优的实现方式，只是自己的一个实现方案，给大家一个作为参考的依据，好了，铁子们，本篇文章就先到这里，希望可以帮助到大家。