注册
环信即时通讯云

环信即时通讯云

单聊、群聊、聊天室...
环信开发文档

环信开发文档

Demo体验

Demo体验

场景Demo,开箱即用
RTE开发者社区

RTE开发者社区

汇聚音视频领域技术干货,分享行业资讯
技术讨论区

技术讨论区

技术交流、答疑
资源下载

资源下载

收集了海量宝藏开发资源
iOS Library

iOS Library

不需要辛辛苦苦的去找轮子, 这里都有
Android Library

Android Library

不需要辛辛苦苦的去找轮子, 这里都有

一位普通前端程序媛转行创业阶段小结

背景介绍 我女朋友的身份从一个「前端开发」转变成「创业者」,所以本篇文章重点突出创业后她的一些思考。 采访者:Gopal。受访者:QPQ。 以下标题均为问题,内容均为回答。 采访开始分割线 创业方向 抖音电商(抖店)。 具体的工作就是:前期确定类目,选货,...
继续阅读 »

背景介绍


我女朋友的身份从一个「前端开发」转变成「创业者」,所以本篇文章重点突出创业后她的一些思考。


采访者:Gopal。受访者:QPQ。


以下标题均为问题,内容均为回答。




采访开始分割线




创业方向


抖音电商(抖店)。


具体的工作就是:前期确定类目,选货,进货(商品+打包袋),做商品链接,上链接卖货,谈物流,打包发货,售后,客服,日常运营等。


创业跟「打工」最大的区别是?


最大的区别就是创业需要自己缴社保,打工公司给缴哈哈哈。


然后目前由于是一个人在创业,所以一切的事物都需要自己做包括选货,进货(商品+打包袋),做商品链接,上链接卖货,打包发货,售后,客服,日常运营等, 也就是自己是自己的老板也是自己的员工。


之前工作呢是前端开发,分工明确做前端开发就好。现在是整条链路都需要自己经手,也是一种不一样的体验。


不过这个得话看个人,我自己是乐在其中,虽然所有纷繁杂乱的事情都得自己做,但很有成就感。另外就是身份上的转变,从之前的技术开发关注功能与交互转变为了现在直接接触用户,跟用户产生利益关系的这么一个身份,一种不太一样的感觉。


创业后的生活节奏?


生活节奏呢有时候忙起来真的可以做到废寝忘食,自从做抖店以来直接从50多公斤降到最低时47,减肥很轻松哈哈哈哈。


不过充实的一天忙完之后是最开心轻松的时刻,一般这个时间段我会用来逛公园,吃自己喜欢的。


但是也时长有流量冷淡,生意冷淡的时候,会比较忧桑和焦虑,尤其是突然从很高的流量和单量降到很低的流量和单量的时候心情会很忧桑,也会很焦虑。


另外处理售后也是门考验人的技术活,有时候碰到一些难搞的售后,难受一整天都不在话下,此处心疼所有的客服小姐姐一秒钟。不过通过售后也能发现一些问题,从开店到现在通过不断调整优化目前已经减少了很大一部分售后问题可喜可贺。


创业有遇到什么困难么?


人货场是硬伤。



  1. 人手问题。有时候生意特别好但是人货场跟不上真的很可惜,浪费了流量。这个真是硬伤目前无法解决,只能后面如果越做越好了有能力雇个助理看看。

  2. 场地和囤货问题。



  • 第一是场地受限放货和找货都很艰难,这是硬伤,只能后面有能力了整个仓库试下。

  • 第二有时候有一些产品卖爆了会再搞一大批,回来后发现并没有那么畅销了,就会存在囤货压力。爆款补货真的不能搞多,饥饿营销也是不错的策略,多了就不香了。

  • 第三目前所在地区域距离货品工厂挺远的,拿货也是一个硬伤,相比在货品工厂附近的店家就很劣势。



  1. 经常性会遇到瓶颈期,如何破局有点难搞。目前也正在经历,也做了很多尝试但暂时所有的尝试都还没有突破瓶颈,还需要不断的学习同行和不断的尝试不同的方式来处理这个问题。


未来计划


期望明年的这个时候能有仓库和员工哈哈哈哈,美丽的愿望。




采访结束分割线




最后,我自己总结一下。


首先,我们是深思熟虑之后才做出来的决定,并不是冲动。



  • 我女朋友一直有创业的想法。

  • 我们还年轻,现阶段负担还没那么大。设想,假如到 30+ 岁,那时候,做出一个选择,可能需要考虑的事情就更多了。也就是试错的代价可能没那么大。

  • 我们两个人,起码保证一人还是有稳定收入的前提下。

  • ...


另外,创业真的很艰难,作为一个「陪跑者」,还是有所体会。


最后一点,我觉得只要我们做的事情不违法,不违反道德,不对他人造成伤害,那你想做就去做吧

作者:Gopal
来源:juejin.cn/post/7123914177168703518
收起阅读 »

程序员如何给变量起名字

程序员如何给变量起名字 在编写代码时,为变量命名是非常重要的。良好的命名习惯可以提高代码的可读性和可维护性,使得其他开发者能够更容易地理解你的代码。在这篇文章中,我们将讨论程序员如何为变量选择合适的名称。 规范 首先,需要了解所用编程语言和项目的命名规范。不同...
继续阅读 »

程序员如何给变量起名字


在编写代码时,为变量命名是非常重要的。良好的命名习惯可以提高代码的可读性和可维护性,使得其他开发者能够更容易地理解你的代码。在这篇文章中,我们将讨论程序员如何为变量选择合适的名称。


规范


首先,需要了解所用编程语言和项目的命名规范。不同的编程语言和团队可能有不同的命名约定。例如,Python 中通常使用下划线分隔单词(snake_case),而 Java 和 JavaScript 则倾向于驼峰式大小写(camelCase)。遵循一致的命名规则会使得整个代码库更具统一性,降低学习成本。


见名知意


一个好的变量名应该尽可能描述它代表的实际含义。换句话说,当其他开发者看到变量名时,他们应该能够猜测出它表示什么以及如何使用。


好例子



  • user_name 代表用户名;

  • password_hash 表示经过哈希处理的密码;

  • email_list 是一个邮件列表。


不好的例子



  • x, y, z 这样的简单字母命名无法反映变量的实际含义(除非在特定场景下,如表示坐标或数学公式中);

  • tempdata 等过于泛化,无法直接理解其用途;

  • string1array2 只提供了数据类型信息,但未说明其用途。


避免冗长


虽然应该让变量名具有描述性,但同时需要避免使用冗长的名称。太长的名称可能会导致代码难以阅读和维护。通常情况下,选择简洁明确的单词组合更为可取。


好例子



  • index

  • user_count


不好的例子



  • the_index_of_the_current_element_in_the_list

  • the_total_number_of_users_in_the_database


使用专业术语


如果你正在编写涉及某个领域知识的代码,可以使用该领域的专业术语作为变量名。这将使得对该领域能较好理解的开发者更容易理解你的代码意图。


好例子



  • 在计算几何领域,变量名 centroid 表示多边形的质心;

  • 在密码学领域,变量名 salt 代表加密时混入的额外值。


处理复数


当变量包含一系列对象时,最好使用复数名称。这样可以让读者知道它是一个集合类型(如列表、数组、集等),而不仅仅包含一个对象。


好例子



  • users

  • files


避免重名和相似命名


为了提高代码的可读性,应尽量避免在同一作用域内使用相似或容易混淆的变量名。


不好的例子



  • user_listusers_list

  • convert_to_stringtransform_to_string


结论


良好的命名习惯对于编写高质量的代码至关重要。请确保你所选择的变量名既简洁明了,又具有描述性,并且遵循项目规范。这将使得其他开发者能够更容易地理解和维护你的代码。


作者:牙叔教程
来源:juejin.cn/post/7225490584058724410
>公众号 牙叔教程

收起阅读 »

移动端旅行网站页面

web
一、布局 1、首页 (1)头部 iconfont的使用和代码优化 iconfont.css中修改路径 引入iconfont.css import text-align: center(文字水平居中) 优化: 变量复用:src/assets/styles/...
继续阅读 »

一、布局


1、首页


(1)头部


iconfont的使用和代码优化



  • iconfont.css中修改路径

  • 引入iconfont.css import


text-align: center(文字水平居中)


优化:


  1. 变量复用:src/assets/styles/varibles.styl中定义变量 $变量名=值。在style中引入样式,@import(样式中引入样式需加@符号)

  2. 路径名过长:在css中引入其他的css想使用@符号,必须在@符号前加上~(@表示src目录)

  3. 路径别名:


build/webpack.base.conf.js->resolve->alias->创建别名


resolve: {
extensions: ['.js', '.vue', '.json'],
alias: {
'vue$': 'vue/dist/vue.esm.js',
'@': resolve('src'),
//创建别名
'styles': resolve('src/assets/styles'),
'common':resolve('src/common')
}
}

报错原因:修改webpack中的内容后需要重启服务器


(2)轮播图


Swiper插件原理


Swiper是一款基于JavaScript的开源滑动插件,可以用于制作各种类型的轮摇图、滑动菜单、图片预览等。Swiper 的原理主要是通过监听用户的手势操作来实现滑动效果,同时利用CSS3动画和过渡效果来实现平滑的过渡和动画效果。



  1. 监听手势操作


Swiper通过监听用户的手势操作来实现滑动效果,具体包括touchstart、touchmove.touchend符事件。在touchstart 事件中,Swiper记录下用户的触摸起始位置及时间,touchmove事件中,Swiper根据用户移动的距离和时间计算出滑动速度和方向,从而控制滑动的行为;touchend事件中,Swiper根据滑动的距离和速度来判断是否进行下一张图片的切换。



  1. 切换图片


Swiper通过获取当前显示的图片索引及方向来计算出下一张图片的索引,并通过CSS3过渡效果来实现平滑的图片切换。同时,Swiper可以支持多种不同的切换效果,包括淡入淡出、渐变、滑动、翻转等,



  1. 响应式设计


Swiper支持响应式设计,可以根据不同的设备尺寸和屏幕方向来自动调整轮播图的大小和样式,从而提供更好的用户体验。同时,Swiper还支持自定义参数配置,可以灵活地控制轮播图的各种属性和行为。


问题


网速慢时图片没有加载出来造成的抖动(使用padding-bottom占位):


overflow: hidden
height:0
padding-bottom: 31.25% //高宽比

显示分页:


<!-- template -->
<swiper :options="swiperOption" v-if="showSwiper">
<!-- slides -->
<!-- 循环实现轮播图 -->
<swiper-slide v-for="item of list" :key="item.id">
<img class="swiper-img" :src="item.imgUrl" alt="">
</swiper-slide>
<!-- 插槽 -->
<div class="swiper-pagination" slot="pagination"></div>
</swiper>

// script
export default {
name: 'HomeSwiper',
props: {
list:Array
},
data() {
return {
swiperOption: {
// 设置显示轮播图分页
pagination: ".swiper-pagination",
//设置轮播图循环展示
loop: true,
// 设置自动轮播及间隔时间
autoplay: 3000
},
}
},
computed: {
// 列表为空时不显示轮播图
showSwiper() {
return this.list.length;
}
}
}

样式穿透



  • >>>

  • /deep/

  • ::v-deep



  1. 引入第三方组件库(如element-ui、element-plus),修改第三方组件库的样式。

  2. 样式文件中使用了 scoped 属性,但是为了确保每个组件之间不存在相互影响所以不能去除


/* style */
.wrapper >>> .swiper-pagination-bullet
background-color: #fff

插槽slot


通过slot插槽将页面中具体的数据传递给swiper组件,希望组件的内容可以被父组件定制的时候,使用slot向组件传递内容。


(3)图标区域


图标的轮播实现


使用computed计算功能实现图标的多页显示(容量为8,多出来的的图标换页显示):


computed: {
pages () {
// 创建二维数组pages
const pages = [];
// 对图标列表使用forEach循环
this.list.forEach((item, index) => {
// 计算页码
const page = Math.floor(index/8);
if (!pages[page]){
pages[page] = []
}
pages[page].push(item)
});
// pages[0]中存储在第一页显示的图标,以此类推
return pages
},
showIcon() {
return this.list.length
}
}

优化:


(1)希望文字过多时有…提示:


css中添加:


overflow: hidden
white-space:nowrap
text-overflow:ellipsis

(2)重复代码封装:


借助stylus提供的mixin对代码进行封装:


src/assets/varibles.styl中定义ellipse方法,在css中@import 文件,直接使用ellipse()


mixin(混入)

它提供了一种非常灵活的方式,来分发 Vue 组件中的可复用功能。


使用场景: 不同组件中经常会用到一些相同或相似的代码,这些代码的功能相对独立。可以通过mixin 将相同或相似的代码提出来。


缺点:



  1. 变量来源不明确

  2. 多 mixin 可能会造成命名冲突(解决方式:Vue 3的组合API)

  3. mixin 和组件出现多对多的关系,使项目复杂度变高。


(4)推荐


text-indent:文字缩进


使用ellipsis()不起作用:父元素添加min-width: 0


(5)周末游


(6)Ajax获取首页数据


安装axios,引入axios


import axios from 'axios'
methods: {
getHomeInfo() {
// 使用axios.get()请求一个URL,返回的对象是一个promise对象,使用.then()获取
axios.get('/api/index.json?city='+this.city)
.then(this.getHomeInfoSucc);
},

getHomeInfoSucc(res) {
res = res.data;
if (res.ret && res.data) {
const data = res.data
// this.city = data.city
this.swiperList = data.swiperList
this.iconList = data.iconList
this.recommendList = data.recommendList
this.weekendList = data.weekendList
}
}
}

转发机制(开发环境的转发)



  • 只有static文件夹下的内容才可以被外部访问到

  • 现在用的是本地模拟的接口地址,假如代码要上线,肯定不能填成这样的一个地址,那么就需要在上线之前把这块儿的东西都重新替换成API这种格式,上线之前去改动代码儿是有风险的

  • 转发机制:webpack-dev-server提供 proxyTable 配置项,config/index.js 中proxyTable


module.exports = {
dev: {
// Paths
assetsSubDirectory: 'static',
assetsPublicPath: '/',
// 请求api目录时将请求转发到当前服务器的8080端口上,但是路径替换为/static/mock
proxyTable: {
'/api':{
target: 'http://localhost:8080',
pathRewrite: {
'^/api': '/static/mock'
}
}
}
}


  • 整个首页发送一个ajax请求而不是每个组件发送一个


(7)首页父子组件数据传递


父->子:属性传值,子组件props:{}接收


轮播图默认显示最后一张图


原因:


还没有接收ajax数据时,swiper接收的数据是一个空数组,当接受ajax数据后, swiperList变成真正的数据项。再传给home-swiper这个组件的时候,它才获取到新的数据,然后重新渲染了新数据对应的很多的幻灯片。因为swiper的初始化创建是根据空数组创建的,所以会导致默认显示的是所有的这个页面中的最后一个页面。


解决:


让swiper的初次创建由完整的数据来创建,而不是由那个空数组来创建。只需要写一个v-if,再写一个list.length。当传递过来的list是个空数组的时候,v-if的值是false,所以swiper不会被创建。只有等真正的数据过来了之后才会被创建。由于模板中尽量少出现逻辑性代码,所以创建一个计算属性computed,计算 list.length。


取消轮播图自动播放:autoplay: false


2、城市选择页


(1)路由配置


路由跳转:


import Vue from 'vue'
import Router from 'vue-router'
import Home from '../pages/home/Home'
import City from '../pages/city/City'
import Detail from '../pages/detail/Detail'

Vue.use(Router)

export default new Router({
routes: [{
path: '/',
name: 'Home',
component: Home
},
{
path: '/city',
name: 'City',
component: City
},
{
// 动态路由
path: '/detail/:id',
name: 'Detail',
component: Detail
}
],
scrollBehavior (to, from, savedPosition) {
return { x: 0, y: 0 }
}
})

使用:


<router-link to="/city">
<div class="header-right">
{{this.city}}
<span class="iconfont arrow-icon">&#xe600;</span>
</div>

</router-link>

(2)搜索框


定义一个keyword数据,与搜索框使用v-model做双向数据绑定。


<div class="search">
<input v-model="keyword" class="search-input" type="text" placeholder="输入城市名或拼音" />
</div>

City.vue父组件向Search.vue组件传值(cities),Search.vue接收cities


使用watch监听keyword的改变(使用节流)


解决匹配城市过多无法滚动问题


import Bscroll,在mounted中创建一个BScroll, this.scroll = new BScroll(this.$refs.search),通过$ref获取需要滚动的元素。


<!--搜索结果显示框-->
<div class="search-content" ref="search" v-show="keyword">
<ul>
<!--解决删除输入列表依然存在的问题-->
<li class="search-item border-bottom" v-for="item in list" :key="item.id" @click="handleCityClick(item.name)">{{item.name}}</li>
<li class="search-item border-bottom" v-show="hasNoData">没有找到匹配数据</li>
</ul>
</div>

优化


1.解决删除输入列表依然存在的问题:v-show = "keyword"

2.没有找到匹配项时,显示“没有找到匹配数据”:v-show = "!this.list.length"

双向数据绑定原理(搜索时使用)




  • 概念:

    Vue 中双向绑定是一个指令v-model,可以绑定一个响应式数据到视图,同时视图的变化能改变该值。v-model是语法糖,默认情况下相当于:value@inputv-bind:valuev-on:input),使用v-model可以减少大量繁琐的事件处理代码,提高开发效率。




  • 使用:

    通常在表单项上使用v-model,还可以在自定义组件上使用,表示某个值的输入和输出控制。




  • 原理:

    v-model是一个指令,双向绑定实际上是Vue 的编译器完成的,通过输出包含v-model模版的组件渲染函数,实际上还是value属性的绑定及input事件监听,事件回调函数中会做相应变量的更新操作。




(3)列表


引入区块滚动


子元素使用float,父元素开启BFC(overflow:hidden)去除高度塌陷。


使列表区域无法滚动(position:absolute + overflow:hidden),然后使用better-scroll插件


better-scroll



  • 安装better-scroll包。

  • 需要 better-scroll 包裹的所有元素最外层需要使用一个div包裹,并设置一个ref属性方便创建scroll。

  • 创建scroll


<div class="list" ref="wrapper">list中的元素<div>

import Bscroll from 'better-scroll'
// 写在mounted钩子函数中,此时页面挂载完成,可以操作DOM元素。
mounted() {
this.scroll = new Bscroll(this.$refs.wrapper)
}

$ref


ref属性:获取DOM。


在vue中ref可以以属性的形式添加给标签或者组件:



  • ref 写在标签上时:this.$refs.ipt 获取的是添加了ref="ipt"标签对应的dom元素;

  • ref 写在组件上时:this.$refs['component'] 获取到的是添加了ref="component"属性的这个组件。


$refs 是所有注册过 ref 的集合(对象);若是遍历的ref,则对应$refs是个数组集合


注意:$refs不是响应式的,只在组件渲染完成之后才填充。所以想要获取DOM数据的更新要使用 this.$nextTick()


字母表和城市列表字母的联动


兄弟组件传值:


Alphabet组件将值传递给父组件City.vue,父组件将值传递给子组件List.vue实现字母表和城市列表字母的联动。


为每个字母绑定一个onclick事件,在方法中使用this.$emit向外传递change事件。


<!--Alphabet.vue-->
<template>
<ul class="list" >
<li class="item" v-for="key in letters"
:key="key"
:ref="key"
@touchstart="handleTouchStart"
@touchmove="handleTouchMove"
@touchend="handleTouchEnd"
@click="handleLetterClick"
>

{{key}}
</li>
</ul>
</template>


// Alphabet.vue
methods: {
handleLetterClick (e) {
// 向外(City.vue)传递事件
this.$emit("change", e.target.innerText);
}
}

父组件


<!--City.vue-->
<city-alphabet :cities="cities" @change="handleLetterChange"></city-alphabet>

// City.vue
data () {
return {
letter: '' // 被点击的字母
}
},
methods: {
handleLetterChange (letter) {
this.letter = letter;
// console.log(letter);
}
}

<!-- 向List组件传值letter -->
<city-list :cities="cities" :hot="hotCities" :letter="letter"></city-list>

// List.vue接收letter
props: {
hot: Array,
cities: Object,
letter: String
},

使用watch监听letter变化,当letter发生变化时,调用this.scroll.scrollToElement()方法将区域自动滚动到指定区域,在template中给每一个area区域加一个:ref='key',通过this.$refs[this.letter][0]获取值为this.letter的DOM元素。


<div class="area" v-for="(item, key) in cities" :key="key" :ref="key" >
<div class="title border-topbottom">{{ key }}</div>
<div class="item-list">
<div class="item border-bottom" v-for="innerItem in item" :key="innerItem.id" @click="handleCityClick(innerItem.name)">{{innerItem.name}}</div>
</div>
</div>

watch: {
letter () {
if (this.letter) {
// 获取值为`this.letter`的DOM元素
const element = this.$refs[this.letter][0]
// 将区域自动滚动到指定区域
this.scroll.scrollToElement(element)
}
}
}

上下拖拽字母表touch

为字母表绑定三个事件:


@touchstart="handleTouchStart"  //手指开始触摸时设置this.touchStatus = true
@touchmove="handleTouchMove" //在true时对触摸事件做处理
@touchend="handleTouchEnd" //手指结束触摸时设置this.touchStatus = false

// 构建字母数组
computed: {
// 构建字母数组["A", "B", ……, "Z"]
letters () {
const letters = [];
for (let i in this.cities){
letters.push(i);
}
return letters;
}
},
methods: {
handleLetterClick (e) {
// 向外(City.vue)传递事件
this.$emit("change", e.target.innerText);

},
handleTouchStart () {
this.torchStatus = true;
},
handleTouchMove (e) {
if (this.torchStatus) {
// 如果timer已经存在,去除timmer(即上一次的事件还未执行完毕又出发了下一次事件,就用下一次事件覆盖上一次的事件)
if (this.timer){
clearTimeout(this.timer)
}
// 否则就创建一个timer
//节流,将操作延迟16ms执行,如果上一个操作间隔小于16ms,则清除上一个操作,直接执行这次操作,减少handleTouchMove的使用频率
this.timer = setTimeout(() => {
const touchY = e.touches[0].clientY - 79; // 当前手指触摸位置与头部下沿的距离,79px为头部的高度
const index = Math.floor((touchY - this.startY) / 20); //当前手指触摸位置的元素
// 合法时向父元素emit change事件
if (index >= 0 && index < this.letters.length){
this.$emit('change', this.letters[index]);
}
}, 16)

}
},
handleTouchEnd () {
this.torchStatus = false
}
}

优化

1、将字母A到头部下沿的距离的计算放在updated生命周期钩子函数中


初始时cities值为0,当Ajax获取数据后,cities的值才发生变化,AlphaBet才被渲染出来, 当往alphabet里面传的数据发生变化的时候,alphabet这个组件儿就会重新渲染。之后,updated这个生命周期钩子就会被执行。这个时候,页面上已经展示出了城市字母列表里所有的内容,去获取A这个字母所在的dom对应的offsettop的值就没有任何的问题了。


2、节流


如果timer已经存在,去除timmer(即上一次的事件还未执行完毕又出发了下一次事件,就用下一次事件覆盖上一次的事件)。


否则就创建一个timer,将操作延迟16ms执行,如果上一个操作间隔小于16ms,则清除上一个操作,直接执行这次操作,减少handleTouchMove的使用频率。


3、使用Vuex实现首页和城市选择页面的数据共享



  1. 安装vuex

  2. 创建src/store/index.js文件


import Vue from 'vue'
import Vuex from 'vuex'
import state from './state'
import mutations from './mutations'

Vue.use(Vuex)

export default new Vuex.Store({
state,
// actions: {
// changeCity (ctx, city) {
// ctx.commit('changeCity', city)
// }
// },
mutations
})


  1. main.js中引入store


import store from './store'


  1. 在mainjs中创建根实例时将store传入,store会被派发到每个子组件中,每个子组件中都可以使用this.$store获取到 store。


new Vue({
el: '#app',
router,
store,
components: { App },
template: '<App/>'
})

(1)Vuex


概念


Vuex 是 Vue 专用的状态管理库,它以全局方式集中管理应用的状态,并以相应的规则保证状态以一种可预测的方式发生变化。主要解决的问题是多组件之间状态共享。


image.png


核心概念



  • State:存放核心数据

  • Action:异步方法

  • Mutation:同步的对数据的改变

  • Getter:类似于计算属性,提供新的数据,避免数据的冗余

  • Module:模块化,拆分


image.png


项目中Vuex的使用



  • state存放当前城市CurCity

  • 为每个城市元素都绑定一个onclick事件(获取改变的city),点击城市

  • 在List组件中调用dispatch方法->触发Action

  • 在store/index.js中增加一个actions对象(接收city),使用commit调用mutation

  • mutations中,令state.city = city,完成


// List.vue
this.$store.dispatch('changeCity', city)

// store/index.js
actions: {
changeCity (ctx, city) {
// 使用Commit调用Mutation
ctx.commit('changeCity', city)
}

},
mutations: {
changeCity (state, city) {
state.city = city;
try {
localStorage.city = city
} catch (e) {}
}
}

image.png


(2)单页面与多页面


实现单页面跳转的方式



  1. 标签实现



  • a标签

  • router-link标签


<a href="#/xxx" />
<router-link to="/xxx" />


  1. 函数实现



  • 传统的window.location.href

  • 使用vue-router中的router对象 (点击城市后自动跳转到首页)
    step1 定义一个实现onclik事件的组件


<a onClick={this.goTo} />

step2 在goTo函数中实现跳转


goTo = () => {
// 方案1 传统的window.location.href
window.location.href = "#/xxx"

// 方案2 使用vue-router中的router对象
this.$router.push('/');
}

项目中,点击城市后跳转到首页:this.$router.push


methods: {
handleCityClick (city) {
this.$router.push('/');
}
},

(3)localStorage(state和mutations中使用)


//state.js
let defaultCity = "上海"
try {
if (localStorage.city){
defaultCity = localStorage.city
}
}catch (e) {}

export default{
city: defaultCity
}

// mutation.js
export default{
changeCity (state, city) {
state.city = city;
try {
localStorage.city = city
} catch (e) {}

}
}

(4)keep-alive优化网页性能


每次切换回组件时,组件就会被重新渲染,mounted生命周期钩子就会被重新执行,ajax数据就会被重新获取,导致性能低。


<!-- App.vue -->
<keep-alive>
<router-view/>
</keep-alive>

使用keep-alive后会多出两个生命周期钩子函数activated和deactivated
activated在每次切换回组件时调用,因此可以在activated中定义方法,在城市切换时重新发送ajax请求。


4、景点详情页


(1)动态路由及banner分支


为recommend组件的li标签外部包裹一个router-link标签,li标签样式改变,解决方式:


将li标签直接替换为router-link标签, 加入一个tag=“li”的属性,动态绑定::to = "'/detail/' + item.id",在router/index.js设置Detail路由


<!-- recommend.vue -->
<router-link tag="li"
class="item border-bottom"
v-for="item in list"
:key="item.id"
:to="'/detail/' + item.id">

</router-link>

// router/index.js
{
path: '/detail/:id',
name: 'Detail',
component: Detail
}

图片底部渐变效果:


background-image: linear-gradient(top, rgba(0, 0, 0, 0), rgba(0, 0, 0, 0.8))

(2)公用图片画廊组件拆分


将画廊组件变成一个公用组件src/common/gallary/Gallary.vue


画廊组件:图片轮播+页码显示


使用swiper插件实现轮播功能,使用swiper插件的 paginationType: 'fraction',将分页器样式设置为页码。

‘bullets’  圆点(默认)
‘fraction’  分式 
‘progress’  进度条
custom’ 自定义

创建路径别名,重启服务器。


一开始将gallary显示为隐藏状态,再次显示时计算宽度出现问题,swiper无法正确显示,解决:


data () {
return {
showGallary: true,
swiperOptions: {
pagination: '.swiper-pagination',

// 将分页器样式设置为页码
paginationType: 'fraction',

// swiper监听到此元素或父级元素发生DOM变化时,就会自动刷新一次,解决宽度计算问题。
observeParents:true,
observer:true,

loop:true,
autoplay: false
}
}
}

(3)实现header渐隐渐现效果


methods: {
handleScroll () {
// 获取当前页面的滚动条纵坐标位置
const top = document.documentElement.scrollTop;
// top > 60 时开始逐渐显示header,top > 40 时一直显示header
if (top > 60){
const opacity = top / 140;
opacity > 1 ? 1 : opacity;
this.opacityStyle = {
opacity
};
this.showAbs = false;
}
else{
this.showAbs = true
}
}
},
activated () {
window.addEventListener('scroll', this.handleScroll)
},


(4)对全局事件的解绑(window对象)


// 页面即将被隐藏时执行
deactivated () {
window.removeEventListener('scroll', this.handleScroll)
}

(5)使用递归组件实现详情页列表


(6)使用Ajax获取动态数据


获得动态路由参数(id)并将其传递给后端、


getDetailInfo () {
axios.get('/api/detail.json',{
params: {
id: this.lastRouteId
}
}).then(this.handleGetDetailInfoSucc)
}

(7)组件跳转时页面定位


scrollBehavior (to, from, savedPosition) {
return { x: 0, y: 0 }
}

(8)在项目中加入基础动画


在点击画廊组件时增加渐隐渐现的动画效果


//FadeAnimation.vue

<template>
<transition>
<slot></slot>
</transition>
</template>
<script>
export default{
name: "FadeAnimation"
}
</script>
<style lang="stylus" scoped>
@import '~styles/varibles.styl'
.v-enter, .v-leave-to
opacity: 0
.v-enter-active, .v-leave-active
transition: opacity .5s
</style>

common-gallary 作为插槽插入到fade-animation中:


<!--Banner.vue-->

<fade-animation>
<common-gallary
:imgs="bannerImgs"
v-show="showGallary"
@close="handleGallaryClose"
>

</common-gallary>
</fade-animation>

二、优化



  • 网速慢时图片没有加载出来造成的抖动(使用padding-bottom占位)

  • 重复代码封装:借助stylus提供的mixin对代码进行封装

  • 节流:触摸滑动字母表&搜索框中输入

  • keep-alive

  • 对全局事件解绑


作者:树上结了个小橙子
来源:juejin.cn/post/7222627262399365180
收起阅读 »

快看一看,你是不是这样使用的vscode

web
俗话说:“工欲善其事,必先利其器”。想要高效的编写代码,自然要先熟练的使用一款工具。 vscode设置简体中文 使用国外的工具,头等大事自然是必不可少的汉化。 按快捷键 ‘ctrl+shift+p’,在顶部出现的输入框输入‘configure language...
继续阅读 »

俗话说:“工欲善其事,必先利其器”。想要高效的编写代码,自然要先熟练的使用一款工具。


vscode设置简体中文


使用国外的工具,头等大事自然是必不可少的汉化。


按快捷键 ‘ctrl+shift+p’,在顶部出现的输入框输入‘configure language’,按回车,选择‘zh-cn’。此时,会自动安装中文插件,然后重新打开vscode就可以看到中文界面了。

image.png


vscode实用插件


选择vscode的原因,除了它的轻量之外,自然少不了它丰富的插件库。


1. Auto Rename Tag


自动修改匹配的html标签。在修改标签的时候,是不是需要修改完开始标签之后还需要修改结束标签。安装Auto Rename Tag,以后只需要修改一个标签就可以了,四舍五入就等于减少一半工作量啊。


2. Prettier


代码格式化插件,一键格式化代码,也可以设置保存自动格式化。我会将我的配置放在文章末尾。


3. code runner


可以直接js文件,在控制台输出结果。在写一些小算法的时候再也不用频繁刷新页面打印了。


image.png


4. Turbo Console Log


快捷添加 console.log,一键 注释、启用、删除 所有 console.log。调试js时候大概都会用console.log,每次手敲都很麻烦。


ctrl + alt + l 选中变量之后,生成 console.log
alt + shift + c 注释所有 console.log
alt + shift + u 启用所有 console.log
alt + shift + d 删除所有 console.log

注意,只能注释、启用、删除ctrl + alt + l生成的console.log。如果有小伙伴安装了印象笔记,ctrl + alt + l和印象笔记是冲突的。


5. css-auto-prefix


自动添加 CSS 私有前缀。
比如写完transform样式,会自动添加-webkit-、-moz-等样式。


配置


接下来便是无处不在的配置了,将我的配置贴出来,供大家参考。


文件->首选项->设置->工作台->设置编辑器,将editor的ui改为json,将配置直接粘贴进去


{
"eslint.enable": true,
"eslint.run": "onType",
"eslint.options": {
"extensions": [
".js",
".vue",
".jsx",
".tsx"
]
},
"editor.codeActionsOnSave": {
"source.fixAll.eslint": true
},
"workbench.iconTheme": "material-icon-theme",
"workbench.colorTheme": "Monokai",
"[vue]": {
"editor.defaultFormatter": "esbenp.prettier-vscode"
},
"[json]": {
"editor.defaultFormatter": "esbenp.prettier-vscode"
},
"workbench.settings.editor": "json",
"editor.tabSize": 2,
//失去焦点后自动保存
"files.autoSave": "onFocusChange",
// #值设置为true时,每次保存的时候自动格式化;
"editor.formatOnSave": true,
// 在使用搜索功能时,将这些文件夹/文件排除在外
"search.exclude": {
"**/node_modules": true,
"**/bower_components": true,
"**/target": true,
"**/logs": true,
},
// #让vue中的js按"prettier"格式进行格式化
"vetur.format.defaultFormatter.html": "js-beautify-html",
"vetur.format.defaultFormatter.js": "prettier",
"vetur.format.defaultFormatterOptions": {
"js-beautify-html": {
// #vue组件中html代码格式化样式
"wrap_attributes": "force-aligned", //也可以设置为“auto”,效果会不一样
"wrap_line_length": 200,
"end_with_newline": false,
"semi": false,
"singleQuote": true
},
"prettier": {
"semi": false,
"singleQuote": true
}
},
"[jsonc]": {
"editor.defaultFormatter": "vscode.json-language-features"
}
}

快捷键


熟练的时候快捷键,可以更高效的提升敲代码的效率。我将我常用的快捷键列出,供大家参考。


ctrl + d 选中一个词 鼠标双击也可以
ctrl + f 搜索
ctrl + p 快速打开文件
ctrl + shift + [ 折叠区域代码
ctrl + shift + ] 展开区域代码
ctrl + shift + k 删除一行代码,不过我更喜欢用ctrl+x,因为一只手就可以操作

作者:前端手记
来源:juejin.cn/post/7226248402799345719
收起阅读 »

手写一个类似博客的个人主页 css动画效果多

web
手写一个好看的个人主页 效果图 文字,图片加上各种动画显示,使页面更加美观。然后给头像也加上了一个动画,使头像实现一个一直在上下浮动的效果。媒体组件logo,添加事件hover,置顶会变颜色。按钮添加active激活样式。 最好打开码上掘金看效果图,更明显,...
继续阅读 »

手写一个好看的个人主页


效果图


文字,图片加上各种动画显示,使页面更加美观。然后给头像也加上了一个动画,使头像实现一个一直在上下浮动的效果。媒体组件logo,添加事件hover,置顶会变颜色。按钮添加active激活样式。
image.png
最好打开码上掘金看效果图,更明显,因为显示框问题,这样看布局有点问题。


整体布局


头部


包含一个logo,和一个 导航栏。
logo我这里用了一段文字替代,大家可以自己替换。
header都处于同一行,于是我采用了弹性布局。因为一个左一个右,就可以使用justify-content: space-between;然后logo我给它设置了一个从左往右的动画,时间为1s。导航栏添加了一个从上往下的动画,不过注意的是,我们可以看到每一个导航栏元素是递进往上升的。


实现导航栏元素递进往上升的关键。<a href="#" class="item" style="--i:1">Home</a>我们给每个导航元素都添加了css属性,然后通过这个属性, calc(.2S * var(--i)) 计算每个不同元素的延迟时间,这样我们就可以看到这种延迟效果。
image.png


.header {
position: fixed;
/* 将导航栏固定在页面顶部 */
top: 0;
left: 0;
width: 100%;
padding: 20px 10%;
/* 设置导航栏内边距 */
background: transparent;
/* 设置导航栏背景为透明 */
display: flex;
/* 将导航栏的子元素设置为flex布局 */
justify-content: space-between;
/* 将导航栏子元素分散对齐 */
align-items: center;
/* 将导航栏子元素垂直居中对齐 */
z-index: 100;
/* 将导航栏设置为最上层 */
}

/* 设置导航栏Logo的样式 */
.logo {
font-size: 25px;
/* 设置字体大小 */
color: #fff;
/* 设置字体颜色 */
text-decoration: none;
/* 取消下划线 */
font-weight: 600;
/* 设置字体粗细 */
cursor: default;
/* 设置鼠标样式为默认 */
opacity: 0;
/* 设置初始透明度为0 */
animation: slideRight 1s ease forwards;
/* 设置动画效果 */
}

/* 设置导航栏链接的样式 */
.navbar a {
display: inline-block;
/* 将链接设置为块级元素 */
font-size: 18px;
/* 设置字体大小 */
color: #fff;
/* 设置字体颜色 */
text-decoration: none;
/* 取消下划线 */
font-weight: 500;
/* 设置字体粗细 */
margin-left: 35px;
/* 设置左侧间距 */
opacity: 0;
/* 设置初始透明度为0 */
transition: 0.3s;
/* 设置过渡效果 */
animation: slideTop 1s ease forwards;
/* 设置动画效果 */
animation-delay: calc(.2S * var(--i));
/* 设置动画延迟时间 */
}

/* 设置导航栏链接的鼠标悬停和点击样式 */
.navbar a:hover,
.navbar a:active {
color: #b7b2a9;
/* 设置字体颜色 */
}


<header class="header">
<!-- 网站Logo -->
<a href="#" class="logo">
This is a Logo!
</a>

<!-- 导航栏 -->
<nav class="navbar">
<!-- 导航栏选项1 -->
<a href="#" class="item" style="--i:1">Home</a>
<!-- 导航栏选项2 -->
<a href="#" class="item" style="--i:2">About</a>
<!-- 导航栏选项3 -->
<a href="#" class="item" style="--i:3">Skills</a>
<!-- 导航栏选项4 -->
<a href="#" class="item" style="--i:4">Me</a>
</nav>

</header>

主页部分


主页部分包含文字区域和头像区域。


在文字区域里有一个打印机效果输出文字,可以看我上一篇文章。html手写一个打印机效果-从最基础到学会。然后给每个文字设置不同的动画,比如第一个h1我们让它从上往下,然后第二个h1我们让它从下往上,在他们中间的h1我们让它从左向右出现。在文字区域还有一块是一些media的组件logo,这个我是通过一个js引入的库。然后这些logo跟导航栏元素大致相同,我们也给他们定义了一个css属性,可以让他们相继出现。然后按钮也是添加向上的动画,给定一个延迟时间。


头像区域,我们给头像设置了两个动画,其实动画非常简单,一个其实就是为了显示头像,另一个实现头像上下浮动的效果。


 /* 定义放大的动画 */
@keyframes zoomIn {
0% {
transform: scale(0);
}

100% {
transform: scale(1);
opacity: 1;
}
}

/* 定义图片浮动的动画 */
@keyframes floatImg {
0% {
transform: translateY(0);
}

50% {
transform: translateY(-36px);
}

100% {
transform: translateY(0);
}
}

<link rel="stylesheet" href="https://unpkg.com/boxicons@2.1.4/css/boxicons.min.css">

 <!-- 主页部分 -->

<section class="home">
<!-- 主页内容 -->
<div class="home-content">
<!-- 主页标题 -->
<h3>Hello,It's Me</h3>
<h1>Welcome To Know Me!</h1>
<!-- 主页小标题 -->
<h3>个人介绍
<!-- 小标题下的文本 -->
<span class="text">
</span>
</h3>
<!-- 主页正文 -->
<p>越努力,越幸运!!!Lucky!</p>
<!-- 社交媒体链接 -->
<div class="social-media">
<!-- 社交媒体链接1 -->
<a href="#" style="--i:7"><i class="bx bxl-tiktok"></i></a>
<!-- 社交媒体链接2 -->
<a href="#" style="--i:8"><i class="bx bxl-facebook-circle"></i></a>
<!-- 社交媒体链接3 -->
<a href="#" style="--i:9"><i class="bx bxl-google"></i></a>
<!-- 社交媒体链接4 -->
<a href="#" style="--i:10"><i class="bx bxl-linkedin-square"></i></a>
</div>
<!-- 主页按钮 -->
<a href="#" class="btn">Learn More</a>
</div>
<!-- 主页图片 -->
<div class="home-img">
<img src="https://img.wxcha.com/m00/54/ed/69d26be4a4ac700e27c2d9cf85472b8c.jpg" alt="">
</div>
</section>

整体代码


动画的代码


  /*动画*/
@keyframes blink {

from,
to {
border-color: transparent;
/* 透明边框颜色 */
}

50% {
border-color: white;
/* 白色边框颜色 */
}
}

/* 定义向右滑动的动画 */
@keyframes slideRight {
0% {
transform: translateX(-100px);
}

100% {
transform: translateX(0px);
opacity: 1;
}
}

/* 定义向左滑动的动画 */
@keyframes slideLeft {
0% {
transform: translateX(100px);
}

100% {
transform: translateX(0px);
opacity: 1;
}
}

/* 定义向上滑动的动画 */
@keyframes slideTop {
0% {
transform: translateY(100px);
}

100% {
transform: translateY(0px);
opacity: 1;
}
}

/* 定义向下滑动的动画 */
@keyframes slideBottom {
0% {
transform: translateY(-100px);
}

100% {
transform: translateY(0px);
opacity: 1;
}
}

/* 定义放大的动画 */
@keyframes zoomIn {
0% {
transform: scale(0);
}

100% {
transform: scale(1);
opacity: 1;
}
}

/* 定义图片浮动的动画 */
@keyframes floatImg {
0% {
transform: translateY(0);
}

50% {
transform: translateY(-36px);
}

100% {
transform: translateY(0);
}
}

源码


链接自取
掘金/个人页面 · Mr-W-Y-P/Html-css-js-demo - 码云 - 开源中国 (gitee.com)


作者:Mr-Wang-Y-P
来源:juejin.cn/post/7225444782331592764
收起阅读 »

Android - 统一依赖管理(config.gradle)

介绍 Android 依赖统一管理距目前为止,博主一共知道有三种方法,分别是: 传统apply from的方式(也是本文想讲的一种方式):新建一个 「config.gradle」 文件,然后将项目中所有依赖写在里面,更新只需修改 「config.gradl...
继续阅读 »
646286.webp

介绍


Android 依赖统一管理距目前为止,博主一共知道有三种方法,分别是:




  1. 传统apply from的方式(也是本文想讲的一种方式):新建一个 「config.gradle」 文件,然后将项目中所有依赖写在里面,更新只需修改 「config.gradle」 文件内容,作用于所有module。

  2. buildSrc 方式:当运行 Gradle 时会检查项目中是否存在一个名为 buildSrc 的目录。然后 Gradle 会自动编译并测试这段代码,并将其放入构建脚本的类路径中, 对于多项目构建,只能有一个 buildSrc 目录,该目录必须位于根项目目录中, buildSrc 是 Gradle 项目根目录下的一个目录。

  3. Composing builds 方式:复合构建只是包含其他构建的构建. 在许多方面,复合构建类似于 Gradle 多项目构建,不同之处在于,它包括完整的 builds ,而不是包含单个 projects,总的来说,他有 buildSrc 方式的优点,同时更新不需要重新构建整个项目。



三种方式各有各的好,目前最完美的应该是第三种实现。但是这种方式不利于框架使用,因为它属于的是新建一个module,如果项目远程依赖了框架,默认也包含了这个 module。所以博主选择了第一种方式。以下文章也是围绕第一种方式进行讲解。


实现方式


实现这个统一依赖管理,拢共分三步,分别是:




  • 第一步:创建「config.gradle」 文件

  • 第二步:项目当中引入「config.gradle」

  • 第三步:在所有module的「build.gradle」当中添加依赖





  • 第一步:创建 「config.gradle」 文件


    首先将 Aandroid Studio 目录的Android格式修改为Project,然后再创建一个「config.gradle」的文件


    1681962514751.jpg


    然后我们编辑文章里面的内容,这里直接给出框架的代码出来(篇幅太长,省略部分代码):


    ext {
    /**
    * 基础配置 对应 build.gradle 当中 android 括号里面的值
    */

    android = [
    compileSdk : 32,
    minSdk : 21,
    targetSdk : 32,
    versionCode : 1,
    versionName : "1.0.0",
    testInstrumentationRunner: "androidx.test.runner.AndroidJUnitRunner",
    consumerProguardFiles : "consumer-rules.pro"

    ......
    ]

    /**
    * 版本号 包含每一个依赖的版本号,仅仅作用于下面的 dependencies
    */

    version = [
    coreKtx : "1.7.0",
    appcompat : "1.6.1",
    material : "1.8.0",
    constraintLayout : "2.1.3",
    navigationFragmentKtx: "2.3.5",
    navigationUiKtx : "2.3.5",
    junit : "4.13.2",
    testJunit : "1.1.5",
    espresso : "3.4.0",

    ......
    ]

    /**
    * 项目依赖 可根据项目增加删除,但是可不删除本文件里的,在 build.gradle 不写依赖即可
    * 因为MVP框架默认依赖的也在次文件中,建议只添加,不要删除
    */

    dependencies = [

    coreKtx : "androidx.core:core-ktx:$version.coreKtx",
    appcompat : "androidx.appcompat:appcompat:$version.appcompat",
    material : "com.google.android.material:material:$version.material",
    constraintLayout : "androidx.constraintlayout:constraintlayout:$version.constraintLayout",
    navigationFragmentKtx : "androidx.navigation:navigation-fragment-ktx:$version.navigationFragmentKtx",
    navigationUiKtx : "androidx.navigation:navigation-ui-ktx:$version.navigationUiKtx",
    junit : "junit:junit:$version.junit",
    testJunit : "androidx.test.ext:junit:$version.testJunit",
    espresso : "androidx.test.espresso:espresso-core:$version.espresso",

    ......
    ]
    }

    简单理解就是将所有的依赖,分成版本号以及依赖名两个数组的方式保存,所有都在这个文件统一管管理。用 ext 包裹三个数组:第一个是「build.gradle」Android 里面的,第二个是版本号,第三个是依赖的名字。依赖名字数组里面的依赖版本号通过 $ 关键字指代 version 数组里面的版本号




  • 第二步:项目当中引入 「config.gradle」


    将「config.gradle」文件引入项目当中,在项目的根目录的「build.gradle」文件(也就是刚刚新建的 「config.gradle」同目录下的),添加如下代码:


    apply from:"config.gradle"

    需要注意的的是,如果你是 AndroidStudio 4.0+ 那么你将看到这样的「build.gradle」文件


    // Top-level build file where you can add configuration options common to all sub-projects/modules.
    plugins {
    id 'com.android.application' version '7.2.2' apply false
    id 'com.android.library' version '7.2.2' apply false
    id 'org.jetbrains.kotlin.android' version '1.7.10' apply false
    }

    apply from:"config.gradle"

    相反,如果你是 AndroidStudio 4.0- 那么你将会看到这样的「build.gradle」文件



    apply from: "config.gradle"

    buildscript {
    ext.kotlin_version="1.7.10"
    repositories {
    maven { url "https://jitpack.io" }
    mavenCentral()
    google()
    }
    dependencies {
    classpath "com.android.tools.build:gradle:4.2.1"
    classpath 'com.jakewharton:butterknife-gradle-plugin:10.2.3'
    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"

    // NOTE: Do not place your application dependencies here; they belong
    // in the individual module build.gradle files
    }
    }

    allprojects {
    repositories {
    maven { url "https://jitpack.io" }
    mavenCentral()
    google()
    }
    }

    task clean(type: Delete) {
    delete rootProject.buildDir
    }


    不过仅仅是两个文件里面的内容不一致,这个文件的位置是一样的,而且我们添加的引入代码也是一样的。可以说,这只是顺带提一嘴,实际上不影响我们实现统一依赖管理这个方式。




  • 第三步:在所有module的「build.gradle」当中添加依赖


    这一步是最重要的,我们完成了上面两步之后,只是做好了准备,现在我们需要将我们每一个module里面「build.gradle」文件里面的依赖指向「config.gradle」文件。也就是下图圈起来的 那两个「build.gradle」文件。


    Snipaste_2023-04-20_14-15-58.png


    因为我们第二步的时候已经在根目录引入了「config.gradle」,所以我们在「build.gradle」就可以指向「config.gradle」例如:



    implementation rootProject.ext.dependencies.coreKtx



    这一行,就指代了我们「config.gradle」文件里面的 dependencies 数组里面的 coreKtx 的内容。完整示例如下:


    plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    }
    android {
    namespace 'leo.dev.mvp.kt'
    // compileSdk 32
    compileSdk rootProject.ext.android.compileSdk

    defaultConfig {
    applicationId "leo.dev.mvp.kt"
    // minSdk 21
    // targetSdk 32
    // versionCode 1
    // versionName "1.0"
    //
    // testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"

    minSdk rootProject.ext.android.minSdk
    targetSdk rootProject.ext.android.targetSdk
    versionCode rootProject.ext.android.versionCode
    versionName rootProject.ext.android.versionName

    testInstrumentationRunner rootProject.ext.android.testInstrumentationRunner

    }

    ......
    }

    dependencies {

    implementation fileTree(include: ['*.jar'], dir: 'libs')

    // implementation 'androidx.core:core-ktx:1.7.0'
    // implementation 'androidx.appcompat:appcompat:1.6.1'
    // implementation
    //
    // testImplementation 'junit:junit:4.13.2'
    // androidTestImplementation 'androidx.test.ext:junit:1.1.5'
    // androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'

    implementation rootProject.ext.dependencies.coreKtx
    implementation rootProject.ext.dependencies.appcompat
    implementation rootProject.ext.dependencies.material

    testImplementation rootProject.ext.dependencies.junit
    androidTestImplementation rootProject.ext.dependencies.testJunit
    androidTestImplementation rootProject.ext.dependencies.espresso

    }


    需要注意的是,我们在编写代码的时候,是没有代码自动补全的。所以得小心翼翼,必须要和「config.gradle」文件里面的名字向一致。




注意事项



  • 首先就是这种方式在coding的时候,是没有代码补全的(只有输入过的,才会有提示),我们需要确保我们的名字一致

  • 我们在增加依赖的时候,在「config.gradle」里面添加完之后,记得在对应的module里面的「build.gradle」里面添加对应的指向代码。


总结


以上就是本篇文章的全部内容,总结起来其实步骤不多,也就三步。但是需要注意的是细节。需要保持写入的依赖与「config.gradle」文件一致,并且未写过的词,是不会有代码自动补全的。


抬头图片


作者:肥仔仁
来源:juejin.cn/post/7224007334513770551
收起阅读 »

Android 自定义开源库 EasyView

  这是一个简单方便的Android自定义View库,我一直有一个想法弄一个开源库,现在这个想法付诸实现了,如果有什么需要自定义的View可以提出来,不一定都会采纳,合理的会采纳,时间周期不保证,咱要量力而行呀,踏实一点。 配置EasyView 1. 工程b...
继续阅读 »

  这是一个简单方便的Android自定义View库,我一直有一个想法弄一个开源库,现在这个想法付诸实现了,如果有什么需要自定义的View可以提出来,不一定都会采纳,合理的会采纳,时间周期不保证,咱要量力而行呀,踏实一点。


1682474222191_095705.gif.gif


配置EasyView


1. 工程build.gradle 或 settings.gradle配置


   代码已经推送到MavenCentral(),在Android Studio 4.2以后的版本中默认在创建工程的时候使用MavenCentral(),而不是jcenter()


   如果是之前的版本则需要在repositories{}闭包中添加mavenCentral(),不同的是,老版本的Android Studio是在工程的build.gradle中添加,而新版本是工程的settings.gradle中添加,如果已经添加,则不要重复添加。


repositories {
...
mavenCentral()
}

2. 使用模块的build.gradle配置


   例如在app模块中使用,则打开app模块下的build.gradle,在dependencies{}闭包下添加即可,之后记得要Sync Now


dependencies {
implementation 'io.github.lilongweidev:easyview:1.0.3'
}

使用EasyView


   这是一个自定义View的库,会慢慢丰富里面的自定义View,我先画个饼再说。


一、MacAddressEditText


MacAddressEditText是一个蓝牙Mac地址输入控件,点击之后出现一个定制的Hex键盘,用于输入值。


在这里插入图片描述


1. xml中使用


首先是在xml中添加如下代码,具体参考app模块中的activity_mac_address.xml


    <com.easy.view.MacAddressEditText
android:id="@+id/mac_et"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
app:boxBackgroundColor="@color/white"
app:boxStrokeColor="@color/black"
app:boxStrokeWidth="2dp"
app:boxWidth="48dp"
app:separator=":"
app:textColor="@color/black"
app:textSize="14sp" />


2. 属性介绍


这里使用了MacAddressEditText的所有属性,可以自行进行设置,使用说明参考下表。


属性说明
app:boxBackgroundColor设置输入框的背景颜色
app:boxStrokeColor设置输入框的边框颜色
app:boxStrokeWidth设置输入框的边框大小
app:boxWidth设置输入框大小
app:separatorMac地址的分隔符,例如分号:
app:textColor设置输入框文字颜色
app:textSize设置输入框文字大小

3. 代码中使用


    MacAddressEditText macEt = findViewById(R.id.mac_et);
String macAddress = macEt.getMacAddress();

macAddress可能会是空字符串,使用之前请判断一下,参考app模块中的MacAddressActivity中的使用方式。


二、CircularProgressBar


CircularProgressBar是圆环进度条控件。


在这里插入图片描述


1. xml中使用


首先是在xml中添加如下代码,具体参考app模块中的activity_progress_bar.xml


    <com.easy.view.CircularProgressBar
android:id="@+id/cpb_test"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginTop="30dp"
app:maxProgress="100"
app:progress="10"
app:progressbarBackgroundColor="@color/purple_500"
app:progressbarColor="@color/purple_200"
app:radius="80dp"
app:strokeWidth="16dp"
app:text="10%"
app:textColor="@color/teal_200"
app:textSize="28sp" />


2. 属性介绍


这里使用了MacAddressEditText的所有属性,可以自行进行设置,使用说明参考下表。


属性说明
app:maxProgress最大进度
app:progress当前进度
app:progressbarBackgroundColor进度条背景颜色
app:progressbarColor进度颜色
app:radius半径,用于设置圆环的大小
app:strokeWidth进度条大小
app:text进度条中心文字
app:textColor进度条中心文字颜色
app:textSize进度条中心文字大小

3. 代码中使用


    CircularProgressBar cpbTest = findViewById(R.id.cpb_test);
int progress = 10;
cpbTest.setText(progress + "%");
cpbTest.setProgress(progress);

参考app模块中的ProgressBarActivity中的使用方式。


三、TimingTextView


TimingTextView是计时文字控件。


在这里插入图片描述


1. xml中使用


首先是在xml中添加如下代码,具体参考app模块中的activity_timing_text.xml


    <com.easy.view.TimingTextView
android:id="@+id/tv_timing"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginTop="30dp"
android:text="计时文字"
android:textColor="@color/black"
android:textSize="32sp"
app:countdown="false"
app:max="60"
app:unit="s" />


2. 属性介绍


这里使用了TimingTextView的自定义属性不多,只有3个,TextView的属性就不列举说明,使用说明参考下表。


属性说明
app:countdown是否倒计时
app:max最大时间长度
app:unit时间单位:s(秒)、m(分)、h(时)

3. 代码中使用


    TimingTextView tvTiming = findViewById(R.id.tv_timing);
tvTiming.setMax(6);//最大时间
tvTiming.setCountDown(false);//是否倒计时
tvTiming.setUnit(3);//单位 秒
tvTiming.setListener(new TimingListener() {
@Override
public void onEnd() {
//定时结束
}
});
//开始计时
tvTiming.start();
//停止计时
//tvTiming.end();

参考app模块中的TimingActivity中的使用方式。


四、EasyEditText


EasyEditText是一个简易输入控件,可用于密码框、验证码输入框进行使用。


在这里插入图片描述


1. xml中使用


首先是在xml中添加如下代码,具体参考app模块中的activity_easy_edittext.xml


    <com.easy.view.EasyEditText
android:id="@+id/et_content"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
app:boxBackgroundColor="@color/white"
app:boxFocusStrokeColor="@color/green"
app:boxNum="6"
app:boxStrokeColor="@color/black"
app:boxStrokeWidth="2dp"
app:boxWidth="48dp"
app:ciphertext="false"
app:textColor="@color/black"
app:textSize="16sp" />


2. 属性介绍


这里使用了EasyEditText的所有属性,可以自行进行设置,使用说明参考下表。


属性说明
app:boxBackgroundColor设置输入框的背景颜色
app:boxFocusStrokeColor设置输入框获取焦点时的颜色
app:boxNum设置输入框的个数,4~6个
app:boxStrokeColor设置输入框的边框颜色
app:boxStrokeWidth设置输入框的边框大小
app:boxWidth设置输入框大小
app:ciphertext是否密文,用于密码框
app:textColor设置输入框文字颜色
app:textSize设置输入框文字大小

3. 代码中使用


        binding.cbFlag.setOnCheckedChangeListener((buttonView, isChecked) -> {
binding.etContent.setCiphertext(isChecked);
binding.cbFlag.setText(isChecked ? "密文" : "明文");
});
//输入框
binding.btnGetContent.setOnClickListener(v -> {
String content = binding.etContent.getText();
if (content.isEmpty()) {
showMsg("请输入内容");
return;
}
if (content.length() < binding.etContent.getBoxNum()) {
showMsg("请输入完整内容");
return;
}
showMsg("输入内容为:" + content);
});

参考app模块中的EasyEditTextActivity中的使用方式。


作者:初学者_Study
来源:juejin.cn/post/7225407341633175613
收起阅读 »

css水滴登录界面

web
前言 今天我们来分享一款非常有趣的登录界面,它使用HTML和CSS制作,具有动态的水波纹效果,让用户在登录时感受到了一股清凉之感。 基本html框架 <!DOCTYPE html> <html lang="en"> <head&...
继续阅读 »

前言


今天我们来分享一款非常有趣的登录界面,它使用HTML和CSS制作,具有动态的水波纹效果,让用户在登录时感受到了一股清凉之感。


基本html框架


<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
<link rel="stylesheet" href="water.css">
<link rel="stylesheet" href="form.css">
</head>

<body>
<div class="main">
<form>
<p>用户名<br />
<input type="text" class="textinput" placeholder="请输入用户名" />
</p>
<p>密码<br />
<input type="password" class="textinput" placeholder="请输入密码" />
</p>
<p>
<input id="remember" type="checkbox" /><label for="smtxt">记住密码</label>
</p>
<p>
<input type="submit" value="登录" />
</p>
<p class="txt">还没有账户?<a href="#">注册</a></p>
</form>
</div>
</body>
</html>

首先,我们来看HTML代码。这个登录界面包含一个表单,用户需要在表单中输入用户名和密码。我们使用p标签创建输入框,并设置class属性以便后续的CSS样式设置。此外,我们还在表单中添加了一个“记住密码”的复选框和一个登录按钮,同时还有一个注册链接。


表单样式


form{            
opacity: 0.8;
text-align: center;
padding: 0px 100px;
border-radius: 10px;
margin: 120px auto;
}

p {
-webkit-text-stroke: 1px #8e87c3;
}

对表单整体进行样式定义,使其位于水滴内部,p标签内文镂空。


.textinput{
height: 40px;
font-size: 15px;
width: 100px;
padding: 0 35px;
border: none;
background: rgba(250, 249, 249, 0.532);
box-shadow: inset 4px 4px 10px rgba(160, 162, 158, 0.814), 4px 4px 10px rgba(117, 117, 117, 0.3), 15px 15px 30px rgba(72, 70, 70, 0.193), inset -2px -2px 10px rgba(255, 254, 254, 0.873);
border-radius: 50px;
-webkit-text-stroke: 0px;
color: saddlebrown;
outline-style: none;
}

对输入框进行样式定义,取消镂空字体样式,取消轮廓线,设置阴影实现水滴一般效果。


input[type="submit"]{
width: 110px;
height: 40px;
text-align: center;
outline-style: none;
border-style: none;
border-radius: 50px;
background: rgb(31, 209, 218);
-webkit-text-stroke: 0px;
box-shadow: inset 4px 4px 10px rgba(160, 162, 158, 0.814), 4px 4px 10px rgba(117, 117, 117, 0.3), 15px 15px 30px rgba(72, 70, 70, 0.193), inset -2px -2px 10px rgba(255, 254, 254, 0.873);
}

我们使用了input[type="submit"] 选择器来选中提交按钮,并设置了按钮的大小、文本对齐方式、圆角和背景等样式,去除了轮廓线。同样采用了阴影来设置按钮,使其具有气泡一般的感觉,并设置背景色。


input[type="submit"]:hover {
background-color: rgb(31, 218, 78);
}

这段代码是用来为按钮添加鼠标悬停效果的。我们使用了input[type="submit"]:hover选择器来选中鼠标悬停在按钮上时的状态,并设置了背景颜色。当用户悬停在按钮上时,按钮的背景颜色会改变,非常引人注目。


a {
text-decoration: none;
color: rgba(236, 20, 20, 0.433);
-webkit-text-stroke: 1px;
}

a:hover {
text-decoration: underline;
}

提交按钮底部注册文字样式,采用镂空字体样式,鼠标移至该元素上方时,添加下划线。


* {
margin: 0;
padding: 0;
}
body {
background: skyblue;
}

这段代码是对所有元素的外边距和内边距进行清零,以便更好地控制元素的位置和大小,设置了整个页面的背景颜色为天蓝色。


.main {
position: absolute;
left: 50%;
top: 50%;
transform: translate(-50%, -50%);
width: 400px;
height: 400px;
box-sizing: border-box;
border-radius: 50%;
background: transparent;
box-shadow: inset 15px 10px 40px rgba(158, 158, 158, 0.303), 10px 10px 20px rgba(117, 117, 117, 0.3), 15px 15px 30px rgba(72, 70, 70, 0.193), inset -10px -10px 20px rgba(233, 229, 229, 0.873);
animation: move 6s linear infinite;
}

这段代码采用绝对定位,以便更好地控制它的位置。left: 50%; top: 50%; 将元素的左上角定位在页面的中心位置。通过transform属性将元素向左上角移动50%,以便让元素的中心位置与页面中心位置重合。设置元素的宽度和高度为400像素。background: transparent; 将元素的背景设置为透明色。box-shadow: inset 15px 10px 40px rgba(158, 158, 158, 0.303), 10px 10px 20px rgba(117, 117, 117, 0.3), 15px 15px 30px rgba(72, 70, 70, 0.193), inset -10px -10px 20px rgba(233, 229, 229, 0.873); 设置元素的阴影效果,包括内阴影和外阴影。animation: move 6s linear infinite; 为元素添加动画效果,其中move 是动画名称,6s是动画时长,linear是动画速度曲线,infinite是动画循环次数。


.main::after {
position: absolute;
content: "";
width: 40px;
height: 40px;
background: rgba(254, 254, 254, 0.667);
left: 80px;
top: 80px;
border-radius: 50%;
animation: move2 6s linear infinite;
filter:blur(1px);
}

.main::before {
position: absolute;
content: "";
width: 20px;
height: 20px;
background: rgba(255, 255, 255, 0.5);
left: 130px;
top: 70px;
border-radius: 50%;
animation: move3 6s linear infinite;
filter:blur(1px);
}

这段代码是对两个小球进行样式定义,将伪元素的定位方式设置为绝对定位,以便更好地控制它的位置,设置伪元素的宽度和高度一个为20px,一个为40px。设置伪元素的背景颜色为半透明白色。left,top 设置伪元素的左上角定位在主体元素的中心位置,设置伪元素的边框半径为50%,以便将其设置为圆形。animation: move2 6slinear infinite; 为伪元素添加动画效果,其中 move2 是动画名称,6s 是动画时长,linear 是动画速度曲线,infinite 是动画循环次数,另一个伪元素同理。
接下来是动画定义:


@keyframes move {
50% {
border-radius: 42% 58% 49% 51% / 52% 36% 64% 48% ;
}
75% {
border-radius: 52% 48% 49% 51% / 43% 49% 51% 57% ;
}
25% {
border-radius: 52% 48% 59% 41% / 43% 49% 51% 57% ;
}
}

@keyframes move2 {
25% {
left: 80px;
top: 110px;
}
50% {
left: 50px;
top: 80px;
}
75% {
left: 80px;
top: 120px;
}
}

@keyframes move3 {
25% {
left: 100px;
top: 90px;
}
50% {
left: 110px;
top: 75px;
}
75% {
left: 130px;
top: 100px;
}
}

这段代码定义了三个不同的动画,分别是move、move2和move3。move动画,它控制了元素的边框半径在不同时间点的变化。在这个动画中,元素的边框半径分别在25%、50%和75%的时间点进行了变化。move2move3动画,控制了一个伪元素的位置在不同时间点的变化。在这个动画中,伪元素的位置分别在25%、50%和75%的时间点进行了变化。


结语


以上便是全部代码,喜欢的可以自取,样式不

作者:codePanda
来源:juejin.cn/post/7225623397144199228
好看可以自行更改😜。

收起阅读 »

人生是一场长期的均值回归

我一直觉得记录并收藏每个阶段的状态是一件很有意义且奇妙的事,尤其是多少年后还能清晰地回忆其当初的心境,联想到曾经所设立的一些目标以及为之做出的努力,这些人生经历的脉纹清晰而完整,形成的回荡激扬的动力循环让人长久受益。 所以在即将进入下一个更长远的阶段之前,纪念...
继续阅读 »

我一直觉得记录并收藏每个阶段的状态是一件很有意义且奇妙的事,尤其是多少年后还能清晰地回忆其当初的心境,联想到曾经所设立的一些目标以及为之做出的努力,这些人生经历的脉纹清晰而完整,形成的回荡激扬的动力循环让人长久受益。


所以在即将进入下一个更长远的阶段之前,纪念珍贵的经历,留存美好的记忆,时间是个单向的旅程,在未来的某一刻回忆曾经,挺不错的。


真正的大师,永远怀着一颗学徒的心


尽管计算机科班出身的自己学习了这么多年,对于本专业的某些领域知识却仍然处于浅尝辄止的状态。不过庆幸自己的做事态度,由于存在一些偏执,对于一些方向的学习还做到了令自己满意的成绩。只要认定一个方向,只要开始着手做一件事,那就先做完,不然已经做的努力就白白浪费了。


究天人之际,通古今之变,成一家之言



工程应该包括业务和Infra。业务包括了UI、设计、编码、测试、部署等等,而Infra则包括了相对底层的基础设施平台的开发,其为上层提供服务。



jinengshu.png


还记得最早接触的是Android开发,曾经,2010年后的5年掀起了移动互联网的热潮,跟随着校科研团队的步伐,开始触碰这个方向。15年到17年初,从eclipse到andorid studio,从控件使用到自定义view,从Holo到曾盛极一时的Material Design,从原生开发到跨平台weex、flutter,又了解学习了性能调优、热修复、组件化、插件化、mvp、mvvm等技术,还记得在这个过程中,小程序小游戏也曾盛行一时,不过这个倒是比android简单多了。对于面向用户的终端应用,与服务器进行数据交互自然不可避免,我也因此了解了诸如xutils,httpclient,okhttp,retrofit和glide等库,在学习优雅android设计模式以及极致代码优化的同时,我永对设计这些工具库的Jake Wharton等大神致以最崇高的敬意!


记得16年暑假的时候,我用了两个多月的时间来调试一个andorid与服务端通信的bug,期间辛酸一言难尽,因为没有经验,服务器一直是一个黑盒的存在,这因此促使我去了解网络通信原理和后端开发流程。我也就开始了服务端研发的学习。一个是框架和工具的应用,诸如Netty、SSH、SSM、SpringSecurity、SpringCloud、Zookeeper、MySQL、Redis、Jetty、Tomcat、Nginx、OpenResty、Varnish、Keepalived、Kafka、RocketMQ、Xxl-Job、Seata、ShardingSphere、Docker、Kubernetes、Jenkins等等,一个是设计模式的理解和应用以及代码架构MVC到DDD的理解、迁移与应用,还有架构方面的学习,包括从单体架构到分层架构到微服务架构再到云原生架构以及DevOps的实践等,最后是为了系统稳定而进行的监控系统设计包括用于日志监控的ELK、用于链路监控的Skywalking以及用于指标监控的Prometheus和Grafana等。19年的时候,还和技术大佬川哥一起讨论当年最新的FAAS,这个过程也将我的技术理解和视野带到了一个新的高度。


当然,分布式也是后端不可逃脱的重点内容,包括分布式ID、分布式Session、分布式锁、分布式缓存、分布式文件存储、分布式事务、分布式限流、分布式任务调度、分库分表等等,这里要感谢MIT6.824课程,受益良多!


最早的服务端开发是没有前后端分离这一概念的,所有的前后端资源都集中由一个项目部署,那个时代还是JSP和Thymeleaf的天下。但随着移动互联网的普及以及当今应用复杂性和对实际生产的高性能要求,逐渐产生了诸如SOAP等协议和Restful架构风格,原来的单体项目才开始拆分。但,不论是早期还是架构设计理念有所进步以后,搞后端的人都避免不了对于web基础内容的学习,毕竟最常见的业务还有开发一个常见的管理系统。为此,我又乐此不疲的学习了JS、Html5、JQuery、Vue等技术。不过前端自己了解的都很浅很浅了,在这个过程中遇到的问题还是要请教各位前端大佬,此时,我要感谢我的老同学——房哥,一个人很好的前端开发者,曾一度帮我解决很多问题。


从设计到编码到部署到运维,基本打通了整体流程。在这里,特别感谢在阿里云EBS部门工作的汤兄,曾分享了他在做基础设施时的经验。对Infra的有一定认识后,我对工程的核心点又有了新的理解。


最后,感谢帮我改过简历的每位前辈!


jianli.jpg


冰冻三尺,非一日之寒



你知道的越多,你不知道的也越多



工程领域技术庞大繁杂,所以我对所进行的工作一直在不断的思考和总结,为了更好的于他人分享我的经验以及对诸如高可用、高性能、稳定系统的认识,我对服务端的核心内容以自己的理解进行了总结归纳。跳出技术细节的桎梏,全面考虑问题并有针对性的进行解决。


zongjie.jpg


算法是每个计算机人不可忽视的重要一课,除了可以更好的锻炼思维能力和编码能力,通过算法来学习一些代码的优化设计思想常常也可以用于实际生产之中。比如,我已经和不止一个师弟或同学讨论到某一个具体业务或者问题的解决方案,发现这些本身就是一个个经典的算法问题,如果有所总结和沉淀自然得心应手。所以硕士期间,我除了重新补充了对于专业课操作系统和计算机网络的学习,我还坚持刷了一些算法问题,主要是在LeetCode上。我要感谢我曾经看到的一个博主,奔跑的蜗牛,是他在坚持刷题的过程中不断总结并以录制Vlog的方式来分享才促使我坚持刷题并不断输出,而这一过程让我受益匪浅。


leetcode.png


bzhan.png


博学而笃志,且问而近思


一开始自己还是很浮躁的,总是想把很多内容都搞懂。虽然作为一名技术人,我们要构建一个广泛的知识体系,但技术领域的学习本质应该是一个专注钻研的过程,我们终归是要克制住诱惑,将某个领域做到精深。正如杨老师曾经说过的,“水桶装水量取决于最短板,但是大多数情况下,我们在工作中获取的回报,更多来源于自身的长处”。我在后来也逐渐认识到这一点并及时做出了调整,不过我还是非常庆幸有一段学习过不同领域各种技术的经历,这对我技术眼界的开阔有很大的提升,一个是服务端本身就是要为前端和移动端等平台来提供服务的,如果能对其他平台有一定的认识自然会对自己的编码设计有一定的科学指引,另一个是其他领域的设计思想也可以借鉴到当前领域的许多工作中。博观而约取,厚积而薄发!


感谢一路走来所遇到和知道的前辈,包括做安卓时的郭霖、张鸿洋、赖帆、任玉刚等,做前端时的Vben维护者金毛、在爱奇艺和快手工作过的老同学房哥等,做服务端时的沈剑、许令波、林晓斌、LinkedBear、松哥、Mrbird、小林、汤兄、传奇大佬Robert Tappan Morris等,学算法时的宫水三叶、左程云、闫学灿等。


大胆与礼貌



记录毛姆所著小说《刀锋》里的一段文字:


我并不怕犯错,搞不好会在其中一条冤枉路上,找到人生的目标,人生从来就没有白走的路,每一步都算数。


我们这一生,都怕走冤枉路,都想找到一条捷径,好用最快的速度接近自己的目标。


但事实上,当你并不清楚自己内心最真实的声音的时候,你只有不断尝试,才可能知道什么是适合自己的,就算尝试过后你还是不清楚自己想要什么,但你最起码知道一点,这不是自己喜欢的。



谦逊是青年人进入社会的一种必须常备的状态,但谦卑不是。


这些年的经历,我逐渐感受到因为自己缺乏勇气与自信导致自己失去了很多的机会。自己出身平凡,在见识了很多优秀的大佬后更觉自己渺小,时间长了开始优柔寡断,总觉得自己目前学的做的不充分,不敢去尝试更怕去竞争,患得患失。


鹏哥是我的一个舍友,我们也是七八年的同学了,他是一个性格很好的人,也是一个相当聪明的人,他的逻辑思维非常强,学习能力也很强,经常帮助我们周围很多同学解决很多我们查了很多资料都解决不了的硬件和软件方面的疑难杂症。如果把我们计算机相关专业的同学都放在一起,把我们的生活学习环境比作一个武林,那鹏哥绝对是一个深藏不露的世外高人,他很爱折腾技术,会主动学习一些技能来解决现实生活中的很多问题,比如只要我们去看他正在做的事,看看他的手机或电脑,总会发现很多实用的小工具,有些是他自己写的,有的也不知道是从哪些渠道获取的,但这些工具就是那么的神秘且好用!


鹏哥是我认为周围人里面绝对很出众的一个同学了,但很多时候他得到的往往与他的实力不够匹配,究其原因,也是不够自信,很多事不敢去尝试,总觉得自己的实力有限而不敢有过多的想法,但实际上呢?据我的经历以及我一些朋友跟我分享的一些事看来,总会有很多出身不如你、头脑也不会比你更聪明、技术能力不如你的人做出了非常好的成绩。他们当然很优秀,但如果仅从硬性技能出发而言,他们可能很多还比不上我们,比如我们学的时间更长,积累的编程经验或者理论基础都要超过很多入门才一两年的学生,之所以我们还停留在原地,是很多时候我们忽视了软性技能的培养,我们缺乏那一点初生牛犊不怕虎的干劲和勇气。我们都是普通人,又会有多少人有“秀美的容颜”、“聪颖的天资”、“出众的才华”、“骄人的学业”?如果不能改变自己的心态,即便我们的实力达到了某项任务需要的标准,我们的软实力还是会限制我们的发展。我们出身不如名校学生,如果还一直畏手畏脚,那就更不能在社会上与他们相竞争了。


生活、学习和工作中的很多事,其实本没有那么难,往往是自己不自信的心态为之蒙上了一层恐惧的阴影,之后面对机遇就会胆怯。这些年给我最深的感触就是,我们已经因为缺乏自信和勇气失去了好多机会,而如果有新的机遇让我们来尝试,那我们一定要敢闯,敢干,不怕失败,不畏周围可能存在的偏颇眼光,如果不去尝试那一定不会成功,即使尝试失败了也会成为下一次成功的经验砝码,人生从来就没有白走的路。


自信很重要,大胆一些,礼貌的去问就好了。


愿为江水,与君重逢


江水.jpg


这些年的读书过程中,我结识了与之相处时间最久的谭同学,我们认识了八年,在一个寝室生活就有六年多,自然对于双方的认识是无比的熟悉。谭兄一个非常优秀的人,他头脑聪明、思维敏捷,对于新知识和未知领域永远充满兴趣且会一直不断地探索和求知。做事具有极强的目标性,凡事绝不囿于当前的状态,以最大的自信来追求最接近完美的极致,我经常对他说,“你是我们周围同学中我认为最富有极客精神的那一位”,事实上,谭兄作为全院最优秀的学生同时也是最努力的那一位。


作为良师益友,我们在这八年的过程中,最多的讨论就是关于专业知识学习、技术提高、发展规划等方面的内容。在过去的五六年里,我们进行着不同方向的工作,在自己擅长的领域深耕厚植,当遇到涉及对方领域的问题时,我们都十分乐意交流双方的观点与经验。更为重要的,我十分崇尚开源精神,而谭兄也是非常重视学术交流和论点探讨的人,我们都会毫无保留的分享自己的知识及经验,即使对一方在不擅长某个领域时仍会给予尊重并提供最大的帮助,实现真正的成长。十分荣幸遇到了一个优秀的同学,不仅是在学业上得到了很多帮助,因为熟悉互相脾气秉性,我们也在日常的生活中得到了性格的磨合,在做人做事上也有了很大的进步。


我们终将分别,但想想,我的一生能和几个人共同生活达八年之久呢?一切都是命运,愿为江水,与君重逢。他将到昆士兰去继续自己新的学术研究,我也将准备进入我的下一个阶段。正如谭兄经常说的,我们还要经常保持联系,多交流学术问题,以科研会友,期待能够在KDD等顶会上能够见到对方来参会。而我则希望我们在追求理想的道路上还能相互引为知音,就像一条清澈的小溪在流向大海的途中遇到了另一条清澈的小溪,碰巧这两条小溪还是朝着同一个方向流向大海。祝我们都能实现自己的理想,成为自己想成为的那个人!


这是个拥挤的地方,而我却很平凡


在我读研的这几年里,开始逐渐将自己的精力和工作重心从工程转向科研,尽管如此,我仍然会时常关注工程界大致的一些动向,关注互联网职场人以及北漂青年的一些生活和境况,我喜欢他们忙碌的状态、积极的生活态度以及日常努力生活而表现出的韧性。


鼓楼.png
 


北漂人都是可爱的,不管生活有多少苟且都能够坚持自己的理想,在压力中求生存,平凡而生活更显真实。每个人都有自己选择的生活方式,不管遇到什么挫折与不顺,总要挺过去,毕竟生活总要继续,方向总会有的!


飞鹏各自远,且尽手中杯



君子敬而无失,与人恭而有礼,四海之内皆兄弟也!



友情是散落四处的点点温馨,平时想起一座城市,先会想起一些风景,到最后必然只想起这座城市里的朋友,是朋友,决定了我们与各个城市的亲疏。


很荣幸这些年遇到了一些很好的朋友,曾经的本科同学、如今的研究生同学、工作中认识的朋友以及各种社区交流技术和求职过程中遇到的朋友,不管是校内还是校外,不论是在济南还是在北京、南京、深圳......,他们都在我的人生中的不同阶段提供了极大的帮助。更为重要的是,他们分别从事不同领域的工作,分别在不同地域以不同身份生活,所得到的社会经验和生活感悟对我而言更是弥足珍贵的。


还记得东哥曾经给我分享他从周围人学到的做人之道。如何做一个高情商的人,其实就是与人的交往中要擅于交流,而擅于交流的前提在于你知道的很多,眼界开阔,你能够从容温和的和很多人聊,和不同阶层的人聊相应的话题,打破周围人对你的刻板印象,让自己成为一个有内涵又有趣的人。你的知识储备,你的形象以及谈吐都作为以上的评判标准。


我们终将生活在不同的城市,即使不能时常相见,我们也会随时在对方身处困境或者黑暗时及时的带去援助和光亮。所谓朋友,也只不过是互相使对方活得更加温暖、更加自在的那些人。


时空是个圆圈,直行或是转弯,我们总会相见!


最后


仅以上文来记录我当前阶段的状态与生活。《圣经.启示录》中写道:“我又看见一个新天新地,因为先前的天地已经过去了,海也不再有了”。是的,过去已经过去,未来终将来到,这是一个新的开始。


王小灏

开始于2023年4月1日

完成于2023年4月18日

作者:Gopher
链接:https://juejin.cn/post/7223374346094329911
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

【Git】代码提交到了错误的分支怎么办

Git
最近在git的代码提交中遇到了一个这样的情况,A分支要提交功能a1、a2、a3,B分支要提交功能b1、b2、b3,但是误把a2功能提交到了B分支上,一开始以为得在在A分支上重新把a2功能重写一遍,后来查阅了一番才知道有git cherry-pick 和 git...
继续阅读 »

最近在git的代码提交中遇到了一个这样的情况,A分支要提交功能a1、a2、a3B分支要提交功能b1、b2、b3,但是误把a2功能提交到了B分支上,一开始以为得在在A分支上重新把a2功能重写一遍,后来查阅了一番才知道有git cherry-pickgit rebase这种好东西。


image.png


首先要解决上面的失误,分为两步:




  • 把a2功能添加回A分支




  • 把a2功能从B分支中删除




1. 把a2功能添加回A分支(cherry-pick)


直接切到A分支,然后运行


git cherry-pick a2功能的SHA值

然后就可以了,就是这么简单就把a2挪到A分支上



2. 把a2功能从B分支中删掉(rebase)


切到B分支,然后运行


git rebase -i a2前一个功能的SHA值

运行后我们就能进入SHA值后面的提交文本记录



我们把a2对应的pick改为drop,就能删掉对应的提交,并且不影响后续b3的提交。


编辑方式:按i 进入编辑状态,按Esc:wq就能保存退出。


改成这样的就可以了



就能成功达到我们想要的效果了


image.png


平时Git Rebase 很少用到,直到这一次,不得不用,最后也顺利解决了问题,同时get到了新技能。


作者:前端小小梦
链接:https://juejin.cn/post/7224382425664159800
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

弯道超车的机会

前言 我一直很想把自己思考的东西表达出来,苦于语文成绩差,文字功力不够,想来想去也不知道用什么话来开场。我不喜欢站在高处对别人指指点点,毕竟每个人都不一样,即使你有成功的经验又如何,照样教育不到我,而且成功对于我来说还为时过早。更何况即使人们懂得了道理,在现实...
继续阅读 »

前言


我一直很想把自己思考的东西表达出来,苦于语文成绩差,文字功力不够,想来想去也不知道用什么话来开场。我不喜欢站在高处对别人指指点点,毕竟每个人都不一样,即使你有成功的经验又如何,照样教育不到我,而且成功对于我来说还为时过早。更何况即使人们懂得了道理,在现实中,知行合一的人一直是特立独行的猪,知而不行的人才是沉默的大多数。


但是基于一种可笑的理想,我仍然尽力把自己经历想法分享出来,希望能给你带来一点点的思考。


大学四年


大一


有一天,我在教室里用《生死时速》练习打字。


同学凑过来问这是什么游戏


“抓小偷,练习打字的”


“看起来挺有意思,好玩吗,我也试试”


“你来” 我把电脑递给他


他开始试玩这个游戏,我注意到他第一局就破掉了我的最高记录。


“挺快的” 我称赞道


接下来第二个同学也来试试,我注意到他第二局破掉我的最高记录。


他们不知道的是,我三个月前的暑假开始练习打字,这个游戏我已经练习三个月了。


打字游戏


我报名加入实验室,面试的学长问我会什么


“我学过一些 Python”


“你 Python 学到哪里了”


“函数”


“学到了函数,几乎等于什么都没学,跟他们零基础的同学差不多”


我当时对此嗤之以鼻,不以为然。


三个月前我在网上买了一本《零基础学习Python》的书,封面上的 “零基础”,“全彩”,“快速入门”,“视频教程” 和 “实战项目” 等关键词让我觉得这本书是我想要的。


现在看来这本教材质量十分堪忧。


更加令人毛骨悚然的是《零基础学习Python》还有《零基础学XXX》系列:《零基础学C语言》,《零基础学Java》,《零基础学Android》等。


“得益于” 我当时并没有意识到教材问题的严重性,我大一的对于编程学习效果可以说是微乎其微。


有幸的是学校课程成绩还可以。高数满绩,GPA全班第一。


零基础学习Python


国内除了极少专家外,大部分所谓的 “专家” 撰写的教材的质量堪忧。这种《零基础学XXX》系列的教材,更是质量堪忧中的质量堪忧,感觉是一群商人用来来哄骗刚入门的小白。如果用来当作 “字典” 查询尚可容忍,但是作为启蒙读物无法容忍,让人误入歧途。


对于启蒙书籍的选择容不得半点马虎。对于小白想在短时间评估书籍质量,首先应该咨询自己查询(比如知乎,豆瓣),并且咨询有经验的学长学姐,让他从他确实读过的书里给你一个合理的建议。


大二


发现了《零基础学XXX》系列的教材的质量问题,我在网上找了新的学习资料将之前学过的内容重新学了一遍。


我有幸加入了是食铁兽科技做研发,是一家创业公司,里面的核心人员都拥有我校第一梯队技术或者能力,我学到了一些东西。


stskj


我有幸拿到了元象科技的实习 offer,国内做全真互联网目前最领先的互联网公司。跟我一起进来的实习生有清华大学,复旦大学,香港大学,深圳大学等知名高校的本科甚至研究生,我学历最低。


一次我主持 “云原生监控 Prometheus” 的技术分享会,如果公司使用新方案替代之前的旧方案,能减少 80% 的日志储存成本。


提问环节台下隔壁项目组的 Leader 问我是那个学校的。


“重邮”


“重邮是哪个学校?”


“就是重庆邮电大学”


“重庆邮电大学?”


“邮电学校吧,听说过” 旁边的同事说。


“研究生吗?”


“不是,本科”


“讲的不错”


我向下看着桌脚下的地面,想起了曾今大一的时候去面试重邮新生典礼,我手里拿着稿子,支支吾吾,双腿发抖的场景。心里感触颇深。


大三


我看到学校里充满激情,热血,求知欲,和梦想的同学们通过层层考核进入实验室后,只能自己去学习,去B站,极客等各个网站找项目做。实验室只是提供了一个更好的自习室,实验室的项目是极少的,而且项目的质量甚至不如网上找的项目。


我无意去辩论某些项目,或者网校的项目是否会好些,这种辩论是没有意义的。


我只是看到因为没有项目,同学们独自埋头苦干,主动来实验室的同学寥寥无几,同学之间的交流和互动少,新一届的同学不能很好的借鉴前一届的经验。况且网上的项目并没有服务于真正的用户,你并不需要为你的代码负责,你只需要完成项目,这种项目对于学习的帮助是有限的。


我创立了 “关二爷科技有限公司”,团队核心人员都拥有我校第一梯队技术水平。并且有幸得到了许多在头部互联网就职的学长,创业的学长,和前公司的大佬们的指导和支持。


我们开始开发一款能最大程度降低用户记笔记压力软件 “咕咕笔记”,帮助用户能跟多的记录自己的思考,并且希望未来能不断迭代,帮助更多的人的同时,让实验室的同学能接触到生产级的项目。


遗憾的是后期项目开发进度不及预期,团队核心成员都在忙着找实习,项目暂时搁置,后转交给实验室的同学继续完成。


g2ykj


秋招有幸拿到了阿里,华为,B站,oppo等公司的 offer。


大四


在互联网上我们经常能听到每年能读几百本书的大神。这个速度听起来非常厉害,但是他们究竟用了什么方法来完成这一目标却很少有人关注。


我了解到了主题阅读,如果你想要深入了解某个领域,主题阅读是最好的方式。主题阅读可以同时读3~4本书的阅读法,在熟练后甚至可以同时读30~40本。


说得再简单一些,主题阅读是围绕着某个主题,在一定时间内快速阅读多本书。


比如我做 “如何读书” 的主题阅读。


《如何阅读一本书》:70%的书翻翻目录就行,20%的书需理解框架,7%需要将书读薄再读厚,3%的书需要一辈子反复读。读书应该分多种类型,有对应的阅读规则。


《快速阅读》:传统的读书速度太慢了!大脑得不到充分的使用所以会才会去想其他事情分神。加快速度非但不会影响阅读效果,反而能促进对文章的理解。


罗翔《至法学新人的一封信:关于读书》:读书的目的有功利性的目的和非功利性的目的,前者是为了成功,后者是对前者的纠偏。读书也要非功利性的读书。


《读懂一本书:樊登读书法》:讲书是最高效的沉浸式学习方法,死读书是没用的,需要讲出来给别人听,并且多次安利他个人的樊登读书会。


《这样读书就够了》:不少所谓的读书会主要内容就是把一本书摘抄为5页的PPT或者半个小时的精华干货。殊不知删掉的恰恰可能是最可能帮助学习者内化和应用的东西,留下了最不值钱的核心知识。我们必须区分 “以知识为中心的学习” 和 “以自己为中心的学习”。


因为主题是相似的,所以每一本书都可能有大量的重复内容,这些重复内容理的阅读是非常迅速的。当然,每一本书也有自己的特色,《这样读书就够了》甚至对《读懂一本书:樊登读书法》提到的读书会进行了批判。


因为再好的书也有局限性,甚至可能是错误的。但是大量的书中重复的内容大概率是正确的,而且不同的内容中各种思想会相互碰撞,我们择其善者而从之,就很有可能成为大师。


如何读书书架


毕业论文我准备跳出舒适圈尝试一下区块链,但是它对于我来说是全新的领域,我无法掌控它的难度。


导师催提交毕业论文开题报告,一周后发给她。


我问导师区块链方向有人做过么,效果如何。


“我带的学生没有做过,效果说不清楚”


在提交开题报告的一周时间,我在公司上班的时候抽空对区块链领域进行了主题阅读。


5 天的时间读完了 5 本书,完成了基本的区块链知识的学习。


2 天完成了毕业设计的整个代码部分,并且完成了测试。


建议


上了大学就轻松了是最大的谎言


高中的时候我的老师经常说:“现在你们辛苦点,上了大学,就轻松了”。


我每次听到这种话都想不通很多事:大一新生和高三学生,在智力,能力,经验上,差距有多大?如果大学生能力没有得到提升,和直接高中生的优势在哪里?对于上了大学就跃龙门这种事我是不愿意相信的。


“大学一定不是学习生涯的结束,是开始”


本科教育早已崩溃


我不得不遗憾地告诉大家一个消息:


“国内绝大部分大学的本科教育,已然彻底崩溃。”


我无意争论是否有更好的学校(复旦、中科大、或者清华、北大)比我们崩溃的更少一些。


我也无意列举学校偶然出现的闪光般的措施(如引入MIT麻省理工课程体系,中外合作办学)来说服你容忍余下99%的无意义。


因为任何这些都是欲盖弥彰。


没有老师会对你负责


我看到领导不会为你负责。对于一个争做世界一流大学的研究型学校,管好科研,管好实验室才是当务之急。相比之下,本科生教学显得无利可图。教授也不会为你负责。拉到足够的经费发表足够的论文,满足学院要求才是生存大计。要说管学生,也肯定先要管好自己实验室的硕士博士,而非那一百多人大课堂里的某个本科生。


学不懂?


要么因为你智力低,要么就是自己底下不用功。


为什么跟你一个班上的某某某同学,人家就能懂?


诚然,就算是老师上课说孟加拉语,一个班上也非常有可能冒出一两个翻翻书看看图就能考到八九十分的同学。


真正在课堂上口传心授的教学,其质量是不会有人过问的。教学评估会考察实验报告格式是否合格,出勤率是否够,但是绝对不会考察上百人的班上到底有几个听懂了的。


对于学校和老师来说,搞科研、发期刊才是主要任务,至于上课教学,不过是个不需要怎么负责的副业罢了,基本看具体教师的良心。


而本科生真正值得学校关心的,只有就业率。


因为这是本科生唯一与学校利益挂钩的指标。


于是,到了大四,学校就会开始关注你的就业情况,甚至进行一些神奇操作。


因为从制度上来讲


“无论是升学还是就业,培养都不是必须的。”


学生自己不负责


我看到个别国内的老师或者中外合作的外国老师尝试做出改变,却收效甚微。老师上课各种提问和互动,台下鸦雀无声,学生依旧在下面睡觉玩手机,当老师感觉自己几次都像是跳梁小丑,于是又回到了大多数中。


因为其他老师们都念 PPT 抓考勤,学生们已经习惯了。


别把期待全盘托付他人


“把期待全盘托付他人,必定会迎来悲惨的结果”


我看到无数充满求知欲、激情、与年轻梦想的同学们,不断地把自己的四年青春,充满希望与信任地托付给大学来塑造。然后在大学的所谓磨练中逐渐变得随意、平淡、失去梦想(除非你把保研/考研当作最终的梦想)。


我看到越来越多的同学们在逃避思考,逃避未来,彷佛一个成年了的大孩子(尽管现在的社会就是把大学生当不懂事的孩子一样,多么可笑)。


这使我心中非常不安。


机会


前段时间一个同学问我大学怎样学习,我说了现在的大学状况。


他问我说,“我现在好迷茫,那我该怎么办?”


“如果你意识到了而其他同学没有,这是将是一次弯道超车的机会。”


结语


本文章首次撰写于2023年3月,一定是有局限性甚至错误。内容是否正确,需要自己去评判,就像人生的路,需要自己去走。


我只希望能提供给你一个思考的方向。如果你能通过这篇文章开始思考你自身以及周围环境,那它的价值就是至高无上的了。


作者:JarvanStack
链接:https://juejin.cn/post/7215557246134861883
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

Android 项目的 Code Reviewer 清单

查看 Android 代码库时要记住的几点: 代码审查有时是一个乏味的过程,但我相信我们需要花更多的时间在这上面。 也许这是你学习或分享一些知识的机会。 这里列出了一些在 Android 项目的 Code Review 过程中检查所必需的要点。 Memory ...
继续阅读 »

查看 Android 代码库时要记住的几点:
代码审查有时是一个乏味的过程,但我相信我们需要花更多的时间在这上面。 也许这是你学习或分享一些知识的机会。
这里列出了一些在 Android 项目的 Code Review 过程中检查所必需的要点。


Memory Leaks(内存泄漏):


想象一下以下情况:一个漂亮的应用程序,但同时速度很慢,屏幕之间的导航每次都变慢。
在代码审查期间要检查的一些要点:



  • 这段新代码是否有任何 Context 保留?

  • 有没有相关的 RxAndroid 代码? 如果是,请检查 RxCall 是否在生命周期范围(ViewModel/Fragment/Activity)结束时被释放。

  • 如果代码有 coroutines(协程),检查 Job 是否从 ViewModel 范围启动以正确释放。

  • 代码中有使用 CountDownTimerAsyncTask 或任何视频/音频播放器的实现吗? 如果是,则代码应该释放与避免泄漏相关的内存资源。

  • 是否有新的 Fragment with ViewBinding 方法,代码应该在 onDestroyView 方法处释放绑定。


private ResultProfileBinding binding;

@Override
public View onCreateView (LayoutInflater inflater,
ViewGroup container,
Bundle savedInstanceState) {
binding = ResultProfileBinding.inflate(inflater, container, false);
View view = binding.getRoot();
return view;
}

@Override
public void onDestroyView() {
super.onDestroyView();
binding = null;
}

深度布局:


有时我们有一个 ViewGroup 有另一个 ViewGroup 作为子布局。
一个好的建议是始终使用 ViewGroup ConstraintLayouts 来保持布局更平坦。 它可以避免导致性能问题的过度绘制。
Android 文档中提到了一些减少过度绘制的技巧。


资源注释:


Android 世界中的每个资源都有一个标识符,它是一个 Integer 类型。 如何确保我们的 Integer 值代表一个有效的资源 ID? 注释可以帮助我们解决这个问题。
例如:


fun showMessage(context: Context, val idRes: Int) {
Toast.makeText(context, idRes, Toast.SHORT_LENGHT).show()
}

在上面的代码中,Code Reviewer 会建议你,在这里使用注释。
例如:


fun showMessage(context: Context, @StringRes val idRes: Int) {
Toast.makeText(context, idRes, Toast.SHORT_LENGHT).show()
}

其他注释示例在这里


类似组件:


Code Review 期间投入时间非常重要。 尝试按照作者的想法思考,反映他的选择,提出问题以理解代码。
一个新的需求,需要写很多新代码。 应该和项目组成员及时沟通,比如:“此代码与我们在此组件中已有的相同”。 像这样的沟通说明是必不可少的,因为最重要的是重用我们代码库中已经存在的代码。


危险代码区:


如果你有遇到敏感的代码或危险代码区。 危险代码是 Code Reviewer 需要重点查看的,当你发现一些代码没有任何意义的时候。在这种情况下,不要评判作者。与他们交谈以了解该代码背后的原因。 这次谈话可能是一个学习新东西的机会。也有可能是你自己对这块业务考虑不周,没了解到这段代码本质的原因。如果交流后,发现还是确实有问题,就可以把这块代码区的问题给更正了。


架构违规📐:


软件架构是定义在软件各部分之间的通信协议。
Code Review 是识别架构违规等问题的非常有效的手段。 在这种情况下可以做如下沟通是比较合适的:
“你的 ViewModel 正在访问存储库。 我们在它们之间有一个用例。 请看一下 MainViewModel 文件,这是一个可以参考的例子。”
“为什么要在 ViewModel 中使用 Adapter 引用? 适配器是一个 RecyclerView 组件。 最好把它放在一个 Fragment 中,让它远离我们的 ViewModel。”


小细节决定一切:



  • 未使用 import

  • 未使用的资源,例如 drawables, strings, colors……

  • 注释代码;

  • 未格式化的代码;

  • 变量名、方法名、文件名……

  • 代码不遵循样式指南。 例如,Kotlin 定义了一个定义明确的样式指南。 它对任何开发人员在现有代码库中快速找到任何软件组件都有很大帮助。


结论


静态分析工具在代码审查过程中很有帮助,但它们并不是 100% 有效的。 如果你的团队正在寻找代码质量,关键的 Code Review 是必不可少的。


作者:JeffreyAI
链接:https://juejin.cn/post/7119414483566460935
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

Android串口开发与SerialPort工具封装

Android串口开发之SerialPort工具封装 一. 什么是串口 串口通讯(Serial Communication),是指外设和计算机间,通过数据信号线、地线等,按位进行传输数据的一种通讯方式。 串口是一种接口标准,它规定了接口的电气标准,没有规定接口...
继续阅读 »

Android串口开发之SerialPort工具封装


一. 什么是串口


串口通讯(Serial Communication),是指外设和计算机间,通过数据信号线、地线等,按位进行传输数据的一种通讯方式。


串口是一种接口标准,它规定了接口的电气标准,没有规定接口插件电缆以及使用的协议。


在Android开发这一块来说,串口通信应用越来越广泛,得益于物联网的发展,很多定制设置在Android系统上外挂设备,如何与外挂设备进行双方通信,就需要串口来进行。


其实串口的通信和蓝牙的通信有很多相似的地方,数据帧的处理相似,只是连接通信的方式不同了而已,蓝牙的通信可以使用Android Api的方式,而串口需要自己编译Ndk,这里把封装的工具类开源出来,希望对大家有帮助。


二. Android如何进行串口通信


在Android的Framwork中是没有相关的Api的,我们想进行串口的相关操作还是得借助于谷歌2012年的老库android-serialport-api
项目结构如下:



编译NDK为对应的so库,如何使用Java调用想要的方法,想想真令人头秃







网上有很多编译的教程了,如果觉得麻烦的同学可以往下看我的封装库

三. Android串口通信的封装


allprojects {
repositories {
maven { url 'https://jitpack.io' }
}
}

implementation 'com.gitee.newki123456:serial_port_tools:1.0.0'

一句话解决串口通信:


    private lateinit var mSerialPortManager: SerialPortManager
var cmd = byteArrayOf(-91, 85, 1, -5) //开启通信的指令


//具体调用就是2个回调,设置串口,开启指令
mSerialPortManager = SerialPortManager()
mSerialPortManager
.setOnOpenSerialPortListener(object : OnOpenSerialPortListener {
override fun onFail(paramFile: File?, paramStatus: OnOpenSerialPortListener.Status) {
Toast.makeText(mContext,paramStatus.toString(),Toast.LENGTH_SHORT).show()
}

override fun onSuccess(paramFile: File) {

}
})
//设置串口的数据通信回调
.setOnSerialPortDataListener(object : OnSerialPortDataListener {
override fun onDataReceived(paramAnonymousArrayOfByte: ByteArray) {
//解析返回的数据转换为摄氏度
val i = paramAnonymousArrayOfByte[3]
val f = (paramAnonymousArrayOfByte[2] + i * 255 + 20) / 100.0f
val message = Message.obtain()
message.obj = java.lang.Float.valueOf(f)
message.what = 1
mHandler.sendMessage(message)
}

override fun onDataSent(paramArrayOfByte: ByteArray?) {

}
})
.openSerialPort(File("dev/ttyS3"), 115000) //打开指定串口

mSerialPortManager.beginBytes(cmd) //开启读取

重点概念:

串口路径 波特率 输入指定的指令

只要能通信了之后,处理数据的逻辑其实就和蓝牙的数据帧处理很像啦。


项目介绍:

自定义Android设备,支持人脸识别打卡并外挂的红外温度传感器,我们再识别比对到人脸成功之后需要通过串口拿到温度计的温度展示出来。

源码在此




作者:newki
链接:https://juejin.cn/post/7096022114041348133
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

为什么智能硬件首选MQTT

前言 前面讲了Android如何通过串口通信操作硬件,但实际业务场景大多是既可以屏幕操控硬件也可以远程下发操控,这时就需要MQTT协议来完成这一工作。本文将介绍MQTT协议及其在物联网设备通信中的应用。 一、初识MQTT 1. 什么是MQTT协议 MQTT是一...
继续阅读 »


前言


前面讲了Android如何通过串口通信操作硬件,但实际业务场景大多是既可以屏幕操控硬件也可以远程下发操控,这时就需要MQTT协议来完成这一工作。本文将介绍MQTT协议及其在物联网设备通信中的应用。


一、初识MQTT


1. 什么是MQTT协议


MQTT是一种轻量级的消息传递协议,全称为Message Queuing Telemetry Transport。它是基于发布-订阅模式的协议,可以在分布式系统中实现设备之间的消息传递和通信。


2. 为什么要用MQTT


它是一种非常轻量级的二进制协议,并且由于其最小的数据包开销,与 HTTP 等协议相比,MQTT在通过网络传输数据时表现出色。该协议的另一个重要方面是 MQTT 在客户端非常容易实现。易用性是 MQTT 开发的一个关键问题,使其非常适合当今资源有限的受限设备。


3. MQTT诞生背景



  • 1999 年:Andy Stanfork-Clark (IBM) 和 Arlen Nipper 发布 MQTT 协议,用于通过卫星连接石油管道遥测系统,MQTT 中的 TT (Telemetry Transport) 就是源于这样一个遥测系统;

  • 2010 年:MQTT 协议免费发布;

  • 2014 年:MQTT 协议正式成为 OASIS 标准,经过多年的发展,MQTT 协议已经成为互联网 (IoT) 的主要协议之一。


目前,MQTT 主要分为两个大版本:



  • MQTT v3 其中 v3.1.1 是目前接入设备最多的版本;

  • MQTT v5 2018 年发布,部分设备接入。


4. MQTT核心要求



  • 简单实现

  • 服务质量数据传输

  • 轻巧且带宽高效

  • 数据不可知

  • 连续会话意识


5. MQTT 发布/订阅模式


MQTT 发布/订阅模式(也称为发布/订阅)提供了传统客户端-服务器架构的替代方案。在客户端-服务器模型中,客户端直接与端点通信。发布/订阅模型将发送消息的客户端(发布者)与接收消息的客户端(订阅者)分离。发布者和订阅者从不直接联系对方。事实上,他们甚至不知道对方的存在。它们之间的连接由第三个组件(代理)处理。代理的工作是过滤所有传入的消息并将它们正确分发给订阅者。
image.png
pub/sub 最重要的方面是消息的发布者与接收者(订阅者)的解耦。这种解耦有几个方面:



  • 空间解耦:发布者和订阅者不需要相互了解(例如,不需要交换 IP 地址和端口)。

  • 时间解耦:发布者和订阅者不需要同时运行。

  • 同步解耦:两个组件的操作在发布或接收过程中不需要中断。


总之,MQTT 发布/订阅模型消除了消息发布者与接收者/订阅者之间的直接通信。代理的过滤活动可以控制哪个客户端/订阅者接收哪个消息。解耦具有三个维度:空间、时间和同步。


6. 可拓展性


pub/sub 比传统的客户端/服务器模式有了更好的拓展,这是由于 broker 的高度并行化,并且是基于事件驱动的模式。可扩展性还体现在消息的缓存和消息的智能路由,还可以通过集群代理来实现数百万的连接,使用负载均衡器将负载分配到更多的单个服务器上,这就是 MQTT 的深度应用了。


7. 消息过滤



  • 基于主题的过滤此过滤基于属于每条消息的主题。接收客户端向代理订阅感兴趣的主题,订阅后,broker 就会确保客户端收到发布到 topic 中的消息。

  • 基于内容的过滤在基于内容的过滤中,broker 会根据特定的内容过滤消息,接受客户端会经过过滤他们感兴趣的内容。这种方法的一个显著的缺点就是必须事先知道消息的内容,不能加密或者轻易修改。

  • 基于类型的过滤当使用面向对象的语言时,基于消息(事件)的类型/类进行过滤是一种常见做法。例如,订阅者可以收听所有类型为 Exception 或任何子类型的消息。


**发布/订阅并不是每个用例的答案。在使用此模型之前,您需要考虑一些事项。**发布者和订阅者的解耦是发布/订阅的关键,它本身也带来了一些挑战。例如,您需要事先了解已发布数据的结构。对于基于主题的过滤,发布者和订阅者都需要知道要使用哪些主题。要记住的另一件事是消息传递。发布者不能假定有人正在收听所发送的消息。在某些情况下,可能没有订阅者阅读特定消息。


8. 主要特性



  • MQTT 在空间上解耦了发布者和订阅者。要发布或接收消息,发布者和订阅者只需要知道代理的主机名/IP 和端口。

  • MQTT 按时间解耦。尽管大多数 MQTT 用例近乎实时地传递消息,但如果需要,代理可以为不在线的客户端存储消息。(必须满足两个条件才能存储消息:客户端已连接到持久会话并订阅了服务质量大于 0 的主题)。

  • MQTT 异步工作。因为大多数客户端库异步工作并且基于回调或类似模型,所以任务在等待消息或发布消息时不会被阻塞。在某些用例中,同步是可取且可能的。为了等待某个消息,一些库有同步 API。但流程通常是异步的。


二、MQTT通信过程


1. 连接到MQTT服务器


使用MQTT协议建立通信的第一步是连接到MQTT服务器。MQTT客户端需要提供MQTT服务器的IP地址和端口号,以建立到服务器的TCP连接。一旦连接建立成功,客户端将发送连接请求(Connect Packet)到MQTT服务器,服务器将响应确认请求。


2. 发布主题


发布者(Publisher)将消息发布到特定的主题上。在MQTT中,主题是消息的标识符。主题可以是任何有效的UTF-8字符串,并且可以包含多个层次结构(例如,/sensors/temperature)。当发布者发送消息到主题时,服务器将转发该消息给所有订阅该主题的订阅者。


3. 订阅主题


订阅者(Subscriber)可以订阅感兴趣的主题。在MQTT中,订阅者可以订阅整个主题树,或仅订阅特定的主题。当订阅者订阅主题时,服务器将记录其订阅信息,并将其添加到订阅列表中。


4. 接收消息


一旦订阅者订阅了主题,服务器将转发所有发布到该主题的消息给订阅者。当订阅者接收到消息时,它将执行相应的操作,例如更新设备状态或向其他设备发送命令。


5. 断开连接


使用完MQTT协议后,客户端应该断开与MQTT服务器的连接。MQTT客户端将发送断开请求(Disconnect Packet)到MQTT服务器,服务器将响应确认请求并断开连接。


三、MQTT常用术语



  1. Broker:MQTT的中间件,负责接收和转发消息。

  2. Client:MQTT的客户端,可以是发布者或订阅者。

  3. Topic:MQTT的消息主题,用于识别消息的内容和目的地。格式: “myhome/livingroom/temperature”或“Germany/Munich/Octoberfest/people”

  4. QoS(Quality of Service):MQTT消息的服务质量,分为三个级别:QoS 0,QoS 1和QoS 2。

  5. Retain:MQTT消息的保留标志,表示该主题上最新的消息是否需要保留。

  6. Last Will and Testament(LWT):MQTT客户端的遗嘱消息,用于在客户端离线时通知其他客户端。

  7. Clean Session:MQTT客户端连接时的清理会话标志,用于指示中间件是否保留客户端的订阅信息。


四、总结


MQTT协议的优点



  1. 简单和轻量级:MQTT协议非常简单和轻量级,适合于小型设备和带宽受限的环境。

  2. 可靠:MQTT协议具有多种消息传递保证机制,例如QoS级别,可确保消息可靠地传递到目标设备。

  3. 灵活性:MQTT协议具有灵活的主题订阅机制,允许客户端订阅不同级别的主题。

  4. 可拓展性:MQTT协议支持多个客户端连接到单个服务器,并且可以扩展到支持数百万个设备。


MQTT协议的缺点:



  • 安全性:MQTT协议本身没有提供加密和身份验证机制。如果需要安全通信,则需要使用TLS/SSL等其他协议。

  • 可靠性受限:MQTT提供了不同的服务质量(QoS)级别,但最高的QoS级别也不能保证消息100%可靠传递。在不稳定的网络环境下,消息可能会丢失或重复传递,需要应用程序自行处理。

  • 适用场景受限:MQTT适用于传递简单的消息,但不适用于传递大量的数据或复杂的消息。在需要进行复杂消息处理和转换的场景中,可能需要使用更为复杂的消息传递技术,例如消息队列。

  • 性能受限:MQTT是一种轻量级的协议,但在高并发和大规模消息传递的环境中,可能会面临性能瓶颈。此外,在使用较高的QoS级别时,可能会导致更多的网络流量和延迟,从而影响系统的性能。

  • 可扩展性受限:MQTT本身不提供扩展性的支持,需要使用其他技术来实现分布式消息传递和扩展性。


MQTT其他协议对比:


与其他通信协议相比,MQTT具有一定的优势:



  1. 与HTTP对比:HTTP是一种请求/响应模型的通信协议,适用于网页浏览等场景。相较于HTTP,MQTT协议更轻量级,适用于低带宽、不稳定网络环境。同时,MQTT基于发布/订阅模式,支持实时数据推送,而HTTP需要轮询获取数据,实时性较差。

  2. 与WebSocket对比:WebSocket是一种双向通信协议,适用于实时Web应用。与WebSocket相比,MQTT协议在低带宽和低功耗场景下具有更高的性能优势。此外,MQTT协议内置消息队列和QoS(Quality of Service,服务质量)机制,可确保消息可靠传输。

  3. 与CoAP对比:CoAP(Constrained Application Protocol,受限应用协议)是另一种物联网通信协议,主要针对资源受限的设备。相较于CoAP,MQTT协议在低带宽环境下具有更好的性能。然而,CoAP协议基于UDP,具有较低的传输延迟。二者之间的选择取决于具体应用场景和需求。

作者:程序员昊白
链接:https://juejin.cn/post/7224794158744862776
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

Android 带你重新认知属性动画

前言 之前写过一篇关于属性动画简单使用的文章juejin.cn/post/714417… 虽然官方直接提供的属性动画只有4个效果:透明度、位移、旋转、缩放,然后用Set实现组合,用插值器加一些效果。但其实属性动画能做的超越你的想象,他能做到anything。你...
继续阅读 »

前言


之前写过一篇关于属性动画简单使用的文章juejin.cn/post/714417…


虽然官方直接提供的属性动画只有4个效果:透明度、位移、旋转、缩放,然后用Set实现组合,用插值器加一些效果。但其实属性动画能做的超越你的想象,他能做到anything。你可以实现各种你所想象的效果,改图片形状、路径的动画、颜色的变化等(当然这得是矢量图)。而插值器,除了系统提供的那些插值器之外,你还能进行自定义实现你想要的运动效果。


实现的效果


我这里拿个形变的效果来举例。可以先看看实现的效果:


sp.gif


实现要点


要点主要有两点:(1)要去想象,到了这种程度包括更复杂的效果,没有人能教你的,只能靠自己凭借经验和想象力去规划怎么实现。 (2)要计算,一般做这种自定义的往往会涉及计算的成分,所以你要实现的效果越高端,需要计算的操作就越复杂。


思路


我做这个播放矢量图和暂停矢量图之间的形变,这个思路是这样的: 其实那个三角形是由两部分组成,左边是一个矩形(转90度的梯形),右边是一个三角形。然后把两个图形再分别变成长方形。具体计算方式是我把width分成4份,然后配合一个偏移量offset去进行调整(计算的部分没必要太纠结,都是要调整的)


步骤:



  1. 绘制圆底和两个图形

  2. 属性动画

  3. 页面退出后移除动画


1. 绘制圆底和两个图形


一共三个Paint


init {
paint = Paint()
paint2 = Paint()
paint3 = Paint()

paint?.color = context.resources.getColor(R.color.kylin_main_color)
paint?.isAntiAlias = true
paint2?.color = context.resources.getColor(R.color.kylin_white)
paint2?.style = Paint.Style.FILL
paint2?.isAntiAlias = true
paint3?.color = context.resources.getColor(R.color.kylin_white)
paint3?.isAntiAlias = true
}

绘制圆底就比较简单


paint?.let {
canvas?.drawCircle((width/2).toFloat(), (height/2).toFloat(), (width/2).toFloat(),
it
)
}

然后先看看我的一个参考距离的计算(有这个参考距离,才能让图形大小跟着宽高而定,而不是写死)


override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
super.onLayout(changed, left, top, right, bottom)
if (baseDim == 0f){
baseDim = (0.25 * width).toFloat()
}
}

另外两个图用路径实现


if (path1 == null || path2 == null){
path1 = Path()
path2 = Path()
// 设置初始状态
startToStopAnim(0f)
}
paint2?.let { canvas?.drawPath(path1!!, it) }
paint3?.let { canvas?.drawPath(path2!!, it) }

看具体的绘制实现


private fun startToStopAnim(currentValue : Float){
val offset : Int = (baseDim * 0.25 * (1-currentValue)).toInt()

path1?.reset()
path1?.fillType = Path.FillType.WINDING
path1?.moveTo(baseDim + offset, baseDim) // 点1不变
path1?.lineTo(2 * baseDim+ offset - baseDim/3*currentValue,
baseDim + (0.5 * baseDim).toInt() * (1-currentValue))
path1?.lineTo(2 * baseDim+ offset - baseDim/3*currentValue,
2 * baseDim +(0.5 * baseDim).toInt() + (0.5 * baseDim).toInt() * currentValue)
path1?.lineTo(baseDim+ offset, 3 * baseDim) // 点4不变
path1?.close()


path2?.reset()
path2?.fillType = Path.FillType.WINDING
if (currentValue <= 0f) {
path2?.moveTo(2 * baseDim + offset, baseDim + (0.5 * baseDim).toInt())
path2?.lineTo(3 * baseDim + offset, 2 * baseDim)
path2?.lineTo(2 * baseDim + offset, 2 * baseDim + (0.5 * baseDim).toInt())
}else {
path2?.moveTo(2 * baseDim+ offset + baseDim/3*currentValue,
baseDim + (0.5 * baseDim).toInt() * (1-currentValue))
path2?.lineTo(3 * baseDim + offset, baseDim + baseDim * (1-currentValue))
path2?.lineTo(3 * baseDim + offset, 2 * baseDim + baseDim * currentValue)
path2?.lineTo(2 * baseDim+ offset + baseDim/3*currentValue,
2 * baseDim +(0.5 * baseDim).toInt() + (0.5 * baseDim).toInt() * currentValue)
}
path2?.close()
}

这个计算的过程不好解释,加偏移量就是一个调整的过程,可以去掉偏移量offset看看效果就知道为什么要加了。path1代表左边的路径,左边的路径是4个点,path2是右边的路径,右边的路径会根据情况去决定是3个点还是4个点,默认情况是3个。


2、属性动画


fun startToStopChange(){
isRecordingStart = true
if (mValueAnimator1 == null) {
mValueAnimator1 = ValueAnimator.ofFloat(0f, 1f)
mValueAnimator1?.addUpdateListener {
val currentValue: Float = it.animatedValue as Float
startToStopAnim(currentValue)
postInvalidate()
}
mValueAnimator1?.interpolator = AccelerateInterpolator()
}
mValueAnimator1?.setDuration(500)?.start()
}

float类型0到1其实就是实现一个百分比的效果。变过去能实现后,变回来就也就很方便


fun stopToStartChange(){
isRecordingStart = false
if (mValueAnimator2 == null) {
mValueAnimator2 = ValueAnimator.ofFloat(1f, 0f)
mValueAnimator2?.addUpdateListener {
val currentValue: Float = it.animatedValue as Float
startToStopAnim(currentValue)
postInvalidate()
}
mValueAnimator2?.interpolator = AccelerateInterpolator()
}
mValueAnimator2?.setDuration(500)?.start()
}

3.移除动画


view移除后要移除动画


fun close(){
try {
if (mValueAnimator1?.isStarted == true){
mValueAnimator1?.cancel()
}
if (mValueAnimator2?.isStarted == true){
mValueAnimator2?.cancel()
}
}catch (e : Exception){
e.printStackTrace()
}finally {
mValueAnimator1 = null
mValueAnimator2 = null
}
}

然后还要注意,这个动画是耗时操作,所以要做防快速点击。


总结


从代码可以看出,其实并实现起来并不难,难的在于自己要有想象力,要能想出这样的一个过程,比较花费时间的可能就是一个调整的过程,其它也基本没什么技术难度。


我这个也只是简单做了个Demo来演示,你要问能不能实现其它效果,of course,你甚至可以先把三角形变成一个正方形,再变成两个长方形等等,你甚至可以用上贝塞尔来实现带曲线的效果。属性动画就是那么的强大,对于矢量图,它能实现几乎所有的你想要的效果,只有你想不到,没有它做不到。


作者:流浪汉kylin
链接:https://juejin.cn/post/7144190782205853732
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

🔥面试官想听的离职原因清单

交锋 面试官:方便说下离职原因吗? 掘友1:不方便 掘友2:在前公司长期工作量有些太大了,我自己身体上也出现了一些信号,有段时间都完全睡不着觉,所以需要切换一个相对来讲工作量符合我个人要求的,比如说周末可以双休这样一个情况,这个对我现在的选择来讲还蛮重要的 掘...
继续阅读 »

交锋


面试官:方便说下离职原因吗?


掘友1:不方便


掘友2:在前公司长期工作量有些太大了,我自己身体上也出现了一些信号,有段时间都完全睡不着觉,所以需要切换一个相对来讲工作量符合我个人要求的,比如说周末可以双休这样一个情况,这个对我现在的选择来讲还蛮重要的


掘友3:本来已经定好的前端负责人(组长),被关系户顶掉了,我需要一个相对公平的竞争环境,所以打算换个公司


掘友4:实不相瞒,一年前我投过咱们公司(或者面试过但没过),一年了,你知道我这一年是怎么过的吗,因为当时几轮面试都很顺利的,结果却回复我说有更合适的人选了,我难受了很久,因为真的很想进入咱们公司,于是我奋发图强,每天熬夜学习到凌晨两点半,如今学有所成,所以又来了


掘友5:团队差不多解散了吧,领导层变动,没多久时间原团队基本都走了,相当于解散了吧,现在剩几个关系户,干的不开心


掘友6:公司要开发一些灰产(买马/赌球/时时彩之类的),老员工都不愿意搞,就都要我来做,我堂堂掘友6可是与赌毒不共戴天的人,怎么会干这种事(就是害怕坐牢),就辞职了(这是位入职时间不长的掘友)


掘友7:公司业务调整,然后突然让我去外地分公司驻场/让我去搞 flutter(原本是前后端),虽然是个好机会可还是很难受,而且与我的职业发展规划不符,所以不想浪费时间,就第一时间辞职了


掘友8:前东家对我挺好的,工作也得心应手(进入舒适圈了),只是我不想一直呆在舒适圈,我不是那种混日子的人,所以希望跳出来,找一份更有挑战性,更有成就感的工作,贵公司的岗位很符合我的预期


掘友9:公司最近经营不理想:1.不给交社保/公积金了,2.拖欠几个月工资了,好不容易攒的奶粉钱都花完啦(虽然还单身,可也是有想法的),为了生活,这不办法呀,3.公司倒闭了,现在十几个同事都在找工作,咱们这还需要前后端、产品、设计、测试吗,我可以内推


掘友10:您可能也知道现在各行各业行情都不太好,很多公司都裁撤了部分业务,前公司前几年疫情时就已是踏雪而行了,现在在新业务的选择上就决定裁撤掉原来的业务线,我也是其中一员,虽然很遗憾但也能接受吧,在前公司这两年也是学到了很多


掘友11:我其实挺感谢上家公司的,各方面都挺好的,也给了我很好的成长空间,但是也三年多时间了,我的薪资也没涨过,相信你也知道,其实我现在的薪资能够值得更好的,嗯被认可


掘友12:克扣工资,领导说以后生产环境上出现一次 bug 就要扣所有参与的人工资,说真的,每天加班加点的干,我们都没问题,可结果就被这样对待,被连带扣了几次之后心里真的很难受


掘友13:回老家发展咯/对象在这边咯,因为准备结婚了,之后一直在这边发展定居了(这种换城市的回答要给出准备结婚或定居发展这样的原因,不然谈个对象就换城市会显得不靠谱);如果是小城市换大城市,可以直接说是为了高薪来的,因为家里买房了生孩子了啥的经济压力大,顾家其实是能体现稳定的,也给砍价打个预防针


掘友14:(有断层,面试时间和上次离职时间相隔时间有点长,有两三个月左右的,如果真实情况是家里或者生病啥的直说就好,如果只是找了几个月工作没找到,就要组织下语言了),由于长时间加班的原因,身体受到了影响每天睡不好觉,那段时间一直不在状态,没法好好投入工作,就想休息一段时间,为避免给公司造成不好的影响,所以辞职了。当时领导坚持批我几天假,我自己也不知道具体多久能恢复过来,毕竟那种种状态也不是一天两天了,还是坚持让领导批我的辞职了,然后这段时间我去了哪哪哪,身体已经调整过来了,可以全身心投入工作了,不过现在找工作希望是周末可以双休这样一个情况,这个对我现在的选择来讲还蛮重要的


(如果断层有一年的左右的,我有一段经历可以给大家参考下)我当时没工作了,家里投了点钱让我和一个亲戚合伙搞了点生意,结果赚了点钱,但那个亲戚喜欢赌钱,被他拿去赌了,输光了,于是我撤出来了


沐华:就是觉得翅膀硬了,想出去看看(其实这是我入职现公司面试时说的离职原因,当时面试官听着就笑了)


第一轮回答结束!





心法


离职原因真实情况绝大多数情况无非就几种:钱少了,不开心了,被裁了。


大家都差不多的,面试官心里也知道,可这能直说吗?


直说也不是不行,但是要注意表达方式,回答时有些场面话/润色一下还是需要的,去掉负面的字句,目的是让人家听的人舒服一点而已,毕竟谁也不喜欢一个陌生人来向自己诉苦抱怨,发牢骚吧,谁都希望认识正能量/积极向上的人吧


所以回答的关键在于:



  1. 不能是自己的能力、懒惰、不稳定等原因,或可能影响团队的性格缺陷

  2. 不要和现任说前任的不好,除非客观原因没办法,但也要知道即便是前公司真实存在的问题,hr 并不了解真实情况,还是会对是前公司有问题,还是你有问题持怀疑态度的


就像分手原因,对别人说出来时不能显得自己很绝情,又不能让自己很跌份,而且很忌讳疯狂抹黑前任


公司想降低用人风险,看我们离职的原因在这里会不会再发生,所以我们回答中应该体现:稳定性、有想法、积极向上、找工作看重什么、想得到什么、有规划不是盲目找的....


忌讳:升职机会渺茫、个人发展遇到瓶颈、人际关系复杂受人排挤、勾心斗角氛围差...这样的回答会让人质疑是前公司的问题,还是你的能力/情商有问题?


那么,你觉得最好的答案是什么呢,如果你是面试官,会选谁进入下一轮?


作者:沐华
链接:https://juejin.cn/post/7225432788044267575
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

不想写代码的程序员可以尝试的几种职位

标题不够严谨,应该是不想写业务代码的程序员可以做什么。 这里主要覆盖大家可能平时没关注,或者是国内少见的工作;所以像 technical product manager, project manager 这种就不再赘述了。 这里也主要分享 IT 行业内的岗位,...
继续阅读 »

标题不够严谨,应该是不想写业务代码的程序员可以做什么。


这里主要覆盖大家可能平时没关注,或者是国内少见的工作;所以像 technical product manager, project manager 这种就不再赘述了。


这里也主要分享 IT 行业内的岗位,要是除开行业限制,范围就太大了。


Developer Relation/Advocate


国外有很多面向开发者的技术创新公司,比如 Vercel ,PlanetScale ,Prisma ,Algolia 等。


这类公司的用户就是开发者,所以他们的市场活动也都是围绕着开发者;他们需要让更多的开发者可以更容易地把他们的技术用到他们的技术栈里,所以就有了这种岗位。用中文来表达,可能有点类似是布道师的意思?


国内更多是将技术应用起来,而不是创造一些新的技术,所以这种岗位在国内就非常少见了。当然近几年也还是有一些技术驱动型公司的,像 PingCAP ,Agora 等。


希望国内有更多像这样的公司出来。


Technical Recruiter


这个工作从 title 上就大概知道是做什么的了。


这个岗位有深有浅,深的可能是比较完整的招聘职能,浅的可能就是 HR 部门里面试和筛选技术候选人的。


Technical Writer


这个听着像是产品经理的工作,确实会和产品的职责有小部分重叠。


这是个面向内部的岗位,不喜欢对外对用户 /客户的朋友会非常喜欢。通常是一些比较大型的企业要做软件迁移或者什么系统、流程升级之类的时候,因为会牵扯到非常多的 moving parts ,所以通常都需要一个独立岗位来负责 documentation 的工作。


工作内容包括采访以及记录各部门的现有流程和业务需求,然后是新流程 /系统 /软件的手册、图表等等。


这里的“technical”不是我们研发中的技术,更多是“业务”层面的意思。同样这个岗位对技术要求不高,但是有研发背景是非常加分的。


Technical Support


通常这个岗位归属客服部门,高于普通 customer service rep 。普通的 customer support 是客户遇到问题时的第一层支持 - 基本会讲话、了解产品就能干的工作;如果第一层解决不了客户的问题,就会升级到后面 technical support 了。


这个岗位范围会更广一点,几乎任何 IT 公司都会有这种支持岗;对技术要求根据不同公司而不同,比如 Vercel 对这个岗位的技术要求肯定比 HelpScout (一个客服软件)要高。


但整体来说都不如研发要求高,但对应的薪酬待遇也没有研发那么好。


结语


其实说了这么多总结下来就是国外技术生态、开源氛围好很多,并且对技术足够的重视,促使很多技术公司的出现,然后催生了这些工作。


如果觉得本帖有启发,欢迎留言支持鼓励后续的创作。




作者:强生
来源:juejin.cn/post/7229223235680895031

收起阅读 »

朝花夕拾 - 卷王的自白(光头祭天,法力无边)

一、震撼开场 做一个卷王 ta 有什么错,无非就是 —— 「秃」了那么一点点!!! 咳咳咳,一一回复: 自愿的 没有想不开 没有考到寺庙 心态正常 …… 如果非要给这次的行为贯穿一个理由,那就是「下周四就 28 岁了」「头发长长太快想凉快点」! 二、“正...
继续阅读 »

一、震撼开场


做一个卷王 ta 有什么错,无非就是 ——


04-10-01.jpg


「秃」了那么一点点!!!


咳咳咳,一一回复:



  • 自愿的

  • 没有想不开

  • 没有考到寺庙

  • 心态正常

  • ……


如果非要给这次的行为贯穿一个理由,那就是「下周四就 28 岁了」「头发长长太快想凉快点」!


二、“正文”


Hello 小伙伴们早上、中午、下午、晚上和深夜好,这里是 jsliang~


鸽了近一个月,终于能恢复正常作息,和小伙伴们一起折腾、聊天吹水、学习啦!


04-10-02.png


当然,这次我想在 jsliang 的「朝花夕拾」频道,和小伙伴们聊的,不仅仅是鸽了的这个月的内容。


更多的,咱们要从年初,乃至年前聊起。


虽然可能会聊到很多内容,但是咱们尽可能长话短说!



  1. 这几个月怎么过来的?

  2. 你觉得有意思的事情是什么?

  3. 你觉得很失败/颓的事情是什么?

  4. 这几个月发生的事情有哪些让你关注的?

  5. 后面想做啥事情?


三、话痨小剧场


本篇图文尽可能不涉及技术等硬通货


3.1 这几个月怎么过来的?


从 2 月过完年回来后,996 甚至偶尔 997 呀,然后喜提「卷王」称号。


大概故事线就是:



  1. jsliang 想挑战下自己

  2. 然后转开发组,挑战新项目

  3. 不巧作为几年老开发,评估需求失败,3 周的需求,愣是做了 10 周

  4. 于是「自愿」加班,顶着压力 996 乃至 997


Q:你干嘛哎哟!这么一说这几个月可歌可泣的故事,你一点都没体现啊!


04-10-03.png


A:这你就不懂了吧,这里不说的简单点,小伙伴们怎么往下看~


3.2 你觉得有意思的事情是什么?


这几个月感觉蛮有意思的事情,大概有那么几个。


首先,能学到一些没玩过的技术啦!


对于一些「浅薄」的技术,我总是那么沉迷,比如这一次学习了:



  1. Formily。阿里面向中后台复杂场景的表单解决方案

  2. Slate / tinymce。这 2 款不同的富文本编辑器,一种是 React,一种是 Vue,在 2 个不同项目都接触了


04-10-04.png


然后,就是对旧知识的巩固啦!


没错,就是你 React Hook~


有一说一每次写 Hook 我都很沉迷


—— 为什么这个组件多次渲染,为什么这个组件又不渲染了!


回头写一篇小作文吧,在这里吐槽占篇幅太大了。


接着,就是对升华身心的一种挑战。


这几个月被大佬吐槽过能力不行、需求管理没做好;


这几个月碰到过技术问题,经常辗转反侧想不通;


这几个月熬夜有点多,脸色蜡黄黑眼圈……


04-10-05.png


不过还好,每天坚持跑步和跟小伙伴吐槽,让我挺过来了,很有意思,下次别喊我体验了,哈哈~


最后,就是通过直播、发视频、写文章认识了更多的小伙伴。


现在 VX 有 2000+ 好友,距离 30 岁的 5000 好友又近了一步!


不同小伙伴让我认识了世界不一样的精彩~


3.3 你觉得很失败/颓的事情是什么?


这个算糗事集合了吧哈哈~


Round 1


小丑鸭碰到白天鹅的尴尬~


04-10-06.png


Round 2


如 3.2 所说,因为瞎排期,明明做了 10 周的需求,被我在需求稿上写成了 3 周。


然后,我就被骂了哈哈哈,没人撑我,甚是失败。


当时有想过跑路……


Round 3


赚的钱还是那么卑微而少,但是肉眼可见爸妈年轻不再。


有时候会迷茫啥时候能回家买地皮自己起楼,2023 年的机遇我到底抓住了没有。


04-10-07.png


以上,简单说说 3 件印象比较深刻的,后面有更多失败和令人颓废的事咱们再唠嗑唠嗑~


3.4 这几个月发生的事情有哪些让你关注的?


有 2 个:



  • 人工智能

  • 前端已死


当时本来想蹭热度去写写,后面自己把自己说服了,按表不发,等后面逐个打通(如果有小伙伴感兴趣听我吐槽的话)


目前只能说保持对这 2 个话题的关注,提升自己对这 2 块相关技能的学习。


其他的,慢慢来啦,咱走个长期攻略。


3.5 后面想做啥事情?


先补全一些遗憾:



  • CSS 系列更新到第 8 篇(当前第 5 篇,尽量补充几个实用性的)

  • 出门旅游 1 次

  • 补充文章+视频:人工智能

  • 补充文章+视频:前端已死

  • 恢复每日晚上 9:00-11:00 的直播


长期上,可能会关注一下「自由职业」和「独立能力」,毕竟真不能想象自己还能在一线做开发多久~


那么,就酱啦!


周六下午要加班,晚上我会把剃光头的视频和本期内容整合成一个小视频,晚上回去直播,欢迎关注光头前端!


See you tonight~




不折腾的前端,和咸鱼有什么区别!


觉得文章不错的小伙伴欢迎点赞/点 Star。


如果小伙伴需要联系 jsliang



个人联系方式存放在 Github 首页,欢迎一起折腾~


争取打造自己成为一个充满探索欲,喜欢折腾,乐于扩展自己知识面的终身学习斜杠程序员。


作者:jsliang
来源:juejin.cn/post/7223417872596697148
收起阅读 »

Android 中创建子线程的方式有哪几种

在 Android 中,创建子线程的方式通常有以下几种: 使用 Thread 类进行创建 Thread 是 Java 中的一个类,可以通过继承 Thread 类或者创建 Thread 对象并传入 Runnable 对象来创建子线程。例如: // 继承 Th...
继续阅读 »

在 Android 中,创建子线程的方式通常有以下几种:



  1. 使用 Thread 类进行创建 Thread 是 Java 中的一个类,可以通过继承 Thread 类或者创建 Thread 对象并传入 Runnable 对象来创建子线程。例如:


// 继承 Thread 类
public class MyThread extends Thread {
@Override
public void run() {
// 子线程要执行的代码
}
}

// 创建 Thread 对象并传入 Runnable 对象
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
// 子线程要执行的代码
}
});
thread.start();


  1. 使用 Runnable 接口进行创建 Runnable 是 Java 中的一个接口,可以通过实现 Runnable 接口并将其传入 Thread 对象来创建子线程。例如:


// 实现 Runnable 接口
public class MyRunnable implements Runnable {
@Override
public void run() {
// 子线程要执行的代码
}
}

// 创建 Thread 对象并传入 Runnable 对象
Thread thread = new Thread(new MyRunnable());
thread.start();


  1. 使用 AsyncTask 类进行创建 AsyncTask 是 Android 中的一个类,可以通过继承 AsyncTask 类并重写其方法来创建子线程。AsyncTask 可以方便地进行 UI 操作,并且不需要手动处理线程间通信问题。例如:


public class MyTask extends AsyncTask<Void, Void, Void> {
@Override
protected Void doInBackground(Void... voids) {
// 子线程要执行的代码
return null;
}

@Override
protected void onPostExecute(Void aVoid) {
// UI 操作
}
}

// 创建 AsyncTask 对象并调用 execute 方法
MyTask task = new MyTask();
task.execute();


  1. 使用线程池进行创建 线程池是一种可以重复利用线程的机制,可以减少创建和销毁线程所带来的开销。Android 中常用的线程池包括 ThreadPoolExecutor 和 ScheduledThreadPoolExecutor。例如:


// 创建 ThreadPoolExecutor 对象
ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());

// 创建 ScheduledThreadPoolExecutor 对象
ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);

综上所述,Android 中常用的创建子线程的方式有使用 Thread 类、使用 Runnable 接口、使用 AsyncTask 类和使用线程池。每种方式都有其优缺点,需要根据实际

作者:早起的年轻人
来源:juejin.cn/post/7229401405344415781
需求选择合适的方式。

收起阅读 »

Flutter App开发实现循环语句的方式

如果您有小程序、APP、公众号、网站相关的需求,您可以通过私信来联系我 Flutter 中循环语句的使用方式与其他编程语言比较类似,常见的包括 for 循环和 while 循环。 1 for 循环 Flutter 中的 for 循环语法如下: for (va...
继续阅读 »

如果您有小程序、APP、公众号、网站相关的需求,您可以通过私信来联系我



Flutter 中循环语句的使用方式与其他编程语言比较类似,常见的包括 for 循环和 while 循环。


1 for 循环


Flutter 中的 for 循环语法如下:


for (var i = 0; i < count; i++) {
// 循环体
}

其中的 count 为循环次数, i 初始值默认为 0,每次循环自增 1。在循环体内部可以编写需要重复执行的代码。 例如,以下代码循环输出 1 到 10 的数字:


for (var i = 1; i <= 10; i++) {
print(i);
}

下面是一个使用 for 循环实现的案例,用于遍历一个列表并输出其中的元素。假设有一个列表 fruits ,其中包含了一些水果,现在需要遍历列表并输出其中的每个元素:


List<String> fruits = ['apple', 'banana', 'orange', 'grape'];
for (String fruit in fruits) {
print(fruit);
}

上述代码中,使用 for 循环遍历了列表 fruits 中的每个元素,变量 fruit 用于存储当前循环到的元素,并输出了该元素。在每次循环中,变量 fruit 都会被更新为列表中的下一个元素,直到遍历完整个列表为止。


2 for in


在 Flutter 中, for...in 主要是用于遍历集合类型的数据,例如 List、Set 和 Map。


下面是一个使用 for...in 遍历 List 的案例:


List<int> numbers = [1, 2, 3, 4, 5];
for (int number in numbers) {
print(number);
}

上述代码中, numbers 是一个包含整数的 List, for...in 循环遍历该 List 中的每个元素,将每个元素赋值给变量 number ,并输出 number 的值。在每次遍历中, number 都会被更新为 List 中的下一个元素,直到遍历完整个 List 为止。


下面是一个使用 for...in 遍历 Map 的案例:


Map<String, String> fruits = {
'apple': 'red',
'banana': 'yellow',
'orange': 'orange',
'grape': 'purple'
};
for (String key in fruits.keys) {
print('$key is ${fruits[key]}');
}

上述代码中, fruits 是一个包含水果名称和颜色的 Map, for...in 循环遍历该 Map 中的每个键,将每个键赋值给变量 key ,并输出该键及其对应的值。在每次遍历中, key 都会被更新为 Map 中的下一个键,直到遍历完整个 Map 为止。


在遍历集合类型的数据时,使用 for...in 语句可以简化代码,避免了使用下标、索引等方式进行访问和处理,使代码更加易读、优雅。


3 while 循环


Flutter 中的 while 循环语法如下:


while (expression) {
// 循环体
}

其中, expression 是布尔表达式,循环体内部的代码会一直循环执行,直到 expression 不再为真时跳出循环。 例如,以下代码使用 while 循环实现输出 1 到 10 的数字:


var i = 1;
while (i <= 5) {
print(i);
i++;
}

上述代码中,我们定义了一个变量 i ,并使用 while 循环判断 i 是否小于 5,如果为真,则输出变量 i 的值并将 i 的值加 1,然后继续循环;如果为假,则跳出 while 循环。


在每次循环中,变量 i 都会被更新为上一次的值加 1,直到变量 i 的值达到 5 时, while 循环结束。


while 循环还可以和条件表达式一起使用,例如,下面是一个使用 while 循环判断列表是否为空的示例:


List<int> numbers = [1, 2, 3, 4, 5];
while (numbers.isNotEmpty) {
print(numbers.removeLast());
}

上述代码中,我们定义了一个包含整数的列表 numbers ,并使用 while 循环判断 numbers 是否为空,如果不为空,则输出列表中的最后一个元素并将其从列表中删除,然后继续循环;如果为空,则跳出 while 循环。
在每次循环中, numbers 列表都会被更新,直到列表为空时 while 循环结束。 使用 while 循环可以在满足一定条件的情况下,重复执行一组语句,从而实现某些特定的功能需求。


在使用 while 循环时,需要注意控制循环条件,避免出现死循环的情况。


以上就是 Flutter 中实现循环语句的方式。




如果你有兴趣,可以关注一下我的综合公

作者:早起的年轻人
来源:juejin.cn/post/7229388804611932217
众号:biglead

收起阅读 »

前端访问系统文件夹

随着前端技术和浏览器的升级,越来越多的功能可以在前端实现而不用依赖于后端。其中,访问系统文件夹是一个非常有用的功能,例如上传文件时,用户可以直接从自己的电脑中选择文件。 使用方法 在早期的浏览器中,要访问系统中的文件夹需要使用 ActiveX 控件或 Java...
继续阅读 »

随着前端技术和浏览器的升级,越来越多的功能可以在前端实现而不用依赖于后端。其中,访问系统文件夹是一个非常有用的功能,例如上传文件时,用户可以直接从自己的电脑中选择文件。


使用方法


在早期的浏览器中,要访问系统中的文件夹需要使用 ActiveX 控件或 Java Applet,这些方法已经逐渐淘汰。现在,访问系统文件夹需要使用HTML5的 API。


最常使用的 API 是FileAPI,配合 input[type="file"] 通过用户的交互行为来获取文件。但是,这种方法需要用户选择具体的文件而不是像在系统中打开文件夹来进行选择。


HTML5 还提供了更加高级的 API,如 showDirectoryPicker。它支持在浏览器中打开一个目录选择器,从而简化了选择文件夹的流程。这个 API 的使用也很简单,只需要调用 showDirectoryPicker() 方法即可。


async function pickDirectory() {
const directoryHandle = await window.showDirectoryPicker();
console.log(directoryHandle);
}

但是需要注意的是该api的兼容性较低,目前所支持的浏览器如下图所示:


image.png


点击一个按钮后,调用 pickDirectory() 方法即可打开选择文件夹的对话框,选择完文件夹后,该方法会返回一个 FileSystemFileHandle 对象,开发者可以使用这个对象来访问所选择的目录的内容。


应用场景


访问系统文件夹可以用于很多场景,下面列举几个常用的场景。


上传文件


在前端上传文件时,用户需要选择所需要上传的文件。这时,打开一个文件夹选择器,在用户选择了一个文件夹后,就可以读取文件夹中的文件并进行上传操作。


本地文件管理


将文件夹中的文件读取到前端后,可以在前端进行一些操作,如修改文件名、查看文件信息等。这个在 纯前端文件管理器 中就被广泛使用。


编辑器功能


访问系统文件夹可以将前端编辑器与本地的文件夹绑定,使得用户直接在本地进行编写代码,而不是将代码保存到云端,这对于某些敏感数据的处理尤为重要。


结尾的话


通过HTML5的 API,前端可以访问到系统中的文件夹,这项功能可以应用于上传文件、本地文件管理和编辑器功能等场景,为用户带来了极大的便利。


作者:白椰子
来源:juejin.cn/post/7222636308740014135
收起阅读 »

可视化大屏:vue-autofit 一行搞定自适应

web
可视化大屏适配/自适应现状 可视化大屏的适配是一个老生常谈的话题了,现在其实不乏一些大佬开源的自适应插件、工具但是我为什么还要重复造轮子呢?因为目前市面上适配工具每一个都无法做到完美的效果,做出来的东西都差不多,最终实现效果都逃不出白边的手掌心,可以解决白边问...
继续阅读 »

可视化大屏适配/自适应现状


可视化大屏的适配是一个老生常谈的话题了,现在其实不乏一些大佬开源的自适应插件、工具但是我为什么还要重复造轮子呢?因为目前市面上适配工具每一个都无法做到完美的效果,做出来的东西都差不多,最终实现效果都逃不出白边的手掌心,可以解决白边问题的,要么太过于复杂,要么会影响dom结构。


三大常用方式




  1. vw/vh方案



    1. 概述:按照设计稿的尺寸,将px按比例计算转为vwvh

    2. 优点:可以动态计算图表的宽高,字体等,灵活性较高,当屏幕比例跟 ui 稿不一致时,不会出现两边留白情况

    3. 缺点:每个图表都需要单独做字体、间距、位移的适配,比较麻烦




  2. scale方案



    1. 概述:也是目前效果最好的一个方案

    2. 优点:代码量少,适配简单 、一次处理后不需要在各个图表中再去单独适配.

    3. 缺点:留白,据说有事件热区偏移,但是我目前没有发现有这个问题,即使是地图也没有




  3. rem + vw vh方案



    1. 概述:这名字一听就麻烦,具体方法为获得 rem 的基准值 ,动态的计算html根元素的font-size ,图表中通过 vw vh 动态计算字体、间距、位移等

    2. 优点:布局的自适应代码量少,适配简单

    3. 缺点:留白,有时图表需要单独适配字体




基于此背景,我决定要造一个简单又好用的轮子。


解决留白问题


留白问题是在使用scale时才会出现,而其他方式实现起来又复杂,效果也不算太理想,总会破坏掉原有的结构,可能使元素挤在一起,所以我们还是选择使用scale方案,不过这次要做出一点小小的改变。


常用分辨率


首先来看一下我的拯救者的分辨率:


image-20230420141240837 它可以代表从1920往下的分辨率


我们可以发现,比例分别是:1.77、1.6、1.77、1.6、1.33... 总之,没有特别夸张的宽高比。


计算补齐白边所需的px


只要没有特别夸张的宽高比,就不会出现特别宽或者特别高的白边,那么我们能不能直接将元素宽高补过去?也就是说,当屏幕右侧有白边时,我们就让宽度多出一个白边的px,当屏幕下方有白边时,我们就让高度多出一个白边的px。


很喜欢CSGO玩家的一句话:"啊?"


先想一下,如果此时按宽度比例缩放,会在下方留下白边,所以设置一下它的高度,设置多少呢?比如 scale==0.8 ,也就是说整个#app缩小了0.8倍,我们需要将高扩大多少倍才可以回到原来的大小呢?


QQ录屏20230420144111


emmm.....


算数我最不在行了,启动高材生


image-20230420143742913


原来是八分之十,我vue烧了。


当浏览器窗口比设计稿大或者小的时候,就应该触发缩放,但是比例不一定,如果按照scale等比缩放时,宽度从1920缩小0.8倍也就是1536,而高度缩小0.8也就是743,如果此时浏览器高度过高,那么就会出现下方的白边,根据高材生所说的,缩小0.8后只需要放大八分之十就可以变回原大小,所以以现在的高度743*1.25=928,使宽度=928px就可以完全充满白边!


真的是这样吗?感觉哪里不对劲...


是浏览器高度!我忽略了浏览器高度,我可以直接使用浏览器高度乘以1.25然后再缩放达0.8!就是 1 !


也就是说 clientHeight / scale 就等于我们需要的高度!


我们用代码试一试


function keepFit(designWidth, designHeight, renderDom) {
 let clientHeight = document.documentElement.clientHeight;
 let clientWidth = document.documentElement.clientWidth;
 let scale = 1;
 if (clientWidth / clientHeight < designWidth / designHeight) {
   scale = (clientWidth / designWidth)
   document.querySelector(renderDom).style.height = `${clientHeight / scale}px`;
} else {
   scale = (clientHeight / designHeight)
   document.querySelector(renderDom).style.width = `${clientWidth / scale}px`;
}
 document.querySelector(renderDom).style.transform = `scale(${scale})`;
}

上面的代码可能看起来乱糟糟的,我来解释一下:


参数分别是:设计稿的宽高和你要适配的元素,在vue中可以直接传#app。


下面的if判断的是宽度固定还是高度固定,当屏幕宽高比小于设计宽高比时,


我们把高度写成 clientHeight / scale ,宽度也是同理。


最终效果


将这段代码放到App.vue的mounted运行一下


autofit


如上图所示:我们成功了,我们仅用了1 2 3 4....这么几行代码,就做到了足以媲美复杂写法的自适应!


我把这些东西封装了一个npm包:vue-autofit ,开箱即用,欢迎下载!


亲手打造集成工具:vue-autofit


这是一款可以使你的项目一键自适应的工具 github源码👉go



  • 从npm下载


npm i vue-autofit


  • 引入


import autofit from 'vue-autofit'


  • 快速开始


autofit.init()


默认参数为1920*929(即去掉浏览器头的1080), 直接在大屏启动时调用即可




  • 使用


export default {  
 mounted() {
 autofit.init({
       designHeight: 1080,
       designWidth: 1920,
       renderDom:"#app",
       resize: true
  })
},
}


以上使用的是默认参数,可根据实际情况调整,参数分别为


   * - renderDom(可选):渲染的dom,默认是 "#app",必须使用id选择器 
  * - designWidth(可选):设计稿的宽度,默认是 1920
  * - designHeight(可选):设计稿的高度,默认是 929 ,如果项目以全屏展示,则可以设置为1080
  * - resize(可选):是否监听resize事件,默认是 true


结语


诺克萨斯即将崛起


作者:德莱厄斯
来源:juejin.cn/post/7224015103481118757
收起阅读 »

上手 Vue 新的状态管理 Pinia,一篇文章就够了

web
Vuex 作为一个老牌 Vue 状态管理库,大家都很熟悉了 Pinia 是 Vue.js 团队成员专门为 Vue 开发的一个全新的状态管理库,并且已经被纳入官方 github 为什么有 Vuex 了还要再开发一个 Pinia ? 先来一张图,看下当时对于 Vu...
继续阅读 »

Vuex 作为一个老牌 Vue 状态管理库,大家都很熟悉了


Pinia 是 Vue.js 团队成员专门为 Vue 开发的一个全新的状态管理库,并且已经被纳入官方 github


为什么有 Vuex 了还要再开发一个 Pinia ?


先来一张图,看下当时对于 Vuex5 的提案,就是下一代 Vuex5 应该是什么样子的


微信图片_20220314212501.png


Pinia 就是完整的符合了他当时 Vuex5 提案所提到的功能点,所以可以说 Pinia 就是 Vuex5 也不为过,因为它的作者就是官方的开发人员,并且已经被官方接管了,只是目前 Vuex 和 Pinia 还是两个独立的仓库,以后可能会合并,也可能独立发展,只是官方肯定推荐的是 Pinia


因为在 Vue3 中使用 Vuex 的话需要使用 Vuex4,还只能作为一个过渡的选择,存在很大缺陷,所以在 Componsition API 诞生之后,也就设计了全新的状态管理 Pinia


Pinia 和 Vuex


VuexStateGettesMutations(同步)、Actions(异步)


PiniaStateGettesActions(同步异步都支持)


Vuex 当前最新版是 4.x



  • Vuex4 用于 Vue3

  • Vuex3 用于 Vue2


Pinia 当前最新版是 2.x



  • 即支持 Vue2 也支持 Vue3


就目前而言 Pinia 比 Vuex 好太多了,解决了 Vuex 的很多问题,所以笔者也非常建议直接使用 Pinia,尤其是 TypeScript 的项目


Pinia 核心特性



  • Pinia 没有 Mutations

  • Actions 支持同步和异步

  • 没有模块的嵌套结构

    • Pinia 通过设计提供扁平结构,就是说每个 store 都是互相独立的,谁也不属于谁,也就是扁平化了,更好的代码分割且没有命名空间。当然你也可以通过在一个模块中导入另一个模块来隐式嵌套 store,甚至可以拥有 store 的循环依赖关系



  • 更好的 TypeScript 支持

    • 不需要再创建自定义的复杂包装器来支持 TypeScript 所有内容都类型化,并且 API 的设计方式也尽可能的使用 TS 类型推断



  • 不需要注入、导入函数、调用它们,享受自动补全,让我们开发更加方便

  • 无需手动添加 store,它的模块默认情况下创建就自动注册的

  • Vue2 和 Vue3 都支持

    • 除了初始化安装和SSR配置之外,两者使用上的API都是相同的



  • 支持 Vue DevTools

    • 跟踪 actions, mutations 的时间线

    • 在使用了模块的组件中就可以观察到模块本身

    • 支持 time-travel 更容易调试

    • 在 Vue2 中 Pinia 会使用 Vuex 的所有接口,所以它俩不能一起使用

    • 但是针对 Vue3 的调试工具支持还不够完美,比如还没有 time-travel 功能



  • 模块热更新

    • 无需重新加载页面就可以修改模块

    • 热更新的时候会保持任何现有状态



  • 支持使用插件扩展 Pinia 功能

  • 支持服务端渲染


Pinia 使用


Vue3 + TypeScript 为例


安装


npm install pinia

main.ts 初始化配置


import { createPinia } from 'pinia'
createApp(App).use(createPinia()).mount('#app')

在 store 目录下创建一个 user.ts 为例,我们先定义并导出一个名为 user 的模块


import { defineStore } from 'pinia'
export const userStore = defineStore('user', {
state: () => {
return {
count: 1,
arr: []
}
},
getters: { ... },
actions: { ... }
})

defineStore 接收两个参数


第一个参数就是模块的名称,必须是唯一的,多个模块不能重名,Pinia 会把所有的模块都挂载到根容器上

第二个参数是一个对象,里面的选项和 Vuex 差不多



  • 其中 state 用来存储全局状态,它必须是箭头函数,为了在服务端渲染的时候避免交叉请求导致的数据状态污染所以只能是函数,而必须用箭头函数则为了更好的 TS 类型推导

  • getters 就是用来封装计算属性,它有缓存的功能

  • actions 就是用来封装业务逻辑,修改 state


访问 state


比如我们要在页面中访问 state 里的属性 count


由于 defineStore 会返回一个函数,所以要先调用拿到数据对象,然后就可以在模板中直接使用了


如下这样通过 store.xxx 使用,是具备响应式的


<template>
<div>{{ store.count }}</div>
</template>
<script lang="ts" setup>
import { userStore } from '../store'
const store = userStore()
// 解构
// const { count } = userStore()
</script>


比如像注释中的解构出来使用,也可以用,只是这样拿到的数据不是响应式的,如果要解构还保持响应式就要用到一个方法 storeToRefs(),示例如下


<template>
<div>{{ count }}</div>
</template>
<script lang="ts" setup>
import { storeToRefs } from 'pinia'
import { userStore } from '../store'
const { count } = storeToRefs(userStore())
</script>


原因就是 Pinia 其实是把 state 数据都做了 reactive 处理,和 Vue3 的 reactive 同理,解构出来的也不是响应式,所以需要再做 ref 响应式代理


getters


这个和 Vuex 的 getters 一样,也有缓存功能。如下在页面中多次使用,第一次会调用 getters,数据没有改变的情况下之后会读取缓存


<template>
<div>{{ myCount }}</div>
<div>{{ myCount }}</div>
<div>{{ myCount }}</div>
</template>

注意两种方法的区别,写在注释里了


getters: {
// 方法一,接收一个可选参数 state
myCount(state){
console.log('调用了') // 页面中使用了三次,这里只会执行一次,然后缓存起来了
return state.count + 1
},
// 方法二,不传参数,使用 this
// 但是必须指定函数返回值的类型,否则类型推导不出来
myCount(): number{
return this.count + 1
}
}

更新和 actions


更新 state 里的数据有四种方法,我们先看三种简单的更新,说明都写在注释里了


<template>
<div>{{ user_store.count }}</div>
<button @click="handleClick">按钮</button>
</template>
<script lang="ts" setup>
import { userStore } from '../store'
const user_store = userStore()
const handleClick = () => {
// 方法一
user_store.count++

// 方法二,需要修改多个数据,建议用 $patch 批量更新,传入一个对象
user_store.$patch({
count: user_store.count1++,
// arr: user_store.arr.push(1) // 错误
arr: [ ...user_store.arr, 1 ] // 可以,但是还得把整个数组都拿出来解构,就没必要
})

// 使用 $patch 性能更优,因为多个数据更新只会更新一次视图

// 方法三,还是$patch,传入函数,第一个参数就是 state
user_store.$patch( state => {
state.count++
state.arr.push(1)
})
}
</script>


第四种方法就是当逻辑比较多或者请求的时候,我们就可以封装到示例中 store/user.ts 里的 actions 里


可以传参数,也可以通过 this.xx 可以直接获取到 state 里的数据,需要注意的是不能用箭头函数定义 actions,不然就会绑定外部的 this 了


actions: {
changeState(num: number){ // 不能用箭头函数
this.count += num
}
}

调用


const handleClick = () => {
user_store.changeState(1)
}

支持 VueDevtools


打开开发者工具的 Vue Devtools 就会发现 Pinia,而且可以手动修改数据调试,非常方便


image.png


模拟调用接口


示例:


我们先定义示例接口 api/user.ts


// 接口数据类型
export interface userListType{
id: number
name: string
age: number
}
// 模拟请求接口返回的数据
const userList = [
{ id: 1, name: '张三', age: 18 },
{ id: 2, name: '李四', age: 19 },
]
// 封装模拟异步效果的定时器
async function wait(delay: number){
return new Promise((resolve) => setTimeout(resolve, delay))
}
// 接口
export const getUserList = async () => {
await wait(100) // 延迟100毫秒返回
return userList
}

然后在 store/user.ts 里的 actions 封装调用接口


import { defineStore } from 'pinia'
import { getUserList, userListType } from '../api/user'
export const userStore = defineStore('user', {
state: () => {
return {
// 用户列表
list: [] as userListType // 类型转换成 userListType
}
},
actions: {
async loadUserList(){
const list = await getUserList()
this.list = list
}
}
})

页面中调用 actions 发起请求


<template>
<ul>
<li v-for="item in user_store.list"> ... </li>
</ul>

</template>
<script lang="ts" setup>
import { userStore } from '../store'
const user_store = userStore()
user_store.loadUserList() // 加载所有数据
</script>


跨模块修改数据


在一个模块的 actions 里需要修改另一个模块的 state 数据


示例:比如在 chat 模块里修改 user 模块里某个用户的名称


// chat.ts
import { defineStore } from 'pinia'
import { userStore } from './user'
export const chatStore = defineStore('chat', {
actions: {
someMethod(userItem){
userItem.name = '新的名字'
const user_store = userStore()
user_store.updateUserName(userItem)
}
}
})

user 模块里


// user.ts
import { defineStore } from 'pinia'
export const userStore = defineStore('user', {
state: () => {
return {
list: []
}
},
actions: {
updateUserName(userItem){
const user = this.list.find(item => item.id === userItem.id)
if(user){
user.name = userItem.name
}
}
}
})

结语


如果本文对你有一点点帮助,点个赞支持一下吧,你的每一个【赞】都是我创作的最大动力,感谢支持 ^_^


更多前端文章,或者加入前端交流群,欢迎关注公众号【沐华说技术】,大家一起共同交流和进步呀





往期精彩


【保姆级】Vue3 开发文档


Vue3的8种和Vue2的12种组件通信,值得收藏


作者:沐华
来源:juejin.cn/post/7075491793642455077
收起阅读 »

🔥面试官想听的离职原因清单

大家好,我是沐华。今天聊一个面试的问题 由于面试官还要摸鱼刷沸点,不想花那么多时间一个个面,所以采用群面的方式,就出现了上图这样的场景 交锋 面试官:方便说下离职原因吗? 掘友1:不方便 掘友2:在前公司长期工作量有些太大了,我自己身体上也出现了一些信号,有段...
继续阅读 »

大家好,我是沐华。今天聊一个面试的问题


由于面试官还要摸鱼刷沸点,不想花那么多时间一个个面,所以采用群面的方式,就出现了上图这样的场景


交锋


面试官:方便说下离职原因吗?


掘友1:不方便


掘友2:在前公司长期工作量有些太大了,我自己身体上也出现了一些信号,有段时间都完全睡不着觉,所以需要切换一个相对来讲工作量符合我个人要求的,比如说周末可以双休这样一个情况,这个对我现在的选择来讲还蛮重要的


掘友3:本来已经定好的前端负责人(组长),被关系户顶掉了,我需要一个相对公平的竞争环境,所以打算换个公司


掘友4:实不相瞒,一年前我投过咱们公司(或者面试过但没过),一年了,你知道我这一年是怎么过的吗,因为当时几轮面试都很顺利的,结果却回复我说有更合适的人选了,我难受了很久,因为真的很想进入咱们公司,于是我奋发图强,每天熬夜学习到凌晨两点半,如今学有所成,所以又来了


掘友5:团队差不多解散了吧,领导层变动,没多久时间原团队基本都走了,相当于解散了吧,现在剩几个关系户,干的不开心


掘友6:公司要开发一些灰产(买马/赌球/时时彩之类的),老员工都不愿意搞,就都要我来做,我堂堂掘友6可是与赌毒不共戴天的人,怎么会干这种事(就是害怕坐牢),就辞职了(这是位入职时间不长的掘友)


掘友7:公司业务调整,然后突然让我去外地分公司驻场/让我去搞 flutter(原本是前后端),虽然是个好机会可还是很难受,而且与我的职业发展规划不符,所以不想浪费时间,就第一时间辞职了


掘友8:前东家对我挺好的,工作也得心应手(进入舒适圈了),只是我不想一直呆在舒适圈,我不是那种混日子的人,所以希望跳出来,找一份更有挑战性,更有成就感的工作,贵公司的岗位很符合我的预期


掘友9:公司最近经营不理想:1.不给交社保/公积金了,2.拖欠几个月工资了,好不容易攒的奶粉钱都花完啦(虽然还单身,可也是有想法的),为了生活,这不办法呀,3.公司倒闭了,现在十几个同事都在找工作,咱们这还需要前后端、产品、设计、测试吗,我可以内推


掘友10:您可能也知道现在各行各业行情都不太好,很多公司都裁撤了部分业务,前公司前几年疫情时就已是踏雪而行了,现在在新业务的选择上就决定裁撤掉原来的业务线,我也是其中一员,虽然很遗憾但也能接受吧,在前公司这两年也是学到了很多


掘友11:我其实挺感谢上家公司的,各方面都挺好的,也给了我很好的成长空间,但是也三年多时间了,我的薪资也没涨过,相信你也知道,其实我现在的薪资能够值得更好的,嗯被认可


掘友12:克扣工资,领导说以后生产环境上出现一次 bug 就要扣所有参与的人工资,说真的,每天加班加点的干,我们都没问题,可结果就被这样对待,被连带扣了几次之后心里真的很难受


掘友13:回老家发展咯/对象在这边咯,因为准备结婚了,之后一直在这边发展定居了(这种换城市的回答要给出准备结婚或定居发展这样的原因,不然谈个对象就换城市会显得不靠谱);如果是小城市换大城市,可以直接说是为了高薪来的,因为家里买房了生孩子了啥的经济压力大,顾家其实是能体现稳定的,也给砍价打个预防针


掘友14:(有断层,面试时间和上次离职时间相隔时间有点长,有两三个月左右的,如果真实情况是家里或者生病啥的直说就好,如果只是找了几个月工作没找到,就要组织下语言了),由于长时间加班的原因,身体受到了影响每天睡不好觉,那段时间一直不在状态,没法好好投入工作,就想休息一段时间,为避免给公司造成不好的影响,所以辞职了。当时领导坚持批我几天假,我自己也不知道具体多久能恢复过来,毕竟那种种状态也不是一天两天了,还是坚持让领导批我的辞职了,然后这段时间我去了哪哪哪,身体已经调整过来了,可以全身心投入工作了,不过现在找工作希望是周末可以双休这样一个情况,这个对我现在的选择来讲还蛮重要的


(如果断层有一年的左右的,我有一段经历可以给大家参考下)我当时没工作了,家里投了点钱让我和一个亲戚合伙搞了点生意,结果赚了点钱,但那个亲戚喜欢赌钱,被他拿去赌了,输光了,于是我撤出来了


沐华:就是觉得翅膀硬了,想出去看看(其实这是我入职现公司面试时说的离职原因,当时面试官听着就笑了)


第一轮回答结束!





心法


离职原因真实情况绝大多数情况无非就几种:钱少了,不开心了,被裁了。


大家都差不多的,面试官心里也知道,可这能直说吗?


直说也不是不行,但是要注意表达方式,回答时有些场面话/润色一下还是需要的,去掉负面的字句,目的是让人家听的人舒服一点而已,毕竟谁也不喜欢一个陌生人来向自己诉苦抱怨,发牢骚吧,谁都希望认识正能量/积极向上的人吧


所以回答的关键在于:



  1. 不能是自己的能力、懒惰、不稳定等原因,或可能影响团队的性格缺陷

  2. 不要和现任说前任的不好,除非客观原因没办法,但也要知道即便是前公司真实存在的问题,hr 并不了解真实情况,还是会对是前公司有问题,还是你有问题持怀疑态度的


就像分手原因,对别人说出来时不能显得自己很绝情,又不能让自己很跌份,而且很忌讳疯狂抹黑前任


公司想降低用人风险,看我们离职的原因在这里会不会再发生,所以我们回答中应该体现:稳定性、有想法、积极向上、找工作看重什么、想得到什么、有规划不是盲目找的....


忌讳:升职机会渺茫、个人发展遇到瓶颈、人际关系复杂受人排挤、勾心斗角氛围差...这样的回答会让人质疑是前公司的问题,还是你的能力/情商有问题?


那么,你觉得最好的答案是什么呢,如果你是面试官,会选谁进入下一轮?


同时期待掘友们在评论区补充哦


往期精彩


【保姆级】Vue3 开发文档


TS 泛型进阶


深入浅出虚拟 DOM 和 Diff 算法源码,及 Vue2 与 Vue3 中的区别


上手 Vue 新的状态管理 Pinia,一篇文章就够了


作者:沐华
来源:juejin.cn/post/7225432788044267575
收起阅读 »

你到底值多少钱?2023打工人薪酬指南

刚毕业时,我为了赢得面试官的好感,说了很多违心话,如:“工资不要紧,主要是想学习”,又或者是“我对贵司的这块技术非常感兴趣”。 现在想想,呸!恶心,哪怕是花钱嫖培训呢,也不要再傻乎乎的说出“为块术”这种违心的话了。 那时候年轻,不知道起薪高的好处,现在被各种...
继续阅读 »

刚毕业时,我为了赢得面试官的好感,说了很多违心话,如:“工资不要紧,主要是想学习”,又或者是“我对贵司的这块技术非常感兴趣”。


现在想想,呸!恶心,哪怕是花钱培训呢,也不要再傻乎乎的说出“为块术”这种违心的话了。


图1:为块术.png


那时候年轻,不知道起薪高的好处,现在被各种压涨幅,各种倒挂,干最累的活,拿最少的钱,吃最硬的大饼。


2023年,后疫情时代的“元年”,我想明白了,我背上行囊,背井离乡来北漂,就为了3件事:挣钱,挣钱,还是TM的挣钱


既然要挣钱,首先要明确自己的价值。想必大家也对自己值多少钱感兴趣吧?可苦于薪酬保密协议,很难和身边人对比,难以了解自己的价值。没关系,我最近读了几份有趣的报告:



  • 《看看你该赚多少?2023薪资指南(亚太版)》连智领域

  • 《2023年市场展望与薪酬报告》任仕达

  • 《2023⾏业薪酬⽩⽪书》嘉驰国际


今天我就通过这几份报告和大家聊聊,在职场中“我”到底价值几何,“我”拿到怎样的薪资才没有辜负我的才华。


Tips



  • 本文重点分享信息技术岗位,互联网行业,金融行业,软件行业的数据,其余数据可自行阅报告,文末附下载方式;

  • 个人价值不单单由工作年限决定,更多的是与工作年限所匹配的能力。


应届生薪资指南


如果你经常逛各种论坛,可能会看到“今年春/秋招的白菜价是25K”,“XXXX给我开了20K的侮辱性Offer”这类言论。那么20K真的是侮辱性Offer吗?低于白菜价的Offer到底要不要接?


来看嘉驰国际统计到的信息技术行业应届生薪资数据:


图2:2023信息技术行业应届生平均薪资.png


数据似乎与看到的言论相反,一线城市中,本科毕业生薪资中位数是8.8K,只有25%的毕业生拿到了超过10K的薪资。热门城市(北京,上海,广州,深圳和杭州)中也只有北京,上海和深圳的应届生薪资中位数超过了8K


那么网上流传的“白菜价”是怎么回事?其实不难理解,“白菜价”是少数顶尖院校(115所211院校,含39所985院校)的学生拿到顶尖互联网大厂的平均薪资水平,而大部分应届毕业生是很难拿到这个薪资的。


我国拥有2759所普通高等院校,本科1270所,高职(专科)1489所,顶尖院校(115所211院校,含39所985院校)仅占本科院校的9%,普通高等院校的4.1%。


所以对于大部分的普通人院校的毕业生来说,没有所谓的“白菜价”。根据自身的硬性条件合理决定自身的价值范围,不要被HR忽悠,也不要有太过离谱的期望


插句题外话,我16年毕业于某双非院校,第一份工作8.5K,但我们年级的“神”,第一份工作18K。讲这个事情有两层意思:



  • 某些大佬真的可以挣脱本科院校的枷锁

  • 身边的个例并不能反应真实的平均情况


Tips



互联网的天花板


了解完应届生的薪资后,你一定会很想了解未来自己的天花板在哪。注意,标题是互联网的天花板,并非某个职业,也并非每个人都能达到天花板。


先来看互联网行业的年固定收入成长曲线:


图3:互联网年固定收入天花板.png


接着是互联网行业年总收入的成长曲线:


图4:互联网年总收入天花板.png


以我个人观察到的情况,互联网行业中,主管/高级通常对应阿里巴巴的技术职级序列的P6和P6+,经理/资深则对应的是P7,而总监/专家则是P8及以上的职级。


一个很惨淡的事实,对于大部分人来说,P7是通过勤奋可以达到的天花板


如果不是太差,当你达到P7时你的年固定收入会来到50W上下,总收入(奖金和少量股票)会在60W到70W徘徊;而其中的佼佼者,年固定收入会来到70W,总收入触摸到7位数的边界;佼佼者中的一部分会跨过P7这道坎来到P8,普通的P8年薪会在60W上下,总收入(奖金和股票)接近100W,而顶尖的P8薪资会超过100W,总收入更是超过150W。


如果说P7是普通人勤奋的天花板,那普通人想要晋升为P8就需要额外的借助机遇和人脉才有可能达成


Tips:正文部分只展示互联网行业的年固定收入成长曲线和年总收入成长曲线,附录部分提供其他行业的收入曲线。


上海地区研发岗位薪酬


任仕达在《2023年市场展望与薪酬报告》中,给出了信息技术行业中各个技术岗位的薪酬数据,但只有上海地区的数据较为全面,我们重点关注几个“奋战”在一线的技术岗位的薪酬数据:


图5:上海职位薪酬.png
可以看到,对于研发工程师来说,薪资的天花板都非常接近,最突出的是移动开发工程师,稍微落后的是Python开发工程师


当然,技术岗位的天花板远不是职业的终点,技术岗位之后是偏向管理的岗位,例如项目管理和技术管理等。


在大部分互联网公司中,产品经理也是一线岗位,但无论平均薪酬还是薪酬上限,都高于研发岗位(AI类除外)。


结语


了解市场上的薪酬行情,有助于你在求职市场上擦亮自己的双眼,一来可以防止HR恶意压薪资,二来可以清楚自身的定位。


因文章篇幅限制,仅展示部分数据,点击王有志,回复【薪酬报告】即可下载报告。




好了,今天就到这里了,Bye~~


附录


各行业应届生薪资数据


附1:2023各行业应届生平均薪资.png


电子商务年收入成长曲线


年固定收入成长曲线:


附2:电子商务年固定收入天花板.png


年总收入成长曲线:


附3:电子商务年总收入天花板.png


企业软件年收入成长曲线


年固定收入成长曲线:


图4:互联网年总收入天花板.png


年总收入成长曲线:


附5:企业软件年总收入天花板.png


作者:王有志
链接:https://juejin.cn/post/7217601930917838885
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

微信发送语音自定义view中的事件分发

这里通过一个自定义view的例子来看事件分发在自定义view中的使用,其实大部分的Android框架下的事件分发的也都差不多的样子,抛砖引玉,我自己做一个记录,如果能帮到有需要的人那就更上一层楼。 先来看一个微信发送语音的效果图: 关于事件分发我们其实耳熟能...
继续阅读 »

这里通过一个自定义view的例子来看事件分发在自定义view中的使用,其实大部分的Android框架下的事件分发的也都差不多的样子,抛砖引玉,我自己做一个记录,如果能帮到有需要的人那就更上一层楼。

先来看一个微信发送语音的效果图:


关于事件分发我们其实耳熟能详,可以通过一段非常有名的伪代码来大致了解:


  @Override
public boolean dispatchTouchEvent(MotionEvent ev) {
boolean consume = false;
if(onInterceptTouchEvent(ev)){
consume = onTouchEvent(ev);
}else {
consume = child.dispatchTouchEvent(ev);
}
return consume;

}

事件都是从一个DOWN开始,中间经过一堆MOVE,到一个UP结束(先抛开CANCEL的情况)。

事件流向画了半天,感觉也没有人家画的好,可以参考 这里 ,很清晰,忘记了的或者细节不清楚模糊了的可以移步去复习一下。


我们的需求是点击发送按钮后显示浮层view,相当于事件先由发送按钮处理,等浮层view显示后再交由浮层view处理,这个事件的流向很清晰,那应该怎么做呢。


那最简单的view的层级结构就是发送按钮浮层view处在同一层级,那一个问题,事件能否在parent什么都不做的情况下实现事件在同级别view之间的转移呢?

肯定是不可以或者说没有必要的,最好的方式还是通过parent来做分发,由parent的决定此时到底是需要把事件交给发送按钮还是浮层view


所以层级结构上:


<?xml version="1.0" encoding="utf-8"?>
<!-- parent, 来控制事件的分发 -->
<com.yocn.af.view.widget.WeChatParentViewGroup
android:id="@+id/wechat_root"
android:layout_width="match_parent"
android:layout_height="match_parent">

<LinearLayout
android:id="@+id/ll_option"
android:layout_width="match_parent"
android:layout_height="60dp"
android:layout_alignParentBottom="true">

<!-- 发送按钮view -->
<com.yocn.af.view.widget.WeChatVoiceTextView
android:id="@+id/tv_voice"
android:layout_width="0dp"
android:layout_height="match_parent"
android:gravity="center"
android:text="按住 说话"/>
</LinearLayout>
<!-- 点击后需要显示的浮层view -->
<com.yocn.af.view.widget.WeChatVoiceView
android:id="@+id/voice_view"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@color/half"
android:visibility="gone" />

</com.yocn.af.view.widget.WeChatParentViewGroup>

我们梳理一下思路,需要做的就是:



  1. 什么都没做时ParentViewGrouponInterceptTouchEvent要返回false,使得事件能顺利的从ParentViewGroup传递到VoiceTextView(发送按钮)

  2. 点击到VoiceTextView(发送按钮)时,发送按钮的dispatchTouchEvent返回true,处理DOWN事件并告诉parent需要显示WeChatVoiceView(浮层view)

  3. parent接收到需要显示浮层view的命令,显示浮层view并且onInterceptTouchEvent返回true,表示事件我parent来处理,这时VoiceTextView(发送按钮)会收到一个CANCEL事件并且不会继续接受MOVE事件。

  4. parent来分发事件,在WeChatVoiceView(浮层view)显示出来之后直接将后续的MOVE事件交给WeChatVoiceView(浮层view)处理,当然浮层view的onInterceptTouchEvent需要返回true,会回调到浮层view的onTouchEvent,直接做对应的动画或者手势操作。

  5. 当然不要忘记在parent收到ACTION_UP的时候将浮层view置为不可见,因为事件是由parent分发给浮层view的,当然parent可以一直拿到事件。


至此,整个事件分发的流程就结束了。
附上代码地址WeChatSendVoice


作者:Yocn
链接:https://juejin.cn/post/7224318172831531068
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

Android项目cicd流程总结(使用jenkins)

没有cicd之前我们都是怎么做的 相信做安卓开发的都做过这些事 手动运行单元测试,根据报错改代码 检查代码风格,根据报错改代码 构建apk包,发给测试,有时候还得打很多个 接收测试的反馈,改bug, 重复之前的步骤 把apk放到ftp或者其他地方去发布 是...
继续阅读 »

没有cicd之前我们都是怎么做的


相信做安卓开发的都做过这些事



  1. 手动运行单元测试,根据报错改代码

  2. 检查代码风格,根据报错改代码

  3. 构建apk包,发给测试,有时候还得打很多个

  4. 接收测试的反馈,改bug,

  5. 重复之前的步骤

  6. 把apk放到ftp或者其他地方去发布


是不是想到这一套流程,头都大了,虽然每一步都不难,但是连起来都手工操作就很繁琐


像这些手动流程固定的事,我们完全就可以交给机器来做,让我们有更多时间做点别的事,没错,这就是今天要说的cicd


什么是cicd,以及在cicd过程中包含了哪些步骤


一般来说,安卓开发的CI/CD流程包括以下几个阶段:代码提交、代码检查、编译构建、单元测试集成测试、部署发布、用户反馈。



  1. 在代码提交阶段,开发者将自己的代码推送到远程仓库,例如Git或SVN,并触发CI/CD工具或平台例如Jenkins或Travis CI等

  2. 在代码检查阶段,CI/CD工具或平台会对代码进行静态分析和风格检查,例如使用SonarQube或Checkstyle等。

  3. 在编译构建阶段,CI/CD工具或平台会使用Gradle或Maven等工具对代码进行编译和打包,生成APK文件

  4. 在单元测试阶段,CI/CD工具或平台会使用JUnit或Espresso等框架对代码进行单元测试,并生成测试报告。

  5. 在集成测试阶段,CI/CD工具或平台会使用Appium或Selenium等框架对应用进行集成测试,并生成测试报告

  6. 在部署发布阶段,CI/CD工具或平台会将APK文件上传到内部服务器或外部平台,例如蒲公英或Google Play等,并通知相关人员。

  7. 在用户反馈阶段,开发者可以通过Bugly或Firebase等工具收集用户的反馈和错误信息,并根据需要进行修复和更新


通过以上几个步骤,我们可以把以前的app构建流程从手动变为自动,而且可以通过不断以非常低的成本的重复这个过程,提高我们的项目质量,这就是cicd带给我们的自信


今天我们来通过jenkins来实现上面的几个步骤


安装配置jenkins


本文讨论的主要是在windows环境下安装jenkins



  1. 从jenkins官网下载对应的安装包即可

  2. 安装过程很简单但是需要提供一个账号,就像下图显示的界面,这个账号需要有权限
    图片.png
    打开开始菜单,搜索本地安全策略,选择本地策略用户权限分配,在右侧的策略中找到作为服务登录,双击打开。点击添加用户或组,在输入框中填入你的账户的名字,单击检查名称,如果加上了下划线,则说明没有问题,如果输入的用户不存在,则会跳出来一个找不到名称的对话框。
    图片.png


这里需要注意一点,windows家庭版默认是没有本地安全策略的,需要用一些技巧把它开启,如下:


1.  在桌面上单击右键,选择“新建”->“文本文档”。

2. 将文本文档重命名为“OpenLocalSecurityPolicy.bat”。

3. 右键单击“OpenLocalSecurityPolicy.bat”,选择“编辑”。

4. 将以下命令复制并粘贴到文本编辑器中:


@echo off
pushd "%SystemRoot%\system32"
findstr /c:"[SR] Cannot repair member file" %windir%\logs\cbs\cbs.log >%userprofile%\Desktop\sfcdetails.txt
start ms-settings:windowsdefender
start ms-settings:windowsupdate
start ms-settings:windowsupdate-history
start ms-settings:windowsupdate-options
start ms-settings:storagesense
start ms-settings:storagesense-diagnostics
start ms-settings:storagesense-configurecleanup
start ms-settings:storagesense-changehowwesave
start ms-settings:storagesense-runstoragecleanupnow
start ms-settings:storagesense-storageusage
start ms-settings:storagesense-changestoragesavelocations
start ms-settings:backup
start ms-settings:backup-advancedsettings
start ms-settings:backup-addalocaldriveornetworklocation
start ms-settings:backup-managebackups
start ms-settings:backup-moreoptions
start ms-settings:dateandtime
start ms-settings:regionlanguage
start ms-settings:regionlanguage-languagepacks
start ms-settings:regionlanguage-speech
start ms-settings:regionlanguage-keyboards
start ms-settings:regionlanguage-morespeechservicesonline
start ms-settings:speech
start ms-settings:speech-microphoneprivacysettings


5. 保存并关闭文本编辑器。
6. 双击“OpenLocalSecurityPolicy.bat”文件,以打开本地安全策略。
复制代码

3. 修改默认根地址到其他盘符


默认情况下,jenkins的主目录都是在c盘,如果这样,我们使用中产生的数据都是在c盘,用过windows的都知道,数据放在c盘是很危险也是很让人不爽的一件事,我们可以通过修改jenkins的主目录方法来把数据放到其他盘


在成功安装了jenkins并解锁之后,我们可以配置环境变量JENKINS_HOME,地址就是我们想改的目录,


图片.png
然后修改jenkins.xml


    <env name="JENKINS_HOME" value="%LocalAppData%\Jenkins.jenkins"/>
复制代码

改为


    <env name="JENKINS_HOME" value="E:\jenkins"/>
复制代码


  1. 配置常用的插件
    在第一次启动jenkins的时候,会让你选择安装哪些插件,这时候直接选择推荐的插件就好,包含了一些常用插件,比如git等等,如下图


图片.png


配置针对于android的环境



  1. android sdk 见下图
    图片.png

  2. gradle -- Dashboard -> Manage Jenkins -> Global Tool Configuration中的Gradle配置gradle路径即可

  3. jdk -- Dashboard -> Manage Jenkins -> Global Tool Configuration中的JDK配置jdk路径即可

  4. git -- Dashboard -> Manage Jenkins -> Global Tool Configuration中的Git installations配置git路径即可


配置Android的具体job信息


新建一个freestyle的item,在里面做以下几步:




  1. 配置git仓库地址以及构建分支




  2. 设置构建触发器(定时构建) -- 找到构建触发器,勾选build periodically,在编辑框里按照规则设置构建时间,在某天的某个时段自动构建,比如45 9-15/2 * * 1-5,虽然可以提交一次就构建一次,但是不建议这么做。构建表达式的规则见下图,可以根据自己的需要写表达式。
    图片.png




  3. 添加构建步骤,打包出apk,如下图在build step中触发
    图片.png




  4. 配置构建后步骤,自动把apk包上传到ftp或者其他地方


    在Jenkins的项目中,选择“构建”->“增加构建步骤”->“执行shell”或“执行Windows批处理命令”
    一个上传ftp的例子




ftp -n <<EOF
open http://ftp.example.com
user username password
cd /remote/directory
put /local/file
bye
EOF
复制代码

配置邮件通知


在构建完成之后,特别是失败的时候,我们希望收到一封邮件告诉我们构建失败了,快去处理,我们可以通过以下步骤来实现



  1. 在Jenkins中安装Email Extension Plugin插件,可以在插件管理中搜索并安装。

  2. 在Jenkins的系统管理中,配置邮件服务器的地址,用户名,密码和端口。如果使用的是QQ邮箱或者163邮箱,还需要获取邮箱授权码并使用授权码作为密码。

  3. 在Jenkins的项目中,选择“构建后操作”->“增加构建后操作”->“Editable Email Notification”。

  4. 在邮件通知的配置中,填写收件人,抄送人,邮件主题,邮件内容等信息。可以使用一些变量来自定义邮件内容,例如BUILDSTATUS表示构建状态,BUILDSTATUS表示构建状态, {BUILD_URL}表示构建链接等。


这里特别要注意的是,上面的配置地址和授权码需要在job的设置里面进行,在全局配置有可能发不出邮件


配置单元测试和代码检查


我们还需要在运行前执行代码lint检查和单元测试,也需要配插件,插件名字是JUnit和Warnings Next Generation



  1. 参考上面 配置Android的具体job信息 中的配置,添加lint和单元测试的任务

  2. 配置单元测试插件和lint插件,主要指定报告文件的位置,见下图


图片.png


图片.png
3. 把单元测试的结果放到邮件的附件中去,配置见下图,也可以放些别的东西


图片.png


一劳永逸,使用docker把上面的配置做到随时随地使用


上面的步骤完成之后,我们就能自动构建,上传apk什么的了,但是每次换台机器我们都得再配一次,想下就很累,这时候我们就可以用docker,创建一个容器,把上面这些操作放在容器里面,在新环境里面拉个镜像,创建容器跑起来,就ok啦,关于怎么用docker,就需要大家自己去搜索学习了


最后放张图吧,jenkins真好用啊


封面.png


作者:u3shadow
链接:https://juejin.cn/post/7224410321669554231
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

模拟点击与群控——autojs使用

写在前面 autojs是利用accessibility功能实现的一套免root自动化模拟点击框架,让开发者可以直接通过使用js脚本实现一系列的自动化操作,包括:触摸屏幕、滑动、输入文字等。autojs具有很高的灵活性和可扩展性,可以被用于各种场景,例如自动化游...
继续阅读 »

写在前面


autojs是利用accessibility功能实现的一套免root自动化模拟点击框架,让开发者可以直接通过使用js脚本实现一系列的自动化操作,包括:触摸屏幕、滑动、输入文字等。autojs具有很高的灵活性和可扩展性,可以被用于各种场景,例如自动化游戏操作、自动登录、自动化测试等。


autojs免费版本已经停止维护,官网只有Autojs Pro付费版本。然而最近(20230214)又因为一些合规问题,被强制下架已经不允许用户注册。市面上可使用代替产品autox,该项目基于原autojs4.1版本基础上进行维护开发。本文主要围绕该项目展开。


开发环境搭建


使用vscode,添加插件Auto.js-Autox.js-VSCodeExt,如下图,注意不要重复安装多个类似插件,会存在冲突问题。




按住cmd+shift+p,输入> Auto.js,选择"开启服务(Start Server)",此时右下角会提示服务正在运行提示,并显示ip地址信息,如下图,ip为:192.168.1.102




手机与电脑连接同个wifi,并打开autox app,打开"无障碍服务",并打开"连接电脑"按钮,输入ip地址,如下图,点击确认,即可与电脑同步。



连接成功后出现如下提示,此时开发环境搭建完成。



测试hello world程序,创建Autox.js文件,并输入内容toast("hello world!"),选择js文件,右键-重新运行,即可将脚本同步到手机运行,此时手机会出现hello world!的一个toast提示。



js脚本开发指导


关于autojs的API可参考官方文档,这里主要是讲解一下使用的思路。我们在开发自动化工具时,最常见的问题就是如何找到我们所需要点击的控件节点,每一个节点包含的信息包括:



  • className 类名。类名表示一个控件的类型,例如文本控件为"android.widget.TextView",图片控件为"android.widget.ImageView"等。

  • id控件节点的唯一id。

  • text节点名字,不一定有,可能为空。

  • desc节点的描述信息,不一定有,可能为空。

  • packageName 包名。包名表示控件所在的应用包名,例如 QQ 界面的控件的包名为"com.tencent.mobileqq"。

  • bounds 控件在屏幕上的范围。

  • drawingOrder 控件在父控件的绘制顺序。

  • indexInParent 控件在父控件的位置。

  • clickable 控件是否可点击。

  • longClickable 控件是否可长按。

  • checkable 控件是否可勾选。

  • checked 控件是否可以勾选。

  • scrollable 控件是否可滑动。

  • selected 控件是否已选择。

  • editable 控件是否可编辑。

  • visibleToUser 控件是否可见。

  • enabled 控件是否已启用。

  • depth 控件的布局深度。


控件id是最为常用的一个唯一性标记,我们写自动化认为时,经常使用id来对特定控件做点击操作。但是我们如何得知具体控件id信息呢?我们可以利用以下js脚本,将整个界面的控件信息进行打印输出。


toastLog("start.");

function printNode(node){
if(node){
var text = node.text();
var desc = node.desc();
let bounds = node.bounds();
let left = bounds.left;
let top = bounds.top;
let right = bounds.right;
let bottom = bounds.bottom;
var click = node.clickable();
var id = node.id();
log(id, text, desc, click, left, right, top, bottom);
}
}

function traverse(node) {
printNode(node);
var cnt = node.childCount();
for (var i = 0; i < cnt; i++) {
traverse(node.child(i));
}
}

let windowRoot = auto.rootInActiveWindow;
if(windowRoot){
log("tracerse node.");
traverse(windowRoot);
}else{
log("window root is null.");
}

我们可以结合node.bounds()中控件的大小以及所在位置,来猜测我们所要点击的目标控件。在获得某个具体控件id后,即可使用如下js脚本进行点击操作。


target_id=""
id(target_id).findOne().click()

查看viewid脚本开发


这一节我们将利用canvas绘图将每个控件绘制出来,让我们方便地看出来我们所要操作的控件viewid。首先我们需要利用递归方式遍历当前页面上的所有控件,并存放在list变量中,如下。


function traverse(node) {
if(node != null){
viewNodes.push(node);
}
var cnt = node.childCount();
for (var i = 0; i < cnt; i++) {
traverse(node.child(i));
}
}

//x:946, y:80
let windowRoot = auto.rootInActiveWindow;

if(windowRoot){
log("tracerse node.");
traverse(windowRoot); // 开始遍历控件树并打印控件的text属性
}else{
log("window root is null.");
}

function printNode(i, node){
if(node){
var text = node.text();
var desc = node.desc();
let bounds = node.bounds();
let left = bounds.left;
let top = bounds.top;
let right = bounds.right;
let bottom = bounds.bottom;
var click = node.clickable();
var id = node.id();
log(i, id, text, desc, click, left, right, top, bottom);
}
}
var len = viewNodes.length;
for (var i = 0; i < len; i++) {
let childViewNode = viewNodes[i];
printNode(i, childViewNode);
}

使用浮窗功能,在顶层绘制一张透明的画布,如下:


//ui布局为一块画布
var w = floaty.rawWindow(
<frame gravity="center" bg="#ffffff">
<canvas id="canvas" layout_weight="1"/>
</frame>
);

w.setSize(device.width, device.height); // 设置窗口大小
w.setTouchable(false); // 设置触摸透传

使用canvas绘图库,用绿色边框将各个控件圈出,并在每个控件上显示在list中对应的序号。


let paint = new Paint();
paint.setColor(colors.parseColor("#00ff00"));
paint.setStrokeWidth(5);
paint.setStyle(Paint.Style.STROKE);

let paintText = new Paint();
paintText.setColor(colors.parseColor("#FF0000"));
paintText.setTextSize(80);
paintText.setStrokeWidth(20);

var isDraw = 1;
w.canvas.on("draw", function (canvas) {
if(isDraw < 20){
isDraw = isDraw + 1;
var len = viewNodes.length;
for (var i = 0; i < len; i++) {
let childViewNode = viewNodes[i];
let bounds = childViewNode.bounds();
let left = bounds.left;
let top = bounds.top;
let right = bounds.right;
let bottom = bounds.bottom;
canvas.drawRect(left, top, right, bottom, paint);
// log(left, bottom, right, top)
canvas.drawText("" + i, left, bottom, paintText);
}
}
});

为了不让脚本退出,我们需要使用设置等待时间,让脚本持续运行,如下,若没有等待执行,脚本执行后立马退出,我们将无法看到绘图内容。


setTimeout(()=>{
w.close();
}, 50000);

效果图如下:



作者:风铃Cipher
链接:https://juejin.cn/post/7224063449616236605
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

Android通过BLE传输文件

1、遇到的问题 公司要通过Android设备给外围设备的固件进行OTA升级,最开始想到的有两种方案。 1、将当前Android设备所连接 Wifi名称,WiFi密码通过BLE发送给外围设备。 外围设备拿到当前环境的WiFi名称和密码连接热点, 然后自己去服务器...
继续阅读 »

1、遇到的问题


公司要通过Android设备给外围设备的固件进行OTA升级,最开始想到的有两种方案。


1、将当前Android设备所连接 Wifi名称,WiFi密码通过BLE发送给外围设备。 外围设备拿到当前环境的WiFi名称和密码连接热点, 然后自己去服务器下载OTA文件,进行升级

2、当前Android设备和外围设备通过经典蓝牙进行传输OTA文件, 外围设备拿到OTA文件进行升级

但是很遗憾,外围设备既没有WiFi芯片, 也没有经典蓝牙芯片, 只有一颗BLE(低功耗蓝牙)芯片。 这意味着上面的两种方案都行不通。 那我们能不能通过BLE芯片来做文章, 来传输OTA文件?


BLE设计之初就是为了传输简单的指令的, 传输一些小数据的, 每次发送的数据大小不能超过20个字节。到底靠不靠谱啊?


2、 能不能通过BLE传输文件


让我们来问问 GPT 吧


p9uZOaR.png


GPT 的回答, 是可以通过BLE传输文件的, 由于BLE 每次传输的内容最大为20个字节, 传输大文件时就需要分包传输,
同时需要确保分包传输的可靠性和稳定性。


3、 如何传输文件


让 GPT 给我们一些示例代码


p9uekdA.png


可以看出, 发送端分包批量发送数据,接收端


4、如何保证可靠性和稳定性


p9K6UHO.png


1、超时重传


蓝牙在传输过程中, 可能会存在丢包的情况。分两种情况,
1、Android设备发送的数据,外设设备没有收到。
2、Android设备发送的数据,外设设备收到了,并且发送了回复确认。 回复确认包Android设备却没有收到。


出现了这两种情况的任意一种, 则认为发生了丢包的情况。 Android 对这个包进行重发。


2、序列号


针对超时重传的第二种情况, 外设设备会收到两个相同的包。 但是外设设备不清楚是不是重装包。 这时就要给每个数据包添加序列号。 等外设设备收到两个相同序列号的数据包时, 丢弃这个数据包, 回复Android设备收到此包, 开始发送下一个数据包。


3、数据校验


BLE在传输的过程中, 如果周围环境有强蓝牙干扰,或者其他传输通道, 可能会导致数据包变更, 所以需要在数据包添加一个校验位, 这个校验位根据特定的算法,由数据包的数据计算得来。 外设设备收到数据后, 重新计算校验位, 判断数据传输过程是否出现差错, 如果计算的校验位和包传输的校验位不一致, 则要求Android设备重新发送这个包。


5、 传输速度提升 RequestMtu


为了保证传输过程中的可靠性和稳定性,我们需要在传输包中,添加序列号,数据校验等信息。 Android默认每个BLE数据包不超过20个字节,当我们加了一些其他信息时, 每次传输的有效数据可能只有15个字节左右。 导致在传输的过程中分包更多, 传输时间更长。


为了提升传输的速度, 我们来提升BLE每个数据包的传输大小限制, 使每个分包可以传输更多的数据。 系统为我们提供了 RequestMtu这个接口。 需要在gatt连接成功时调用


    private val bluetoothGattCallback = object : BluetoothGattCallback() {

override fun onConnectionStateChange(gatt: BluetoothGatt?, status: Int, newState: Int) {
super.onConnectionStateChange(gatt, status, newState)

if (newState == BluetoothGatt.STATE_CONNECTED) {
Log.d(TAG, "gatt 连接成功")
gatt?.requestMtu(40)
} else {
Log.d(TAG, "gatt 连接失败 status $status newstate $newState")
}

}


override fun onMtuChanged(gatt: BluetoothGatt?, mtu: Int, status: Int) {
super.onMtuChanged(gatt, mtu, status)

if (BluetoothGatt.GATT_SUCCESS == status) {
Log.d(TAG, "onMtuChanged suc : $mtu")
gatt?.discoverServices()
} else {
Log.d(TAG, "onMtuChanged fail : $status")
}
}
}

MTU改变成功后, 再去gatt.discoverServices()发现服务


作者:沉默王贰
链接:https://juejin.cn/post/7226223658775298107
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

【Android】Kotlin 中的 apply、let、also、run 到底有啥区别?

前言 Kotlin 作为一门现代的编程语言,为了提高代码的可读性和简洁性,引入了许多扩展函数。本文将详细介绍 Kotlin 中的四个常用扩展函数:apply、let、also、run,并比较它们的联系与区别。 apply apply 函数接收一个对象并返回该对...
继续阅读 »

前言


Kotlin 作为一门现代的编程语言,为了提高代码的可读性和简洁性,引入了许多扩展函数。本文将详细介绍 Kotlin 中的四个常用扩展函数:applyletalsorun,并比较它们的联系与区别。


apply


apply 函数接收一个对象并返回该对象本身。它允许您在对象上执行一些操作,同时仍然返回原始对象。


这个函数的语法为:


fun <T> T.apply(block: T.() -> Unit): T

其中,T 是对象的类型,block 是一个 lambda 表达式,可以在该对象上执行一些操作。在这个 lambda 中,您可以使用 this 关键字来引用当前对象。


例如:


val person = Person().apply {
name = "John"
age = 30
address = "New York"
}

在这个例子中,我们创建了一个 Person 对象并在 apply 函数中设置了该对象的属性。最终返回的是这个 Person 对象本身。


let


let 同样是一个扩展函数,它也接收一个 Lambda 表达式作为参数。不同于 apply,在 Lambda 表达式中,let 函数将接收者对象作为 Lambda 的参数,通常用 it 作为隐式名称。let 函数的返回值是 Lambda 表达式的结果。


这个函数的语法为:


kotlinCopy code
fun <T, R> T.let(block: (T) -> R): R

其中,T 是对象的类型,R 是返回值的类型,block 是一个 lambda 表达式,它对该对象进行一些操作并返回一个结果。


val person = Person("Alice", 25)
val ageAfterFiveYears = person.let {
it.age + 5
}

在这个示例中,let 函数用于计算 Person 对象五年后的年龄。


also


also 是一个扩展函数,与 apply 类似,但有一个关键区别:also 函数的返回值是接收者对象本身,而 Lambda 表达式的参数是接收者对象,通常用 it 作为隐式名称。
这个函数的语法为:


fun <T> T.also(block: (T) -> Unit): T

其中,T 是对象的类型,block 是一个 lambda 表达式,可以在该对象上执行一些操作。在这个 lambda 中,您可以使用 it 关键字来引用当前对象。


val person = Person("Alice", 25).also {
it.name = "Bob"
it.age = 30
}

在上述示例中,also 函数用于修改 Person 类的属性,最后返回修改后的对象。


run


run 是一个扩展函数,它结合了 applylet 的特点。run 函数在 Lambda 表达式中直接访问接收者对象的属性和方法,同时返回 Lambda 表达式的结果。


这个函数的语法为:


fun <T, R> T.run(block: T.() -> R): R

其中,T 是对象的类型,R 是返回值的类型,block 是一个 lambda 表达式,它对该对象进行一些操作并返回一个结果。在这个 lambda 中,您可以使用 this 关键字来引用当前对象。


val person = Person("Alice", 25)
val greeting = person.run {
"Hello, $name! You are $age years old."
}

在这个示例中,run 函数用于生成一个包含 Person 对象信息的字符串。


总结


四个函数的相同点是,它们都可以操作对象,并可以在 lambda 中引用当前对象。但是,它们的返回值和返回时机有所不同。


apply 和 also 函数的返回值是该对象本身,而 let 和 run 函数的返回值是 lambda 表达式的结果。


apply 函数在对象上执行一些操作,并返回该对象本身。它通常用于在对象创建后立即对其进行初始化。


also 函数类似于 apply 函数,但它返回原始对象的引用。它通常用于对对象进行一些副作用,例如打印日志或修改对象状态。


let 函数在 lambda 中对对象进行一些操作,并返回 lambda 表达式的结果。它通常用于在某些条件下对对象进行转换或计算。


run 函数类似于 let 函数,但它返回 lambda 表达式的结果。它通常用于对对象进行计算,并返回计算结果。


总之,这四个函数都是非常有用的函数式编程工具,可以帮助您以简洁、可读性强的方式操作对象和代码块。对于每个情况,您应该选择最合适的函数,以便以最有效的方式编写代码。


作者:Quincy_Ye
链接:https://juejin.cn/post/7225975883618140221
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

我的30岁,难且正确的事情是什么?

3月意料之中的最后裁员到来了,在充分了解个人意愿后留下两个不想看新工作的小伙伴,IOS Android各一个。我把自己也写进了名单,跟其他能力相对强一点的一起出来了。回顾过去2年我们做的事情,我对大家还是蛮有信心的。同时基于对《钱》这本书的学习,我从前两年开始...
继续阅读 »

3月意料之中的最后裁员到来了,在充分了解个人意愿后留下两个不想看新工作的小伙伴,IOS Android各一个。我把自己也写进了名单,跟其他能力相对强一点的一起出来了。回顾过去2年我们做的事情,我对大家还是蛮有信心的。同时基于对《钱》这本书的学习,我从前两年开始就一直留有1年以上的备用金,所以暂时也没太大经济压力,不至于因为囊中羞涩着急找一份谋生的工作。


刚离开公司的前两周,先花了1000多找了两个职业咨询师,了解目前的招聘环境,招聘平台,招聘数据,以及针对性的帮助我修改简历。都准备好以后,开始选公司试投简历,认真看完大部分JD后大概清楚自己的能力所匹配的公司,薪资范围。机会确实不多,移动端管理岗位,架构岗位就更少,尤其是像我这样工作不到10年,架构跟管理经验都还未满5年的人,选择更是寥寥无几。


先后参加了两个2面试,一个是小团队的移动 TL,在了解后双边意向都不大。另一个是 Android 架构方向。虽然拿了offer,薪资包平移,但我最终没去。一是发生了一点小误会,发offer前电话没告诉我职级,我以为架构岗过了其实没有,差一点点到P7。回看面试记录,提升并不困难,有能力冲一冲的,这一次并不会影响我的信心。


另一个则是我真的冷静下来了,也就有了这篇文章。


在这两周里,陆续写了一些文章,做了一些开源项目。完全是出于助人为乐回馈社区,没想到也因此结识了几个做阅读业务的同学,纷纷向我抛来橄榄枝。其中包含一个已经在行业内做到Top3的产品。这让我有些受宠若惊,毕竟我觉得我给的技术方案并非有很大门槛,只是运气好站在巨人的肩膀上想到了不同的方案而已。


正是这些非常正面的反馈,帮助我消化了很大一部分所谓的焦虑(难说我本身一点不受环境影响)。在Zhuang的帮助下,我大概做了两次自我梳理,最后在前几天我从地铁回家大概3km的步行中想明白了很多事情。


每次出去旅游时,比如我躺在草原上,看着日落,说实话我欣赏不了10分钟。因为我的思绪停不下来,我就会去想一些产品或者是管理方面的问题。我很爱工作,或者说喜欢工作时可以反复获取创造性的快乐,比如做出一个新的技术方案或者优化工作流程解决一个团队问题,都让人很兴奋。但现在,我想强迫自己来思考一些更长期的事情。


我的30岁,难而且正确的事情是什么?


是找一份工作吗?这显然不难,作为技术人,找一份薪资合理的工作不难,这恰恰是最容易的


是找一份自己喜欢的工作吗?这有一点难,更多的是需要运气。职业生涯就十几年,有几次选择的机会呢?这更多的是在合理化自己对稳定性,舒适性的追求,掩盖自己对风险的逃避。


是找一个自己喜欢的事情,并以此谋生吗?这很难,比如先找到自己长期喜欢长期坚持投入的事情就很难,再以此谋生就需要更多的运气与常年积累去等待这个运气出现,比如一些up主。这可以是顺其自然的理想,但不适合作为目标。


上面似乎都是一个个的问题,或者说看到这些问题的时候我就看到了自己的天花板了。因为我可以预见我在这些方向上的学习能力,积累速度,成长空间,资源储备。


这半年涌出了太多的新事物,像极了02年前后的互联网,14前后的移动互联网。我从去年12月5日开始使用GPT,帮助我提高工作,学习效率,帮助我做UI设计,帮助我改善代码,甚至帮助我学习开网店时做选品,做策略,可以说他已经完全融入我的工作学习了。


开发自己的GPT应用要仔细阅读OPEN AI 的API,我再次因为英语的理解速度过慢严重影响学习效率,即使是有众多实时翻译软件帮助下丝毫不会有所改善。


翻译必然会对原文做二次加工,翻译的质量也许很高,甚至超过原文,但这样意味着阅读者离原文越远。


比如我在Tandem上教老外“冰雪聪明”这个词的意思,我很难解释给她,更多的是告诉她这个词在什么场景用比较恰当,比“聪明”更高级。但是如果用翻译软件,这个词会变着花样被翻译成“很聪明”,美感全无。


在Tandem跟人瞎聊时以涉及复杂事件就词穷,直到认识了一个 西班牙的 PHD 与另一个 印尼的大学生,她们帮我找到了关键点,基础语法知识不扎实,英语的思维不足。有些时候他们会说我表达的很棒,口语也行,有些时候他们会说我瞎搞。其实很好理解,就像他们学中文一样,入门也不难,难的是随意调动有限的词汇自由组织句子进行表达,而不是脑子里先想一个母语再试着翻译成外语,难的是在陌生场景下做出正确的表达,能用已经学的知识学习新知识,也就是进入用英语学习英语的阶段。


另外一个例子就是做日常技术学习的时候,尤其是阅读源码的时候,往往是不翻译看懂一部分注释,翻译后看懂一部分,两个一结合就半懂不懂,基于这个半懂不懂的理解写大量测试去验证自己的理解,反推注释是否理解正确,这个过程非常慢,效率极低。


这就是为什么很多东西需要依赖大佬写个介绍文档,或是翻译+延伸解释之后才能高效率学习,为什么自己找不到深入学习的路径,总是觉得前方有些混沌。


记得在刚入行的前几年写过一篇学习笔记,把自定义view 在view层测量相关的代码中的注释,变量名称整个都翻译了,备注2进制标记位变化结果,再去理解逻辑就非常简单了。跟读小说没啥区别(读Java代码就像读小说,我一直这么觉得),很快就理解了。但这个过程要花太多时间了,多到比别人慢10倍不止。


所以这第一个难而正确的事情是学习英语


达到能顺畅阅读技术资料与代码的地步,才能提高我在学习效率上的天花板。


第二个是有关生活的事情,增加不同的收入手段,主业以外至少赚到1块钱


裁员给我最大的感触就是,我很脆弱,我的职业生涯很脆弱,我的生存能力很脆弱,不具备一点反脆弱性。如果没有工作我就没有任何收入,只要稍微发生一点意外,就会面临巨大的经济压力,对于我和家庭都会陷入严重的经济困难中。


市场寒冬与我有关但却不受我影响,我无法改变。同时平庸的职业经历在行业内的影响微乎其微,大佬们是不管寒风往哪吹的,他们只管找自己想做的方向,或者别人找到他们。


我就认识这样的大佬,去年让我去新公司负责组新团队,连续一两周持续对我进行电话轰炸,因为当时正负责的团队处于关键期,我有很深的“良知”情节,我婉拒了,这是优点也是缺点。


而我只有不断提高自己的能力,让人觉得有价值才能持续在这个行业跟关系网里谋生。


但是我知道,大风之下我依然是树叶,我不是树枝,成为树枝需要天时地利人和。就像在公司背小锅的永远都是一线,因为如果是管理层背锅那公司就出了决策性的大问题了,对公司而言已然就是灾难。


这几周陆续跟很多人聊了各种事情,了解他们在做什么。有双双辞职1年多就在家做私活忙得不亦乐乎,有开网店有做跨境电商的,也了解了很多用Chat GPT,Midjourney 等AI工具做实物产品在网上卖的。包括去年了解的生财有术知识星球等等,真的花心思去了解,打开知识茧房确实了解到非常多不同的方向,有一种刘姥姥进大观园的感觉。


自己做了一些实际尝试,跑了下基本流程,确实有一些门槛但各不相同。同时在这个过程中,又因为英语阅读效率低而受阻,文档我也是硬看,不懂的词翻译一下,理解不透再整句翻译,再倒回来看原文。


比如网上midjourney的教程一大把,其实大多数都不如看midjourney官方文档来的快,我从看到用到商品上架,不过几个小时,这中间还包括开通支付跟调整模型。


至于赚到1块钱,有多难呢,当我试了我才有所体会。


种一棵树最好的时间是在10年前,其次是现在。


继续保持在社区的输出,保持技术学习。休假我都不会完全休息,Gap 中当然也不会。


后记


去年公司陆续开始裁撤业务线,有的部门直接清零,公司规模从几千人下降到千人以内不过是几个月的事情,有被裁的,也有为了降低自身风险而主动走裁员名单,这也是双赢的解决方案,公司能精简人员个人可以拿到赔偿。管理层的主要工作是尽力留下核心成员,温和的送走要离开的成员,最大程度降低团队的负面情绪,做人才盘点,申请HC做些人力补充,减少团队震动保障项目支撑。没错,一边裁员一边还会招人。


彼时我个人也才刚刚在管理岗上站稳脚跟不久,团队里没有人申请主动离职算是对我挺大一个宽慰。有的团队人员流失率接近70%,相比之下我压力小得多,但我依然要交出一个名字给到部门负责人。我当然很不舍同时也为他们担忧,过去一年多大家一起相互成长,很多人也才刚刚步入新职级。


我努力寻找第三选择,功夫不负有心人,之前做过的一个项目独立出去了,成立了独立的子公司运营,新团还没搭建完。当时跟那个项目团队的产品,后端负责人配合得相当不错,我便以个人的背书将一个曾重点负责过这个项目的成员推荐过去,加上直属上级的帮助,最终在所有HC都要HRD审批的环境下平滑的将裁员变成了团队调配。现在即使我离开了母公司,他们小团队依然还不错,没有受到后续裁员影响。这位小伙伴人特别实在,他是我见过执行里最强的人,他值得这样的好运气。


作为管理者,我有些单纯的善意,不满足于工作层面的帮助。因为我觉得个人能量实在是太小了,而未来无人知晓。


作为核心部门虽然裁员的影响波及较为滞后,但明显的感觉还是研发压力骤减,加上公司为了早点达到账面盈亏平衡,对部分薪资采取缓发,在这样的背景下整个部门的氛围变了,需求评审得过且过,项目质量得过且过,此类情况比比皆是,工作的宽容度也一再升高。


作为个人来讲这真是躺平型工作,工作任务骤减但薪资还照样发,绩效照发,每天到公司跟去上学一样。我心里就出现了一个声音「你喜欢在这里继续混吗?这里如此安逸」。


今年3月意料之中的新一轮裁员到来,我几乎没有犹豫就答复了部门负责人。团里谁想留下谁不想留我很清楚,过去我们一直也保持比较健康的氛围,始终鼓励能力强的人出去看看,也明确告知留下来与出去将面临的不同风险。大家都有心理准备,但大家都没有懈怠自己的学习,技术目标按部就班,丝毫没有陷入负面漩涡,偶尔还会因为讨论技术问题忘记下班时间。


这一次,我把自己放在了名单上,当然这并不突然。我与部门负责人一直保持着较高的工作沟通频率,就向上管理这一点上,我自认做得非常不错。


离职后大家都积极找工作,我对他们非常有信心,抛开头部大厂,中厂依然是他们的主阵地,他们在各自专精的领域里技术都很扎实,尤其是去年大家一起补足了深层次的网络层知识。不出意料部分人都很快拿了offer,有的更是觉得不想面试了匆匆就入职了,这我就不行使自己好为人师的毛病了。


作者:橘子没了
链接:https://juejin.cn/post/7224068169341763643
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

Android 自定义开源库 EasyView

  这是一个简单方便的Android自定义View库,我一直有一个想法弄一个开源库,现在这个想法付诸实现了,如果有什么需要自定义的View可以提出来,不一定都会采纳,合理的会采纳,时间周期不保证,咱要量力而行呀,踏实一点。 配置EasyView 1. 工程b...
继续阅读 »

  这是一个简单方便的Android自定义View库,我一直有一个想法弄一个开源库,现在这个想法付诸实现了,如果有什么需要自定义的View可以提出来,不一定都会采纳,合理的会采纳,时间周期不保证,咱要量力而行呀,踏实一点。


1682474222191_095705.gif.gif


配置EasyView


1. 工程build.gradle 或 settings.gradle配置


   代码已经推送到MavenCentral(),在Android Studio 4.2以后的版本中默认在创建工程的时候使用MavenCentral(),而不是jcenter()


   如果是之前的版本则需要在repositories{}闭包中添加mavenCentral(),不同的是,老版本的Android Studio是在工程的build.gradle中添加,而新版本是工程的settings.gradle中添加,如果已经添加,则不要重复添加。


repositories {
...
mavenCentral()
}

2. 使用模块的build.gradle配置


   例如在app模块中使用,则打开app模块下的build.gradle,在dependencies{}闭包下添加即可,之后记得要Sync Now


dependencies {
implementation 'io.github.lilongweidev:easyview:1.0.2'
}

使用EasyView


   这是一个自定义View的库,会慢慢丰富里面的自定义View,我先画个饼再说。


一、MacAddressEditText


   MacAddressEditText是一个蓝牙Mac地址输入控件,点击之后出现一个定制的Hex键盘,用于输入值。


1. xml中使用


   首先是在xml中添加如下代码,具体参考app模块中的activity_main.xml。


    <com.easy.view.MacAddressEditText
android:id="@+id/mac_et"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
app:boxBackgroundColor="@color/white"
app:boxStrokeColor="@color/black"
app:boxStrokeWidth="2dp"
app:boxWidth="48dp"
app:separator=":"
app:textColor="@color/black"
app:textSize="14sp" />


2. 属性介绍


   这里使用了MacAddressEditText的所有属性,可以自行进行设置,使用说明参考下表。







































属性说明
app:boxBackgroundColor设置输入框的背景颜色
app:boxStrokeColor设置输入框的边框颜色
app:boxStrokeWidth设置输入框的边框大小
app:boxWidth设置输入框大小
app:separatorMac地址的分隔符,例如分号:
app:textColor设置输入框文字颜色
app:textSize设置输入框文字大小

3. 代码中使用


    MacAddressEditText macEt = findViewById(R.id.mac_et);
String macAddress = macEt.getMacAddress();

   macAddress可能会是空字符串,使用之前请判断一下,参考app模块中的MainActivity中的使用方式。


二、CircularProgressBar


   CircularProgressBar是圆环进度条控件。


1. xml中使用


   首先是在xml中添加如下代码,具体参考app模块中的activity_main.xml。


    <com.easy.view.CircularProgressBar
android:id="@+id/cpb_test"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginTop="30dp"
app:maxProgress="100"
app:progress="10"
app:progressbarBackgroundColor="@color/purple_500"
app:progressbarColor="@color/purple_200"
app:radius="80dp"
app:strokeWidth="16dp"
app:text="10%"
app:textColor="@color/teal_200"
app:textSize="28sp" />

2. 属性介绍


   这里使用了MacAddressEditText的所有属性,可以自行进行设置,使用说明参考下表。















































属性说明
app:maxProgress最大进度
app:progress当前进度
app:progressbarBackgroundColor进度条背景颜色
app:progressbarColor进度颜色
app:radius半径,用于设置圆环的大小
app:strokeWidth进度条大小
app:text进度条中心文字
app:textColor进度条中心文字颜色
app:textSize进度条中心文字大小

3. 代码中使用


    CircularProgressBar cpbTest = findViewById(R.id.cpb_test);
int progress = 10;
cpbTest.setText(progress + "%");
cpbTest.setProgress(progress);

   参考app模块中的MainActivity中的使用方式。


三、TimingTextView


   TimingTextView是计时文字控件


1. xml中使用


   首先是在xml中添加如下代码,具体参考app模块中的activity_main.xml。


    <com.easy.view.TimingTextView
android:id="@+id/tv_timing"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginTop="30dp"
android:text="计时文字"
android:textColor="@color/black"
android:textSize="32sp"
app:countdown="false"
app:max="60"
app:unit="s" />

2. 属性介绍


   这里使用了TimingTextView的自定义属性不多,只有3个,TextView的属性就不列举说明,使用说明参考下表。























属性说明
app:countdown是否倒计时
app:max最大时间长度
app:unit时间单位:s(秒)、m(分)、h(时)

3. 代码中使用


    TimingTextView tvTiming = findViewById(R.id.tv_timing);
tvTiming.setMax(6);//最大时间
tvTiming.setCountDown(false);//是否倒计时
tvTiming.setUnit(3);//单位 秒
tvTiming.setListener(new TimingListener() {
@Override
public void onEnd() {
//定时结束
}
});
//开始计时
tvTiming.start();
//停止计时
//tvTiming.end();

   参考app模块中的MainActivity中的使用方式。


作者:初学者_Study
链接:https://juejin.cn/post/7225407341633175613
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

前端实习近半年的工作总结

前言:     来北京工作实习已经一年,总结一下自己这最近半年的实习经历的感受与收获吧。     首先感谢一下组内的同事,以及我的mentor对我入职实习期间的帮助,以及对我日常问题的解答,特别是我的mentor,从他身...
继续阅读 »

前言:


    来北京工作实习已经一年,总结一下自己这最近半年的实习经历的感受与收获吧。


    首先感谢一下组内的同事,以及我的mentor对我入职实习期间的帮助,以及对我日常问题的解答,特别是我的mentor,从他身上学到了很多优秀的开发习惯和技巧。


    其实在写这篇总结之前,我也去阅读了很多作者写的工作总结,看完大家工作总结之后,我发现自己这半年的工作还是太安逸了,没有逃离自己的舒适圈,这半年自己并没有主动去学习新的一些技术,更多的只是在完成业务需求,但是在工作中想有所提升仅仅做业务开发是远远不够的,要想成长就必须学习新的技术,做一些技术产出才可以,所以这次的总结更多的是对自己的反思以及对之后正式工作的计划与展望。


工作内容:


     部门的业务主要是toC方向做小程序的开发,刚来到公司前期主要跟我的mentor一起负责砍价业务,我用了一周时间来了解砍价相关业务以及代码,并且做了一个宣讲(由于自己当时对于部门业务还不是非常了解,当时的宣讲更多的仅仅是针对前端的业务以及代码逻辑,并没有去了解每一个接口内部的实现,所以感觉第一次宣讲并没有表现很好),后来由于内部调整我就开始主要负责列表的相关需求。我所在的部门属于全栈开发,前端主要采用是微信小程序以及Vue,并且我们有自己的node中间层来封装接口,所以平时会经常写node.js+TS,这在我上一家公司是没有体会过的,(我觉得这样非常合理,再也不用像在上家公司一样,因为一些接口返回字段类型不统一去排查和后端交流好久)这也让我页接触学习到了更广泛的技术栈。


    平时除了开发任务还包括一些日常的巡检等等,虽然现在我还没有加入到日常的巡检当中,但是在最近几个迭代,我也开始自己对每天的指标进行观察巡检,总结巡检报告。


成长与收获:


工具的使用:


1、charles



一款常见的抓包工具,通过代理连接,把客户端的请求数据,以及服务端返回的数据完完整整的抓取下来,方便开发调试,一般搭配switchhost来使用,switchhos是用来改变本地host的工具,实现原理就是通过修改我们本地dns域名解析与ip之间的映射关系。


2、apiPost


在此之前我只知道用postman来请求接口、mock数据,但是经过我mentor的推荐,我发现apiPost是真的好用,用起来很方便推荐给大家!


(我mentor电脑里有非常多奇奇怪怪但是又实用的工具,每一样拿出来都让我直呼🐂🍺,包括他vscode中的各种插件👍,附上一个巨好用的截图插件Snipaste,大家自行感受)


3、Echarts



echarts.js是百度团队推出的一款用于图表可视化的插件,用于以图表的形式展现数据,功能强大,上手简单,在我认知里他和element-UI都属于辅助开发的工具,当时用的多了自然就会精通熟练,不用刻意的去学习,所以把它归到了工具使用这一类。这个是刚进入公司和我mentor一起做一个砍价报表的需求里面大量的图表就用到了Echarts,里面包含折线图,柱状图等等,非常丰富。


技术的拓展:


1、node.js


在来到这个公司之前,我自己也使用node的express框架写过一些小的demo,多少对node有一些了解,express是基于content中间件框架,框架自身封装了大量的功能比如路由router和视图处理等等;我现在开发使用的是基于koa搭建的一个自己的框架,koa相较于express的使用更加灵活,并且我们框架的层次划分非常清晰,把业务代码按照controller、busoness、agent三层层来细分处理,减少了代码的冗余并且更加整洁,方便理解。


2、TypeScript


TS又称为javascript的超集,而且本质上向这个语言添加了可选的静态类型和基于类的面向对象编程。自我感觉Ts在帮我们写出更加强壮的代码,在开发过程中就能将我们的一些错误暴漏出来,编写代码的提示也极大的提升了我们的开发效率,不过TypeScript的学习并不是那么简单的,需要经过大量的联系和阅读,对我来说泛型对我来说掌握的还不够,也是后边学习的重点。


3、vuex


Vuex属于vue的一种状态管理模式,将页面组件中可以共享的变量方法进行统一的管理,告别了一层一层的变量传递,在之前只是说去了解学习过Vuex的一些用法知识,最近做公司的H5项目时多数页面都是用vuex来管理数据的,也是在实践中系统的使用学习了一下。


4、socket


socket通信是新接触的知识,Socket是应用层与TCP/IP协议族通信的中间软件抽象层,是一组接口(也是刚刚查的),部门前段时间刚刚做过分享,建立微信与h5之间的socket通信,还是比较感兴趣的,计划在下半年进行了解和学习。


5、webpack/vite


最近在做公司h5项目的时候感到很烦恼,由于项目很庞大,加上我的电脑真是非常的卡,所以每次启动h5项目的时候都要超级长的时间,n分钟,公司的项目是由webpack构建的,所以就在考虑学习一种更加快速的大包构建工具去尝试优化一下这个项目,vite就是学习的对象,从底层原理上来说,Vite是基于esbuild预构建依赖。而esbuild是采用go语言编写,因为go语言的操作是纳秒级别,而js是以毫秒计数,所以vite比用js编写的打包器快10-100倍。所以接下来的目标就是去学习这个webpack以及vite,学习优化的过程也是对自己的考验。


习惯的养成:


      其实这半年里我觉得最好的习惯就是跟我mentor学习的记笔记,刚来公司就发现我mentor每次做完需求都会记笔记复盘,包括学习一些技术等等都会记笔记,渐渐的我也养成了这个习惯,但是现在记得一些东西都还不是很成熟,都是一些做需求过程中当作思路分析来写的,之后在笔记的书写上应该对自己增加些要求不能太过随意(因为前几天看之前写的已经看不懂当时写的是啥了!)。


      还有一个就是写文章!这个总结是我在掘金写的第一篇文章,之后每周或者每学一一个内容都会在掘金记录一下总结和收获,看了这么多大佬的文章,真的觉得自己非常渺小,作为一个小白,要从头开始把所有知识都从新学习一下。


下半年学习计划:


1、vue3.x:自己之前一直都在使用学习vue2,并没有扩展到vue3,在不学习就要被淘汰了,所以vue3是下半年学习的重点!


2、TS:ts自己现在也只是了解皮毛,可以进行开发,但是掌握的还是太少,要继续学习。


3、webpack/vite:还有就是刚才说的webpack/vite,自己要学习并且优化公司的h5项目!


4、socket:这个作为下半年的拓展,了解的同时也可以复习一下网络的所有知识。


5、markdown语法:第一次写文章就没那么讲究了,写的很丑,下次学一下markdown语法,把文章写的漂亮一点。


阅读书籍:


下面这些是被我列在清单里的书籍,也是同事推荐给我的







结束语


总之这半年过的还是浑浑噩噩太过安逸,嘴上说着是因为弄毕业设计但是自己知道并没有去努力,下半年逃出自己的舒适圈!完成自己的计划,向着目标前进!


作者:fc550
来源:juejin.cn/post/7121378029678362638
收起阅读 »

一个前端实习生在蔚来的成长小结

此文章2332字,预计花费时间7-11分钟。 一、聊聊工作氛围 & 个人成长 1. 这是我的期许 “所谓前途,不过是以后生活的归途。” 这是我人生中的第一段技术实习,之前并不是一心做技术的,所以为了探索自己喜欢的事情在某小公司做过翻译实习,并且在交行...
继续阅读 »

此文章2332字,预计花费时间7-11分钟。


image.png


一、聊聊工作氛围 & 个人成长


1. 这是我的期许


“所谓前途,不过是以后生活的归途。”


这是我人生中的第一段技术实习,之前并不是一心做技术的,所以为了探索自己喜欢的事情在某小公司做过翻译实习,并且在交行做过金融实习(其实就是纯打杂)。


image.png


我很喜欢这样一段话: “我曾以为我的23岁会手提皮包西装革履,但我还是穿着休闲裤,带着十几岁的意气行事,幼稚又成熟;我曾以为我的23岁会性格外向,做事圆滑,但我连最简单的亲情都处理不好;我曾以为我的23岁会和喜欢的人看山河大海落日余晖,但没想道周围的人谈婚论嫁都近在眼前,我还在路上找自己。”


我一直在探索着自己的边界,在能闯能疯的年纪反复横跳,寻找着自己的热爱与期许。在真正从事这个行业之后,我发现了我对于这个岗位的喜爱,当你看着一个个实际的视图出现于自己的手中,你会有一种莫名其妙的成就感,这种感觉难以描述的程度就好像你要向一个完全不看vtuber的人描述你对嘉然的喜爱。


2. 工作氛围:这里是一个乌托邦(适合摸鱼学习的好地方!)


说实话,我最开始预期是每天九点来上班,九点下班的(因为看学长们实习都好辛苦的样子)。


来了之后发现完全不是,每天十点上班,六点下班(我当然是准点跑路)



实习两个月左右的时候接的一个需求,第一天是另一个前端实习生来搞,后来他要跑路,leader就把活给我了。


周四,后端六点把接口给另一个前端实习生。


另一个前端实习生:“明天再说”


周五我来接这个活,我边画页面边让他加字段。


然后提完了,六点他给我改好的接口,让我看看有没问题


我:“下周再说”。


后端:“前端是不是,都很快乐啊[流泪]”



image.png


最开始因为我对 react 不是特别熟悉,leader 让我看着组内文档学了半个月,才开始了第一个需求。


leader 没有给我指定 mentor,所以当我有问题的时候,我看组内谁没开会(或者有时间)就会去问,都能得到很耐心的解答,这点来说还是很有安全感的。


然后每天都会跟着老板和大老板一起去吃饭,有时听他们说说自己的事情,有时听听他们对某个语言的看法,也算有不少收获。


值得一提的是刚入职三天部门就开始团建了,从周五下午五点玩到了第二天凌晨两点,炫了一只烤全羊,然后就开始电玩篮球各种 happy,后面玩狼人杀我次次狼人,大老板也总觉得我是狼人,我次次和他对着刚(乐)



马上就要第二次团建了,可惜参加不了呜呜呜



在团建上 leader 说我是从五个面试感觉都 ok 的人里面选出来的(当时我超惊喜的)


还有几件有趣的事情值得一提



第一件事情是中午和 leader 散步,他说:“你干了两个月这里的情况也看到,很难接触到同龄的小姐姐的,找对象的优先级应该要提高了。”


我:“说的对说的对。”


当时我心里就暗暗想着,这是我不想找吗?这tm是我找不到啊(悲)


第二件事情是我有事开了自己的热点,热点的名字叫:“要失业了咋办呐。


被同事发到了前端大群里。


同事:“这是谁的啊?”


我:“是实习生的(悲)”



3. 个人成长:“不卑不亢,低调务实”


最开始入职当然会担心一些七的八的,诸如这样说会不会不太客气,这样搞会不会让老板不爽,后来和老板还有大老板一起吃饭之后发现他们人都挺随和的,没什么架子,他们更多的关心的是这件事情做的怎么样。


大老板曾经在周会上说:“这个事情可以做的慢一些,这是能力上的问题,这个可以商量,但是如果到了约定的日期没有交付,这就有问题了。 ”这个是说的务实。


然后就是为人处事方面了,自己有时候挺跳脱的,没有什么边界感,在实习和他们一起吃饭的时候我就回默默的听着,有些问题大家都不会问,算是看着看着就成长了。


回校远程的时候我写了这样一段话:



去打工吧,去打上海冬夜准时下班,踩雪走回家的工。


去打工吧,去打一边聊天一边发现,这个产品也是清华✌️的工。


去打工吧,去打测试前一天,人都走光了,mentor陪我赶工到半夜的工。


去打工吧,去打部门团建,大leader带我们玩狼人杀到凌晨两点,超级尽兴的工。


冴羽曾在一次读书会上分享:“开眼界就像开荤一样,只有见过了才会产生饥饿感。”


打工虽然让我变成了稍不注意就会摆烂的成年人,但大平台汇聚了很多丰富有趣的同事,让我看到了截然不同的经历与一波三折的人生。


不知道是不是部门的原因,我这边总是十六五准点上下班。


我现在依然处于打工真香的阶段,不用早起,不用日复一日的和同龄人卷同一件事,身边的人年岁不同,人生阶段也不相同,卷不到一起去。


我还在路上~



image.png


4. 代码方面 learning


说实话看到组内项目的时候体会到了不少的震撼,看着组内的项目之后真的就感觉自己写的东西和玩具一样,每次写完项目,都会兴冲冲的找组内的哥哥姐姐帮忙 CR,然后 CR 出一堆问题,自己在一个一个的修改,把这些规范点记周报上,总之就是学到了很多很多。


timeLine 大概是这样的



  • 前两周熟悉 react 写小 demo

  • 然后以两周一个需求的速度给咱活干~


记得第二次写完一个稍微有点复杂的需求,带着我做这个需求的 mentor 还夸了我一波(骄傲)


5. 对于技术和业务的想法


大leader组织组内 vau 对齐的时候我仔细的听了听,我们的很多东西都需要落地,相比来说技术只是一个实现的手段,并不是做这个的目的。


但怎么说呢,我个人还是对技术本身抱有很大的期许的,希望自己能够变得很厉害,参与到很多的开源项目中,我坚信代码可以改变世界。


二、展望未来



实习不去字节,就像读四大名著不看红楼梦,基督徒不看圣经,学相对论不知道爱因斯坦,看vtuber不看嘉然今天吃什么,这个人的素养与精神追求不足,成了无源之水,无本之木。他的格局就卡在这里了,只能度过一个相对失败的人生!




  • 话是这么说啦,但最后还是没有成功去到字节,但是我是字节不折不扣的舔狗,后面再看吧。

  • 字节给我发面试一定是喜欢我(普信)


下面这段是之前写的



离开的契机也很简单,我在小红书实习的同学跑路了,然后要找继任,顺手把我的简历投过去了,然后我顺手面了一下小红书,小红书顺手给我发了个Offer(bushi,然后就去小红书了。



image.png


小红书确实Offer了,但是老板和我约谈了很久,我决定继续远程实习,在这篇文章发布的当天,我已经实习了 一百四十天,我相信,我的旅途还在继续。


image.png


三、写在最后


不知不觉就实习快半年了啊


我真的非常感谢遇到的leader和同事,感恩遇到的每一位愿意拉我一把的人。


在这段时间里学到了好多一个人学习学不到的东西啊。


那么这就是我在蔚来的实习小结啦!


感谢阅读~


作者:阳树阳树
来源:juejin.cn/post/7228245665334198333
收起阅读 »

Android 自定义View 之 计时文字

前言   在Android开发中,常常会有计时的一些操作,例如收验证码的时候倒计时,秒表的计时等等,于是我就有了一个写自定义View的想法,本文效果图。 正文   那么现在我们将想法换成现实,这个自定义View比较简单,我们来看怎么写的,首先我们还是在Eas...
继续阅读 »

前言


  在Android开发中,常常会有计时的一些操作,例如收验证码的时候倒计时,秒表的计时等等,于是我就有了一个写自定义View的想法,本文效果图。


在这里插入图片描述


正文


  那么现在我们将想法换成现实,这个自定义View比较简单,我们来看怎么写的,首先我们还是在EasyView中进行添加。


一、XML样式


  根据上面的效果图,我们首先来确定XML中的属性样式,在attrs.xml中增加如下代码:


    <!--计时文字-->
<declare-styleable name="TimingTextView">
<!--倒计时-->
<attr name="countdown" format="boolean" />
<!--时间最大值-->
<attr name="max" format="integer" />
<!--时间单位,时:h,分:m,秒:s-->
<attr name="unit">
<enum name="h" value="1" />
<enum name="m" value="2" />
<enum name="s" value="3" />
</attr>
</declare-styleable>

  这里的计时文字目前有3个属性,第一个boolean用来确定是计时还是倒计时,第二个是最大时间,第三个是时间单位:时分秒。


二、构造方法


  之前我说自定义View有三种方式,一种是继承View,一种是继承现有的View,还有一种是继承ViewGroup,那么今天的这个计时文字,我们就可以继承现有的View,这样做的目的就是可以让我们减少一定的工作量,专注于功能上,下面我们在com.llw.easyview包下新建一个TimingTextView类,里面的代码如下所示:


public class TimingTextView extends MaterialTextView {

/**
* 时间单位
*/

private int mUnit;
/**
* 计时最大值
*/

private int mMax;
/**
* 是否倒计时
*/

private boolean mCountDown;
private int mTotal;
/**
* 是否计时中
*/

private boolean mTiming;

public TimingTextView(Context context) {
this(context, null);
}

public TimingTextView(Context context, @Nullable AttributeSet attrs) {
this(context, attrs, 0);
}

public TimingTextView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
@SuppressLint("CustomViewStyleable")
TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.TimingTextView);
mCountDown = typedArray.getBoolean(R.styleable.TimingTextView_countdown, false);
mMax = typedArray.getInteger(R.styleable.TimingTextView_max, 60);
mUnit = typedArray.getInt(R.styleable.TimingTextView_unit, 3);
typedArray.recycle();
}
}

  因为有计时的缘故,所以我们需要一个计时监听,主要用于结束的时候进行调用,可以在com.llw.easyview下新建一个TimingListener接口,代码如下:


public interface TimingListener {
void onEnd();
}

三、API方法


下面在TimingTextView中新增一些API方法和变量,首先增加变量:


    private TimingListener listener;
private CountDownTimer countDownTimer;

然后增加API方法:


    /**
* 设置时间单位
*
* @param unit 1,2,3
*/

public void setUnit(int unit) {
if (unit <= 0 || unit > 3) {
throw new IllegalArgumentException("unit value can only be between 1 and 3");
}
mUnit = unit;
}

/**
* 设置最大时间值
*
* @param max 最大值
*/

public void setMax(int max) {
mMax = max;
}

/**
* 设置是否为倒计时
*
* @param isCountDown true or false
*/

public void setCountDown(boolean isCountDown) {
mCountDown = isCountDown;
}

public void setListener(TimingListener listener) {
this.listener = listener;
}

public boolean isTiming() {
return mTiming;
}

/**
* 开始
*/

public void start() {
switch (mUnit) {
case 1:
mTotal = mMax * 60 * 60 * 1000;
break;
case 2:
mTotal = mMax * 60 * 1000;
break;
case 3:
mTotal = mMax * 1000;
break;
}
if (countDownTimer == null) {
countDownTimer = new CountDownTimer(mTotal, 1000) {
@Override
public void onTick(long millisUntilFinished) {
int time = 0;
if (mCountDown) {
time = (int) (millisUntilFinished / 1000);
setText(String.valueOf(time));
} else {
time = (int) (mTotal / 1000 - millisUntilFinished / 1000);
}
setText(String.valueOf(time));
}

@Override
public void onFinish() {
//倒计时结束
end();
}
};
mTiming = true;
countDownTimer.start();
}

}

/**
* 计时结束
*/

public void end() {
mTotal = 0;
mTiming = false;
countDownTimer.cancel();
countDownTimer = null;
if (listener != null) {
listener.onEnd();
}
}

代码还是很简单的,你敢信,这个自定义View就写完了,不过可能存在一些问题,我将自定义View的代码都放到了一个library下面里,然后将这个library进行构建成aar,然后上传到mavenCentral()中。


四、使用


  然后我们修改一下activity_main.xml,代码如下所示:


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
android:orientation="vertical"
android:padding="16dp"
tools:context=".MainActivity">


<com.easy.view.MacAddressEditText
android:id="@+id/mac_et"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
app:boxBackgroundColor="@color/white"
app:boxStrokeColor="@color/black"
app:boxStrokeWidth="2dp"
app:boxWidth="48dp"
app:separator=":"
app:textColor="@color/black"
app:textSize="16sp" />


<Button
android:id="@+id/btn_mac"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginTop="30dp"
android:text="获取地址" />


<com.easy.view.CircularProgressBar
android:id="@+id/cpb_test"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginTop="30dp"
app:maxProgress="100"
app:progress="10"
app:progressbarBackgroundColor="@color/purple_500"
app:progressbarColor="@color/purple_200"
app:radius="80dp"
app:strokeWidth="16dp"
app:text="10%"
app:textColor="@color/teal_200"
app:textSize="28sp" />


<Button
android:id="@+id/btn_set_progress"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginTop="30dp"
android:text="随机设置进度" />


<com.easy.view.TimingTextView
android:id="@+id/tv_timing"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginTop="30dp"
android:text="计时文字"
android:textColor="@color/black"
android:textSize="32sp"
app:countdown="false"
app:max="60"
app:unit="s" />


<LinearLayout
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginTop="12dp"
android:gravity="center"
android:orientation="vertical">


<CheckBox
android:id="@+id/cb_flag"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="计时" />


<Button
android:id="@+id/btn_start"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="开始" />

</LinearLayout>
</LinearLayout>

预览效果如下图所示:


在这里插入图片描述


下面我们回到MainActivity中,在onCreate()方法中添加如下代码:


        //计时文本操作
TimingTextView tvTiming = findViewById(R.id.tv_timing);
CheckBox cbFlag = findViewById(R.id.cb_flag);
Button btnStart = findViewById(R.id.btn_start);
tvTiming.setListener(new TimingListener() {
@Override
public void onEnd() {
tvTiming.setText("计时文字");
btnStart.setText("开始");
}
});
cbFlag.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
cbFlag.setText(isChecked ? "倒计时" : "计时");
}
});
//计时按钮点击
btnStart.setOnClickListener(v -> {
if (tvTiming.isTiming()) {
//停止计时
tvTiming.end();
btnStart.setText("开始");
} else {
tvTiming.setMax(6);
tvTiming.setCountDown(cbFlag.isChecked());
tvTiming.setUnit(3);//单位 秒
//开始计时
tvTiming.start();
btnStart.setText("停止");
}
});

下面运行一下看看:


在这里插入图片描述


五、源码


如果对你有所帮助的话,不妨 Star 或 Fork,山高水长,后会有期~


源码地址:EasyView


作者:初学者_Study
来源:juejin.cn/post/7225045596029075511
收起阅读 »

无聊的分享:点击EditText以外区域隐藏软键盘

1.前言 当我们在使用一个应用的搜索功能或者任何带有输入功能的控件时,如果想取消输入往往会点击外部空间,这个时候系统的软键盘就会自动收起,并且输入框也会清楚焦点,这样看上去很自然,其实使用EditText控件是没有这种效果的,本文章就如何实现上述效果提供一点小...
继续阅读 »

1.前言


当我们在使用一个应用的搜索功能或者任何带有输入功能的控件时,如果想取消输入往往会点击外部空间,这个时候系统的软键盘就会自动收起,并且输入框也会清楚焦点,这样看上去很自然,其实使用EditText控件是没有这种效果的,本文章就如何实现上述效果提供一点小小的思路。


2.如何实现


当我们在Activity单纯的添加一个EditText时,点击吊起软键盘,这个时候再点击EditText外部区域会是这个样子的:



会发现,无论我们怎么点击外部区域软键盘都不会收起。所以要达到点击外部区域收起键盘效果需要我们自己添加方法去隐藏键盘:


重写dispatchTouchEvent


override fun dispatchTouchEvent(ev: MotionEvent?): Boolean {
   ev?.let {
       if (it.action == MotionEvent.ACTION_DOWN) {
           //如果现在取得焦点的View为EditText则进入判断
           currentFocus?.let { view ->
               if (view is EditText) {
                   if (!isInSide(view, ev) && isSoftInPutDisplayed()) {
                       hideSoftInPut(view)
                  }
              }
          }
      }
  }
   return super.dispatchTouchEvent(ev)
}

在Activity 中重写dispatchTouchEvent,对ACTION_DOWN事件做处理,使用getCurrentFocus()方法拿到当前获取焦点的View,判断其是否为EditText,若为EditText,则看当前软键盘是否展示(isSoftInPutDisplayed)并且点击坐标是否在EditText的外部区域(isInSide),满足条件则隐藏软键盘(hideSoftInPut)。


判断点击坐标是否在EditText内部


//判断点击坐标是否在EditText内部
private fun isInSide(currentFocus: View, ev: MotionEvent): Boolean {
   val location = intArrayOf(0, 0)
//获取当前EditText坐标
   currentFocus.getLocationInWindow(location)
//上下左右
   val left = location[0]
   val top = location[1]
   val right = left + currentFocus.width
   val bottom = top + currentFocus.height
//点击坐标是否在其内部
   return (ev.x >= left && ev.x <= right && ev.y > top && ev.y < bottom)
}

定义一个数组location存储当前EditText坐标,计算出其边界,再用点击坐标(ev.x,ev.y)和边界做比较最终得出点击坐标是否在其内部。


来判断软键盘是否展示


private fun isSoftInPutDisplayed(): Boolean {
   return ViewCompat.getRootWindowInsets(window.decorView)
       ?.isVisible(WindowInsetsCompat.Type.ime()) ?: false
}

使用
WindowInsetsCompat类来判断当前状态下软键盘是否展示,WindowInsetsCompat是AndroidX库中的一个类,用于处理窗口插入(WindowInsets)的辅助类,可用于帮助开发者处理设备的系统UI变化,如状态栏、导航栏、软键盘等,给ViewCompat.getRootWindowInsets传入decorView拿到其实例,利用isVisible方法判断软键盘(WindowInsetsCompat.Type.ime())是否显示。


隐藏软键盘


private fun hideSoftInPut(currentFocus: View) {
   currentFocus.let {
    //清除焦点
       it.clearFocus()
    //关闭软键盘
       val imm = getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
       imm.hideSoftInputFromWindow(it.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
  }
}

首先要清除当前EditText的焦点,防止出现键盘收起但是焦点还在的情况:



最后是获取系统Service隐藏当前的键盘。


来看看最终的效果吧:



3.结尾


以上就是关于点击EditText外部区域隐藏软键盘并且清除焦点的实现方法,当然这只是其中的一种方式,如有不足请在评论区或私信指出,如果你们有更多的实现方法也欢迎在论区或私信留言捏❤️❤️


作者:Otaku_尻男
来源:juejin.cn/post/7226248402798936119
收起阅读 »

Android大图预览

前言 加载高清大图时,往往会有不能缩放和分段加载的需求出现。本文将就BitmapRegionDecoder和subsampling-scale-image-view的使用总结一下Bitmap的分区域解码。 定义 假设现在有一张这样的图片,尺寸为3040 × ...
继续阅读 »

前言


加载高清大图时,往往会有不能缩放分段加载的需求出现。本文将就BitmapRegionDecodersubsampling-scale-image-view的使用总结一下Bitmap的分区域解码


定义


image.png


假设现在有一张这样的图片,尺寸为3040 × 1280。如果按需要完全显示在ImageView上的话就必须进行压缩处理。当需求要求是不能缩放的时候,就需要进行分段查看了。由于像这种尺寸大小的图片在加载到内存后容易造成OOM,所以需要进行区域解码


图中红框的部分就是需要区域解码的部分,即每次只有进行红框区域大小的解码,在需要看其余部分时可以通过如拖动等手势来移动红框区域,达到查看全图的目的。


BitmapRegionDecoder


Android原生提供了BitmapRegionDecoder用于实现Bitmap的区域解码,简单使用的api如下:


// 根据图片文件的InputStream创建BitmapRegionDecoder
val decoder = BitmapRegionDecoder.newInstance(inputStream, false)

val option: BitmapFactory.Options = BitmapFactory.Options()
val rect: Rect = Rect(0, 0, 100, 100)

// rect制定的区域即为需要区域解码的区域
decoder.decodeRegion(rect, option)


  • 通过BitmapRegionDecoder.newInstance可以根据图片文件的InputStream对象创建一个BitmapRegionDecoder对象。

  • decodeRegion方法传入一个Rect和一个BitmapFactory.Options,前者用于规定解码区域,后者用于配置Bitmap,如inSampleSize、inPreferredConfig等。ps:解码区域必须在图片宽高范围内,否则会出现崩溃。


区域解码与全图解码


通过区域解码得到的Bitmap,宽高和占用内存只是指定区域的图像所需要的大小


譬如按1080 × 1037区域大小加载,可以查看Bitmap的allocationByteCount为4479840,即1080 * 1037 * 4


image.png


若直接按全图解码,allocationByteCount为15564800,即3040 * 1280 * 4
image.png


可以看到,区域解码的好处是图像不会完整的被加载到内存中,而是按需加载了。


自定义一个图片查看的View


由于BitmapRegionDecoder只是实现区域解码,如果改变这个区域还是需要开发者通过具体交互实现。这里用触摸事件简单实现了一个自定义View。由于只是简单依赖触摸事件,滑动的灵敏度还是偏高,实际开发可以实现一些自定义的拖拽工具来进行辅助。代码比较简单,可参考注释。


class RegionImageView @JvmOverloads constructor(
context: Context,
attr: AttributeSet? = null,
defStyleAttr: Int = 0
) : View(context, attr, defStyleAttr) {

private var decoder: BitmapRegionDecoder? = null
private val option: BitmapFactory.Options = BitmapFactory.Options()
private val rect: Rect = Rect()

private var lastX: Float = -1f
private var lastY: Float = -1f

fun setImage(fileName: String) {
val inputStream = context.assets.open(fileName)
try {
this.decoder = BitmapRegionDecoder.newInstance(inputStream, false)

// 触发onMeasure,用于更新Rect的初始值
requestLayout()
} catch (e: Exception) {
e.printStackTrace()
} finally {
inputStream.close()
}
}

override fun onTouchEvent(event: MotionEvent?): Boolean {
when (event?.action) {
MotionEvent.ACTION_DOWN -> {
this.decoder ?: return false
this.lastX = event.x
this.lastY = event.y
return true
}
MotionEvent.ACTION_MOVE -> {
val decoder = this.decoder ?: return false
val dx = event.x - this.lastX
val dy = event.y - this.lastY

// 每次MOVE事件根据前后差值对Rect进行更新,需要注意不能超过图片的实际宽高
if (decoder.width > width) {
this.rect.offset(-dx.toInt(), 0)
if (this.rect.right > decoder.width) {
this.rect.right = decoder.width
this.rect.left = decoder.width - width
} else if (this.rect.left < 0) {
this.rect.right = width
this.rect.left = 0
}
invalidate()
}
if (decoder.height > height) {
this.rect.offset(0, -dy.toInt())
if (this.rect.bottom > decoder.height) {
this.rect.bottom = decoder.height
this.rect.top = decoder.height - height
} else if (this.rect.top < 0) {
this.rect.bottom = height
this.rect.top = 0
}
invalidate()
}
}
MotionEvent.ACTION_UP -> {
this.lastX = -1f
this.lastY = -1f
}
else -> {

}
}

return super.onTouchEvent(event)
}

// 测量后默认第一次加载的区域是从0开始到控件的宽高大小
override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec)

val w = MeasureSpec.getSize(widthMeasureSpec)
val h = MeasureSpec.getSize(heightMeasureSpec)

this.rect.left = 0
this.rect.top = 0
this.rect.right = w
this.rect.bottom = h
}

// 每次绘制时,通过BitmapRegionDecoder解码出当前区域的Bitmap
override fun onDraw(canvas: Canvas?) {
super.onDraw(canvas)
canvas?.let {
val bitmap = this.decoder?.decodeRegion(rect, option) ?: return
it.drawBitmap(bitmap, 0f, 0f, null)
}
}
}

SubsamplingScaleImageView


davemorrissey/subsampling-scale-image-view可以用于加载超大尺寸的图片,避免大内存导致的OOM,内部依赖的也是BitmapRegionDecoder。好处是SubsamplingScaleImageView已经帮我们实现了相关的手势如拖动、缩放,内部还实现了二次采样和区块显示的逻辑。


如果需要加载assets目录下的图片,可以这样调用


subsamplingScaleImageView.setImage(ImageSource.asset("sample1.jpeg"))

public final class ImageSource {

static final String FILE_SCHEME = "file:///";
static final String ASSET_SCHEME = "file:///android_asset/";

private final Uri uri;
private final Bitmap bitmap;
private final Integer resource;
private boolean tile;
private int sWidth;
private int sHeight;
private Rect sRegion;
private boolean cached;

ImageSource是对图片资源信息的抽象



  • uri、bitmap、resource分别指代图像来源是文件、解析好的Bitmap对象还是resourceId。

  • tile:是否需要分片加载,一般以uri、resource形式加载的都会为true。

  • sWidth、sHeight、sRegion:加载图片的宽高和区域,一般可以指定加载图片的特定区域,而不是全图加载

  • cached:控制重置时,是否需要recycle掉Bitmap


public final void setImage(@NonNull ImageSource imageSource, ImageSource previewSource, ImageViewState state) {
...

if (imageSource.getBitmap() != null && imageSource.getSRegion() != null) {
...
} else if (imageSource.getBitmap() != null) {
...
} else {
sRegion = imageSource.getSRegion();
uri = imageSource.getUri();
if (uri == null && imageSource.getResource() != null) {
uri = Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE + "://" + getContext().getPackageName() + "/" + imageSource.getResource());
}
if (imageSource.getTile() || sRegion != null) {
// Load the bitmap using tile decoding.
TilesInitTask task = new TilesInitTask(this, getContext(), regionDecoderFactory, uri);
execute(task);
} else {
// Load the bitmap as a single image.
BitmapLoadTask task = new BitmapLoadTask(this, getContext(), bitmapDecoderFactory, uri, false);
execute(task);
}
}
}

由于在我们的调用下,tile为true,setImage方法最后会走到一个TilesInitTask当中。是一个AsyncTask。ps:该库中的多线程异步操作都是通过AsyncTask封装的。


// TilesInitTask
@Override
protected int[] doInBackground(Void... params) {
try {
String sourceUri = source.toString();
Context context = contextRef.get();
DecoderFactory<? extends ImageRegionDecoder> decoderFactory = decoderFactoryRef.get();
SubsamplingScaleImageView view = viewRef.get();
if (context != null && decoderFactory != null && view != null) {
view.debug("TilesInitTask.doInBackground");
decoder = decoderFactory.make();
Point dimensions = decoder.init(context, source);
int sWidth = dimensions.x;
int sHeight = dimensions.y;
int exifOrientation = view.getExifOrientation(context, sourceUri);
if (view.sRegion != null) {
view.sRegion.left = Math.max(0, view.sRegion.left);
view.sRegion.top = Math.max(0, view.sRegion.top);
view.sRegion.right = Math.min(sWidth, view.sRegion.right);
view.sRegion.bottom = Math.min(sHeight, view.sRegion.bottom);
sWidth = view.sRegion.width();
sHeight = view.sRegion.height();
}
return new int[] { sWidth, sHeight, exifOrientation };
}
} catch (Exception e) {
Log.e(TAG, "Failed to initialise bitmap decoder", e);
this.exception = e;
}
return null;
}

@Override
protected void onPostExecute(int[] xyo) {
final SubsamplingScaleImageView view = viewRef.get();
if (view != null) {
if (decoder != null && xyo != null && xyo.length == 3) {
view.onTilesInited(decoder, xyo[0], xyo[1], xyo[2]);
} else if (exception != null && view.onImageEventListener != null) {
view.onImageEventListener.onImageLoadError(exception);
}
}
}

TilesInitTask主要的操作是创建一个SkiaImageRegionDecoder,它主要的作用是封装BitmapRegionDecoder。通过BitmapRegionDecoder获取图片的具体宽高和在Exif中获取图片的方向,便于显示调整。


后续会在onDraw时调用initialiseBaseLayer方法进行图片的加载操作,这里会根据比例计算出采样率来决定是否需要区域解码还是全图解码。值得一提的是,当采样率为1,图片宽高小于Canvas的getMaximumBitmapWidth()getMaximumBitmapHeight()时,也是会直接进行全图解码的。这里调用的TileLoadTask就是使用BitmapRegionDecoder进行解码的操作。


ps:Tile对象为区域的抽象类型,内部会包含指定区域的Bitmap,在onDraw时会根据区域通过Matrix绘制到Canvas上。


private synchronized void initialiseBaseLayer(@NonNull Point maxTileDimensions) {
debug("initialiseBaseLayer maxTileDimensions=%dx%d", maxTileDimensions.x, maxTileDimensions.y);

satTemp = new ScaleAndTranslate(0f, new PointF(0, 0));
fitToBounds(true, satTemp);

// Load double resolution - next level will be split into four tiles and at the center all four are required,
// so don't bother with tiling until the next level 16 tiles are needed.
fullImageSampleSize = calculateInSampleSize(satTemp.scale);
if (fullImageSampleSize > 1) {
fullImageSampleSize /= 2;
}

if (fullImageSampleSize == 1 && sRegion == null && sWidth() < maxTileDimensions.x && sHeight() < maxTileDimensions.y) {
// Whole image is required at native resolution, and is smaller than the canvas max bitmap size.
// Use BitmapDecoder for better image support.
decoder.recycle();
decoder = null;
BitmapLoadTask task = new BitmapLoadTask(this, getContext(), bitmapDecoderFactory, uri, false);
execute(task);
} else {
initialiseTileMap(maxTileDimensions);

List<Tile> baseGrid = tileMap.get(fullImageSampleSize);
for (Tile baseTile : baseGrid) {
TileLoadTask task = new TileLoadTask(this, decoder, baseTile);
execute(task);
}
refreshRequiredTiles(true);

}

}

加载网络图片


BitmapRegionDecoder只能加载本地图片,而如果需要加载网络图片,可以结合Glide使用,以SubsamplingScaleImageView为例


Glide.with(this)
.asFile()
.load("")
.into(object : CustomTarget<File?>() {
override fun onResourceReady(resource: File, transition: Transition<in File?>?) {
subsamplingScaleImageView.setImage(ImageSource.uri(Uri.fromFile(resource)))
}

override fun onLoadCleared(placeholder: Drawable?) {}
})

可以通过CustomTarget获取到图片的File文件,然后再调用SubsamplingScaleImageView#setImage


最后


本文主要总结Bitmap的分区域解码,利用原生的BitmapRegionDecoder可实现区域解码,通过SubsamplingScaleImageView可以对BitmapRegionDecoder进行进一步的交互扩展和优化。如果需要是TV端开发可以参考这篇文章,里面有结合具体的TV端操作适配:Android实现TV端大图浏览


参考文章:



Android实现TV端大图浏览


tddrv.cn/a/233555


Android 超大图长图浏览库 SubsamplingScaleImageView 源码解析



作者:Cy13er
来源:juejin.cn/post/7224311569778229304
收起阅读 »

Android动态权限申请从未如此简单

前言 注:只想看实现的朋友们可以直接跳到最后面的最终实现 大家是否还在为动态权限申请感到苦恼呢?传统的动态权限申请需要在Activity中重写onRequestPermissionsResult方法来接收用户权限授予的结果。试想一下,你需要在一个子模块中申请权...
继续阅读 »

前言


注:只想看实现的朋友们可以直接跳到最后面的最终实现


大家是否还在为动态权限申请感到苦恼呢?传统的动态权限申请需要在Activity中重写onRequestPermissionsResult方法来接收用户权限授予的结果。试想一下,你需要在一个子模块中申请权限,那得从这个模块所在的ActivityonRequestPermissionsResult中将结果一层层再传回到这个模块中,相当的麻烦,代码也相当冗余和不干净,逼死强迫症。


使用


为了解决这个痛点,我封装出了两个方法,用于随时随地快速的动态申请权限,我们先来看看我们的封装方法是如何调用的:


activity.requestPermission(Manifest.permission.CAMERA, onPermit = {
//申请权限成功 Do something
}, onDeny = { shouldShowCustomRequest ->
//申请权限失败 Do something
if (shouldShowCustomRequest) {
//用户选择了拒绝并且不在询问,此时应该使用自定义弹窗提醒用户授权(可选)
}
})

这样是不是非常的简单便捷?申请和结果回调都在一个方法内处理,并且支持随用随调。


方案


那么,这么方便好用的方法是怎么实现的呢?不知道小伙伴们在平时开发中有没有注意到过,当你调用startActivityForResult时,AS会提示你该方法已被弃用,点进去看会告诉你应该使用registerForActivityResult方法替代。没错,这就是androidx给我们提供的ActivityResult功能,并且这个功能不仅支持ActivityResult回调,还支持打开文档,拍摄照片,选择文件等各种各样的回调,同样也包括我们今天要说的权限申请


其实Android在官方文档 请求运行时权限 中就已经将其作为动态权限申请的推荐方法了,如下示例代码所示:


val requestPermissionLauncher =
registerForActivityResult(RequestPermission()
) { isGranted: Boolean ->
if (isGranted) {
// Permission is granted. Continue the action or workflow in your
// app.
} else {
// Explain to the user that the feature is unavailable because the
// feature requires a permission that the user has denied. At the
// same time, respect the user's decision. Don't link to system
// settings in an effort to convince the user to change their
// decision.
}
}

when {
ContextCompat.checkSelfPermission(
CONTEXT,
Manifest.permission.REQUESTED_PERMISSION
) == PackageManager.PERMISSION_GRANTED -> {
// You can use the API that requires the permission.
}
shouldShowRequestPermissionRationale(...) -> {
// In an educational UI, explain to the user why your app requires this
// permission for a specific feature to behave as expected, and what
// features are disabled if it's declined. In this UI, include a
// "cancel" or "no thanks" button that lets the user continue
// using your app without granting the permission.
showInContextUI(...)
}
else -> {
// You can directly ask for the permission.
// The registered ActivityResultCallback gets the result of this request.
requestPermissionLauncher.launch(
Manifest.permission.REQUESTED_PERMISSION)
}
}

说到这里,可能有小伙伴要质疑我了:“官方文档里都写明了的东西,你还特地写一遍,还起了这么个标题,是不是在水文章?!”


莫急,如果你遵照以上方法这么写的话,在实际调用的时候会直接发生崩溃:


java.lang.IllegalStateException: 
LifecycleOwner Activity is attempting to register while current state is RESUMED.
LifecycleOwners must call register before they are STARTED.

这段报错很明显的告诉我们,我们的注册工作必须要在Activity声明周期STARTED之前进行(也就是onCreate时和onStart完成前),但这样我们就必须要事先注册好所有可能会用到的权限,没办法做到随时随地有需要时再申请权限了,有办法解决这个问题吗?答案是肯定的。


绕过生命周期检测


想解决这个问题,我们必须要知道问题的成因,让我们带着问题进到源码中一探究竟:


public final <I, O> ActivityResultLauncher<I> registerForActivityResult(
@NonNull ActivityResultContract<I, O> contract,
@NonNull ActivityResultCallback<O> callback)
{
return registerForActivityResult(contract, mActivityResultRegistry, callback);
}

public final <I, O> ActivityResultLauncher<I> registerForActivityResult(
@NonNull final ActivityResultContract<I, O> contract,
@NonNull final ActivityResultRegistry registry,
@NonNull final ActivityResultCallback<O> callback)
{
return registry.register(
"activity_rq#" + mNextLocalRequestCode.getAndIncrement(), this, contract, callback);
}

public final <I, O> ActivityResultLauncher<I> register(
@NonNull final String key,
@NonNull final LifecycleOwner lifecycleOwner,
@NonNull final ActivityResultContract<I, O> contract,
@NonNull final ActivityResultCallback<O> callback)
{

Lifecycle lifecycle = lifecycleOwner.getLifecycle();

if (lifecycle.getCurrentState().isAtLeast(Lifecycle.State.STARTED)) {
throw new IllegalStateException("LifecycleOwner " + lifecycleOwner + " is "
+ "attempting to register while current state is "
+ lifecycle.getCurrentState() + ". LifecycleOwners must call register before "
+ "they are STARTED.");
}

registerKey(key);
LifecycleContainer lifecycleContainer = mKeyToLifecycleContainers.get(key);
if (lifecycleContainer == null) {
lifecycleContainer = new LifecycleContainer(lifecycle);
}
LifecycleEventObserver observer = new LifecycleEventObserver() { ... };
lifecycleContainer.addObserver(observer);
mKeyToLifecycleContainers.put(key, lifecycleContainer);

return new ActivityResultLauncher<I>() { ... };
}

我们可以发现,registerForActivityResult实际上就是调用了ComponentActivity内部成员变量的mActivityResultRegistry.register方法,而在这个方法的一开头就检查了当前Activity的生命周期,如果生命周期位于STARTED后则直接抛出异常,那我们该如何绕过这个限制呢?


其实在register方法的下面就有一个同名重载方法,这个方法并没有做生命周期的检测:


public final <I, O> ActivityResultLauncher<I> register(
@NonNull final String key,
@NonNull final ActivityResultContract<I, O> contract,
@NonNull final ActivityResultCallback<O> callback)
{
registerKey(key);
mKeyToCallback.put(key, new CallbackAndContract<>(callback, contract));

if (mParsedPendingResults.containsKey(key)) {
@SuppressWarnings("unchecked")
final O parsedPendingResult = (O) mParsedPendingResults.get(key);
mParsedPendingResults.remove(key);
callback.onActivityResult(parsedPendingResult);
}
final ActivityResult pendingResult = mPendingResults.getParcelable(key);
if (pendingResult != null) {
mPendingResults.remove(key);
callback.onActivityResult(contract.parseResult(
pendingResult.getResultCode(),
pendingResult.getData()));
}

return new ActivityResultLauncher<I>() { ... };
}

找到这个方法就简单了,我们将registerForActivityResult方法调用替换成activityResultRegistry.register调用就可以了


当然,我们还需要注意一些小细节,检查生命周期的register方法同时也会注册生命周期回调,当Activity被销毁时会将我们注册的ActivityResult回调移除,我们也需要给我们封装的方法加上这个逻辑,最终实现就如下所示。


最终实现


private val nextLocalRequestCode = AtomicInteger()

private val nextKey: String
get() = "activity_rq#${nextLocalRequestCode.getAndIncrement()}"

fun ComponentActivity.requestPermission(
permission: String,
onPermit: () -> Unit,
onDeny: (shouldShowCustomRequest: Boolean) -> Unit
)
{
if (ContextCompat.checkSelfPermission(this, permission) == PackageManager.PERMISSION_GRANTED) {
onPermit()
return
}
var launcher by Delegates.notNull<ActivityResultLauncher<String>>()
launcher = activityResultRegistry.register(
nextKey,
ActivityResultContracts.RequestPermission()
) { result ->
if (result) {
onPermit()
} else {
onDeny(!ActivityCompat.shouldShowRequestPermissionRationale(this, permission))
}
launcher.unregister()
}
lifecycle.addObserver(object : LifecycleEventObserver {
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
if (event == Lifecycle.Event.ON_DESTROY) {
launcher.unregister()
lifecycle.removeObserver(this)
}
}
})
launcher.launch(permission)
}

fun ComponentActivity.requestPermissions(
permissions: Array<String>,
onPermit: () -> Unit,
onDeny: (shouldShowCustomRequest: Boolean) -> Unit
)
{
var hasPermissions = true
for (permission in permissions) {
if (ContextCompat.checkSelfPermission(
this,
permission
) != PackageManager.PERMISSION_GRANTED
) {
hasPermissions = false
break
}
}
if (hasPermissions) {
onPermit()
return
}
var launcher by Delegates.notNull<ActivityResultLauncher<Array<String>>>()
launcher = activityResultRegistry.register(
nextKey,
ActivityResultContracts.RequestMultiplePermissions()
) { result ->
var allAllow = true
for (allow in result.values) {
if (!allow) {
allAllow = false
break
}
}
if (allAllow) {
onPermit()
} else {
var shouldShowCustomRequest = false
for (permission in permissions) {
if (!ActivityCompat.shouldShowRequestPermissionRationale(this, permission)) {
shouldShowCustomRequest = true
break
}
}
onDeny(shouldShowCustomRequest)
}
launcher.unregister()
}
lifecycle.addObserver(object : LifecycleEventObserver {
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
if (event == Lifecycle.Event.ON_DESTROY) {
launcher.unregister()
lifecycle.removeObserver(this)
}
}
})
launcher.launch(permissions)
}

总结


其实很多实用技巧本质上都是很简单的,但没有接触过就很难想到,我将我的开发经验分享给大家

作者:dreamgyf
来源:juejin.cn/post/7225516176171188285
,希望能帮助到大家。

收起阅读 »

怎么实现微信扫码登录

web
最近在给企业健康管理系统做一个微信扫码登录的功能,借此机会总结下微信登录这个技术点。 网站应用微信登录是基于 OAuth2.0 协议标准构建的。OAuth 协议规范了五种授权模式,Authorization Code、PKCE、Client CreDentia...
继续阅读 »

最近在给企业健康管理系统做一个微信扫码登录的功能,借此机会总结下微信登录这个技术点。


网站应用微信登录是基于 OAuth2.0 协议标准构建的。OAuth 协议规范了五种授权模式,Authorization Code、PKCE、Client CreDentials、Device Code 和 Refresh Token。微信目前只支持 authorization_code 模式。


微信网站应用接入基础知识


第一步需要先到微信开放平台注册一个开发者账号,并创建一个微信登录网站应用,然后获得AppIDAppSecret


微信的authorization_code模式:



  1. 发起微信授权登录请求



// 请求格式
https://open.weixin.qq.com/connect/qrconnect?appid=APPID&redirect_uri=REDIRECT_URI&response_type=code&scope=SCOPE&state=STATE#wechat_redirect



  1. 用户扫码授权之后,微信会重定向到回调地址并且给予一个临时票据code;

  2. 后端拿codeAppIDAppSecret通过 API 换取access_token;

  3. 通过access_token进行接口调用,换取用户基本信息

  4. 根据用户信息中的 openId 查询是否已经和系统用户绑定


流程图:


微信官方


关于 state 参数:


state参数: state 参数会在用户授权成功后和code一起携带给 redirect URL。主要用来做 CSRF 防范。



redirect_url?code=CODE&state=STATE

关于 code:
Code 的超时时间为 10 分钟,一个 code 只能成功换取一个 access_token 即失效。


关于展示形式


微信登录有两种展示形式,一种是弹窗打开登录二维码,另一种是将二维码嵌套在自己网页内


我们的设计


交互流程


login_flow.png


前端工作流程:


1、二维码展示,请求/wechat/qrcode 地址获取二维码地址,返回的参数有 state 字段(重要)。


Note:后端生成一个 uuid state,并存储在 Redis 中用来检测用户的扫码状态


2、在当前二维码页面轮询/wechat/qrcode/status/{state} 接口,判断是否已授权、未绑定、已绑定三种状态。


1)未授权,继续轮询

2)已授权已绑定,根据/wechat/qrcode/status/{state} 接口返回的租户、登录凭证,调用登录接口/login/wechat。

3)已授权未绑定,进去用户绑定微信流程

> 用户绑定微信流程
请求/wechat/bind/sms/send 接口,发送用户绑定微信的验证码
请求/wechat/bind 接口,绑定用户。
根据/wechat/bind 接口返回的租户、凭证信息,调用登录接口/login/wechat。

参考文档


网站应用微信登录开发指南


博客原文


iloveu.xyz/2023/04/25/…


作者:贾克森
来源:juejin.cn/post/7225867003720974373
收起阅读 »

微信小程序背景音频开发

web
最近又新开发了一款听书类的小程序,现在一阶段已基本完工。代码已开源,链接在文章结尾。欢迎star。 本期给大家讲解一下关于背景音频开发的一些基本业务场景和踩坑。 1.需求拆解 先来看一张图: 从图中可以看到,基本的业务包含以下几个部分 播放 暂停 切换上一...
继续阅读 »

最近又新开发了一款听书类的小程序,现在一阶段已基本完工。代码已开源,链接在文章结尾。欢迎star。


本期给大家讲解一下关于背景音频开发的一些基本业务场景和踩坑。


1.需求拆解


先来看一张图:


image.png
从图中可以看到,基本的业务包含以下几个部分



  1. 播放

  2. 暂停

  3. 切换上一个音频

  4. 切换下一个音频

  5. 拖动进度条改变音频进度

  6. 音频进度时间

  7. 音频总时间

  8. 在音频列表切换任意的音频


还有一个需求就是在小程序退出以后,还会播放:


image.png
在上图里看到,当背景音频播放的时候,会出现上方这个小图标:


image.png
同样的,在手机的通知栏里面,长这样子:
image.png


接下来我们动手实现一下整个功能。


2. 技术分析


要想实现背景音频,我们需要使用微信小程序提供的一个API:getBackgroundAudioManager(),因为我这里使用的UNI开发的,所以直接贴的是UNI的文档了。具体方法参数可以查看文档。


这里注意以下几个点:



  • ios App平台,背景播放需在manifest.json -> app-plus -> distribute -> ios 节点添加 "UIBackgroundModes":["audio"] 才能保证音乐可以后台播放(打包成ipa生效)

  • 小程序平台,需在manifest.json 对应的小程序节点下,填写"requiredBackgroundModes": ["audio"]。发布小程序时平台会审核。

  • 在page.json中添加"UIBackgroundModes":["audio"]

  • 配置完以后,重新编译一下项目。


3. 功能实现


3.1 播放slider


1.获取音频数据


在进入播放音频页面的时候,默认获取一下第一个需要播放的音频。我这里是是根据音频的id去获取音频的详情信息:


/**
* @description: 获取专辑声音详情信息
* @returns {*}
*/

const getTrackInfo = async (trackId: number) => {
try {
const res = await albumsService.getTrackInfo(trackId)
trackInfo.value = res.data
audios.trackId = res.data?.id as number;
createBgAudioManager()
} catch (error) {
console.log(error)
}
}
onLoad((options) => {
const { trackId } = options
audios.trackId = trackId
getTrackInfo(trackId)
})

getTrackInfo返回的的数据里面长这样的:


image.png
播放音频需要设置红色框标识的字段。


2.创建音频


请求成功,拿到音频详情数据,就需要创建背景音频。


// 初始化背景音频控件
const bgAudioManager = uni.getBackgroundAudioManager();

/**
* @description: 修改音频地址
* @returns {*}
*/

const createBgAudioManager = () => {
// 音频测试地址
// innerAudioContext.src = 'https://bjetxgzv.cdn.bspapp.com/VKCEYUGU-hello-uniapp/2cc220e0-c27a-11ea-9dfb-6da8e309e0d8.mp3';
if (bgAudioManager) {

// 若原先的音频未暂停,则先暂停
if (!bgAudioManager.paused) {
// stop和pause是不一样的,stop直接停止播放,然后从头开始
bgAudioManager.stop();
}
bgAudioManager.title = trackInfo.value?.trackTitle;
bgAudioManager.coverImgUrl = trackInfo.value?.coverUrl
// 设置了src以后会自动播放
bgAudioManager.src = trackInfo.value?.mediaUrl;
// bgAudioManager.autoplay = true;
initAudio(bgAudioManager)
}
}


这里注意一下,title是必须要设置的。不然音频不播放。当设置了src以后,音频会自动进行播放,无需设置autoPlay。



3.获取播放进度和音频总长度


在上面的函数里面,有个initAudio函数。


/**
* @description: 初始化音频相关的方法
* @param {*} ctx
* @returns {*}
*/

const initAudio = (ctx: any) => {
ctx.onTimeUpdate((e) => {
// 当拖动进度条的时候不需要更新进度,使用seek方法
if(!sliders.isDraging) {
// 获取当前进度
const currentTime:number = ctx.currentTime
// 跟新音频进度和slider进度
if (currentTime) {
sliders.progressTime = ctx.currentTime
audios.currentTime = formatTime(currentTime);
}
}
})
ctx.onCanplay(() => {
setTimeout(() => {
console.log('音频长度', bgAudioManager.duration);
// 音频长度,时分秒格式
const duration = bgAudioManager.duration
audios.duration = formatTime(duration);
// 进度条长度=音频长度
sliders.max = duration
}, 300)
})
ctx.onPlay(() => {
audios.playStatus = true
})
ctx.onPause(() => {
audios.playStatus = false
})
ctx.onEnded((e) => {
// 播放结束自动切换到下一首歌
nextAudio()
})
}

onCanplay中,我们可以获取音频的总长度,注意这里的setTimeout必须加,不然获取不到duration。这里需要把秒格式和时分秒的格式都保存下来。


onTimeUpdate中,我们可以获取到当前音频播放的进度。然后实时更新进度条。


接下来就是进度条的实现了。


这里我用的是uni内置组件中的slider组件。


<slider
step="1"
activeColor="#f86442"
block-color="#fff"
block-size="10"
:min="0"
:max="sliders.max"
:value="sliders.progressTime"
@change="sliderChange"
@touchstart="handleSliderMoveStart "
@touchend="handleSliderMoveEnd"
/>


max必须设置,也就是音频的总长度。
value值是当前音频播放的进度。


4.拖动进度条


当拖动进度条的时候,触发sliderChange事件,改变音频的进度。



/**
* @description: 进度条改变事件
* @returns {*}
*/

const sliderChange = (e) => {
console.log(e);
// 拖动slider的值
const position = e.detail.value
seekAudio(position)
}
/**
* 音频跳转
*/

const seekAudio = (position: number) => {
bgAudioManager.seek(position)
// 修改当前进度
audios.currentTime = formatTime(position)
sliders.progressTime = position
}

这里通过seek方法来设置进度的跳转。


当拖动进度条的时候,在onTimeUpdate中也在修改进度。两个之间会打架。所以这里我们在onTimeUpdate中使用isDraging字段来控制。当鼠标按下和抬起的时候来控制isDraging的值,不让onTimeUpdate修改进度。


/**
* @description: 开始拖动进度条事件
* @returns {*}
*/

const handleSliderMoveStart = () => {
sliders.isDraging = true
}
/**
* @description: 结束拖动进度条时间
* @returns {*}
*/

const handleSliderMoveEnd = () => {
sliders.isDraging = false
}

// 此逻辑在前面的代码有了
ctx.onTimeUpdate((e) => {
// 当拖动进度条的时候不需要更新进度,使用seek方法
if(!sliders.isDraging) {
...
}
})

3.2 播放暂停


播放和暂停就非常简单了。


通过playStatus字段来控制播放和暂停按钮的样式切换即可。


其次是事件:


/**
* @description: 暂停音频
* @returns {*}
*/

const pauseAudio = () => {
bgAudioManager.pause() // 停止
}

/**
* @description: 播放音频
* @returns {*}
*/

const playAudio = () => {
bgAudioManager.play() // 播放
}

// 在钩子函数监听

ctx.onPlay(() => {
audios.playStatus = true
})
ctx.onPause(() => {
audios.playStatus = false
})

3.3 音频列表渲染和切换


image.png


这个列表怎么渲染的我就不讲了。这里还有个下拉刷新和上拉加载更多的功能。


当点击某个音频,获取对应的id,然后请求接口获取对应的音频详情。接口和流程跟之前的一样。唯一注意的是,当我们点击的是正在播放的一个音频的话,啥也不要做。还有一个注意的点,当切换音频的时候需要先暂停,然后再设置src和别的属性。



const createBgAudioManager = () => {

if (bgAudioManager) {

// 若原先的音频未暂停,则先暂停
if (!bgAudioManager.paused) {
// stop和pause是不一样的,stop直接停止播放,然后从头开始
bgAudioManager.stop();
}
bgAudioManager.title = trackInfo.value?.trackTitle;
bgAudioManager.coverImgUrl = trackInfo.value?.coverUrl
// 设置了src以后会自动播放
bgAudioManager.src = trackInfo.value?.mediaUrl;
// bgAudioManager.autoplay = true;
initAudio(bgAudioManager)
}
}

注意这里的暂停不是pause,是stop。


3.4 上一个下一个切换


当切换上一个和下一个音频的时候,逻辑也是需要票拿到对应的id,然后请求音频详细数据。


/**
* @description: 切换上一首音频
* @returns {*}
*/

const prevAudio = () => {
// 判断是不是第一首,是则提示
const firstId = audioList.value[0]?.trackId
if (firstId === audios.trackId) {
uni.showToast({
title : "当前已经是第一首了",
icon : "none"
})
return;
}
// 获取上一首的id
// 从播放列表寻找
let id = 0;
audioList.value.forEach((item, index) => {
if (item.trackId === audios.trackId) {
id = audioList.value[index - 1]?.trackId
}
})

getTrackInfo(id)
}
/**
* @description: 切换下一首音频
* @returns {*}
*/

const nextAudio = () => {
// 判断是不是最后一首。是则提示
const len = audioList.value.length
const lastId = audioList.value[len - 1]?.trackId
if (lastId === audios.trackId) {
uni.showToast({
title : "当前播放列表已是最新的了,请加载更多",
icon : "none"
})
return;
}
// 获取下一首的id
// 从播放列表寻找
let id = 0;
audioList.value.forEach((item, index) => {
if (item.trackId === audios.trackId) {
id = audioList.value[index + 1]?.trackId
}
})
getTrackInfo(id)
}

这里只需要注意的是,如果是第一个和最后一个音频,需要做特殊处理。


3.5 播放结束


最后,当某个音频播放结束的时候,直接请求nextAudio函数即可。


ctx.onEnded((e) => {
// 播放结束自动切换到下一首歌
nextAudio()
})

到此为止,我想要的功能基本全部实现了。


4. 更多功能



  • 实时上报播放进度

  • 音频地址防盗

  • 付费,免费体验功能


5. 代码地址


完整代码地址参考:gitee.com/xiumubai/li…


作者:白哥学前端
来源:juejin.cn/post/7226228585371041848
收起阅读 »

不就new个对象的事,为什么要把简单的问题复杂化?为什么要使用Hilt依赖注入?看完就知道!

为什么要使用Hilt依赖注入 之前有写过一些文章 Hilt与Koin的对比,和 Android开发中Hilt的常用场景。看起来是非常简单与实用了,但是会引起一些同学的疑问? 为什么要使用依赖注入?直接new对象不香吗?为什么要把简单的问题复杂化? 你是不是在炫...
继续阅读 »

为什么要使用Hilt依赖注入


之前有写过一些文章 Hilt与Koin的对比,和 Android开发中Hilt的常用场景。看起来是非常简单与实用了,但是会引起一些同学的疑问?


为什么要使用依赖注入?直接new对象不香吗?为什么要把简单的问题复杂化?


你是不是在炫技,是不是像装13?


这还真不是,如果说我使用的Dagger2,还真是炫技,NB啊。Dagger的坑也是真的多,能在大项目中把Dagger用好,那还真是牛,但是我们现在都用Hilt了有什么可装的,使用是真的简单,都是一些场景化的东西,一些固定用法。没必要没必要。


回归正题,为什么要使用依赖注入?哪种情况下推荐使用依赖注入?就算要用依赖注入,为什么依赖注入推荐使用Hilt?


一、自动管理(灵活与解耦)


首先不是说大家写项目就一定要使用依赖注入,如果大家的项目不是大项目,总共就5、6个,10多个页面,你没必要上依赖注入框架,如果是大项目,分模块,分组件,多人协同开发的,并且可能依赖的对象很复杂,或者说套娃似的对象依赖,那么使用Hilt就非常方便。不同模块/组件的开发人员直接在他自己的组件/模块下定义好对象的提供方式,另一边直接用即可,无需关系依赖的复杂度,和实现的逻辑。


我们先看看一些复杂的嵌套依赖,比如我们来一个三层套娃的依赖:


@Singleton
class UserServer @Inject constructor(private val userDao: UserDao) {

fun testUser() {
YYLogUtils.w(userDao.printUser())
toast(userDao.printUser())
}

fun getDaoContent():String{
return userDao.printUser()
}

}

@Singleton
class UserDao @Inject constructor(private val user: UserBean) {

fun printUser(): String {
return user.toString()
}

}

data class UserBean(
val name: String,
val age: Int,
val gender: Int,
val languages: List<String>
)

其他三个类都是必须了,其实也就多了一个这个类,提供UserBean对象


@Module
@InstallIn(SingletonComponent::class)
class Demo10DIModule {

@Singleton
@Provides
fun provideUser(): UserBean {
return UserBean("newki", 18, 1, listOf("中文", "英文"))
}

}

使用:


@AndroidEntryPoint
class Demo10DIActivity : BaseVMActivity() {

@Inject
lateinit var userServer: UserServer

override fun getLayoutIdRes(): Int = R.layout.activity_demo10_di

override fun init() {
findViewById<Button>(R.id.btn_01).click {
YYLogUtils.w(userServer.toString())
userServer.testUser()
}
}

如果不使用Hilt,自己new对象也能实现


class Demo10DIActivity : BaseVMActivity() {

lateinit var userServer: UserServer

override fun getLayoutIdRes(): Int = R.layout.activity_demo10_di

override fun init() {
//自己new三个对象
userServer = UserServer(UserDao(UserBean("newki", 18, 1, listOf("中文", "英文"))))

findViewById<Button>(R.id.btn_01).click {
YYLogUtils.w(userServer.toString())
userServer.testUser()
}
}

这样new出来的对象,且不说生命周期是跟随页面的,无法保持单例,我们就说如果需求变了,UseDao中需要UserBean和UserProfile2个对象了,如果你是new对象,那么就要到处修改,如果是Hilt的方式,我们就只需要修改UserDao对象的构造即可


@Singleton
class UserDao @Inject constructor(private val user: UserBean,private val profile:UserProfile) {

fun printUser(): String {
return user.toString()
}

}

以上只是举个简单例子,构建一个对象,还要构建一堆其他的对象,并且其他对象的构建同样复杂,并且必须按顺序构建,而且需要的对象的生命周期都不一样,有些生命周期可能和Activity一样,有些可能是单例,所以在构建的时候还要考虑对象声明周期,考虑对象的来源。


特别是在大型项目中很痛苦,因为项目不是一个人写的,大家协同合作开发,看别人的代码也和看天书一样,并不知道同事的对象是如何创建的,如果一个对象的构建方式发生改变,会影响整个的构建过程以及所关联的代码,牵一发而动全身。


这个时候依赖注入框架就派上用场了,我们只用专注于怎么实现功能,对象的依赖关系和生命周期,都让它来帮我们管理,一个Inject,它会按照依赖关系帮我们注入我们需要的对象,并且它会管理好每个对象的生命周期,在生命周期还没结束的情况下是不会重复new的。


所以Hilt依赖注入非常适合大项目,小项目开发者因为项目复杂度低,没遇到这些问题,所以不会理解为什么要用Hilt依赖注入,发出疑问,为什么要让简单的new对象搞这么复杂。


二、生命周期控制


这里说对象的生命周期,其实就是在一定作用域的生命周期,如果只是说单例有点太浅薄,可以说是是在一定范围内的单例。


我们直接new对象是无法控制生命周期的,除非我们使用全局单例的对象,而通过Hilt依赖注入我们可以很方便的实现对象的生命周期的控制。


比如我们普通对象的快速注入方式,直接注解Singleton就标注的是全局范围单例


@Singleton
class UserServer @Inject constructor(private val userDao: UserDao) {

fun testUser() {
YYLogUtils.w(userDao.printUser())
toast(userDao.printUser())
}

fun getDaoContent():String{
return userDao.printUser()
}

}

另一种用法是我们使用Module的方式定义依赖注入,那么使用SingletonComponent + Singleton 同样是全局范围单例的意思


@Module
@InstallIn(SingletonComponent::class)
class Demo10DIModule {

@Singleton
@Provides
fun provideUser(): UserBean {
return UserBean("newki", 18, 1, listOf("中文", "英文"))
}

}

如果我们想Activity内的单例,我们使用ActivityComponent + ActivityScoped 就是Activity范围的单例。


@Module
@InstallIn(ActivityComponent::class)
class Demo10DIModule {

@ActivityScoped
@Provides
fun provideUser(): UserBean {
return UserBean("newki", 18, 1, listOf("中文", "英文"))
}

}

以上两种都是比较常用的作用域,其他的我们还能保证Fragment内单例,View内部单例等等,用法都是同样的用法。


所以对依赖对象的生命周期控制也是Hilt很方便的一个特点,使用new对象是无法做到这一点的。


三、对比其他依赖注入


目前Android主流的也就是三种依赖注入 Dagger2 Hilt Koin。


之前比较过Koin,只能在Kotlin语言环境中使用。并且性能并不会好过Hilt。错误提示也不友好。


Dagger2不是不能用,17年18年的时候特别火,但是学习成本很高,每次创建UI个依赖注入类还得mackproject,并且错误的提示也不友好,



其实我17年就已经在使用Dagger2了,然后自己做了Demo与框架封装,后来做项目中并没有使用,一个是坑太多,一个是同事不会用,学习成本太高。也就放弃使用Dagger2了。


而Hilt其实就是Daggert2的Android场景化的实现,内部对Dagger2进行了封装,在Android开发中使用Hilt更加的简便,学习成本很低,错误提示友好。并且还对ViewModel都可以注入了哦。所以说它是专为Android开发而生。


关于注入的对象内存占用是否有优化的这一点,其实并没有文章或者官方的文档指出有内存优化这一点,仅我自己的测试来说,整个页面如果有多个注入对象和直接new对象相比,感觉注入的对象占用内存稍微少一点,不知道是不是测试的波动,我不理解,如有懂的大佬还望指点一下。


总结


总结为什么要使用Hilt。



  1. 偷懒;自动管理,多对象的自动注入,万一有修改不需要到尸山中到处趴。

  2. 单例;让对象拥有生命周期,无需我们自己手动单例创建,然后去手动注销。

  3. 解耦;不需要到处引入我一些不需要的对象,特别是组件化的项目,另一个组件只管注入,在我的组件中我只管引用。


我觉得这是我使用Hilt最吸引我的三个点,


所以说目前2022年了,依赖注入我推荐Hilt。关键使用简单,在Android的常用场景下我还做了一些 Demo, 总共就那么多固定的一些用法,之前我写过Demo覆盖Android开发大部分的使用场景, 有需要直接拿走即可,可以查看我之前的文章。


顺便说一句,这是国外程序员的必备面试技能,感觉相比国内的开发者老外的Android开发者特别喜欢使用Dagger2和Hilt,不少老项目都是用Dagger2的。


好了,本期内容如讲的不到位或错漏的地方,希望同学们可以指出交流。


如果感觉本文对你有一点点点的启发,还望你能点赞支持一下,你的支持是我最大的动力。


Ok,这一期就此完结。



作者:newki
链接:https://juejin.cn/post/7129673928460468254
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

理解Kotlin中的reified关键字

标题:理解Kotlin中的reified关键字 摘要:本文介绍了Kotlin中的reified关键字的用途,特点以及如何在实际项目中应用。我们将通过实例详细了解reified的功能以及如何在内联函数中使用它。 正文: 什么是reified关键字? 在Kotli...
继续阅读 »

标题:理解Kotlin中的reified关键字


摘要:本文介绍了Kotlin中的reified关键字的用途,特点以及如何在实际项目中应用。我们将通过实例详细了解reified的功能以及如何在内联函数中使用它。


正文:


什么是reified关键字?


在Kotlin中,reified是一个特殊的关键字,用于修饰内联函数中的类型参数。这使得在函数内部可以访问类型参数的具体类型。通常情况下,由于类型擦除(type erasure),在运行时是无法直接获取泛型类型参数的具体类型的。reified关键字解决了这个问题。


使用reified关键字的条件


要使用reified关键字,需要遵循以下几点:



  1. 函数必须是内联的(使用inline关键字修饰)。

  2. 类型参数前需要加上reified关键字。


示例:reified关键字的用法


下面是一个使用reified关键字的简单示例:


inline fun <reified T> checkType(value: Any) {
if (value is T) {
println("Value is of type T.")
} else {
println("Value is NOT of type T.")
}
}

fun main() {
val stringValue = "Hello, Kotlin!"
val intValue = 42

checkType<String>(stringValue) // 输出 "Value is of type T."
checkType<String>(intValue) // 输出 "Value is NOT of type T."
}

在这个示例中,我们定义了一个内联函数checkType,它接受一个reified类型参数T。然后,我们使用is关键字检查传入的value变量是否为类型T。在main函数中,我们用不同的类型参数调用checkType函数来验证它的功能。


获取类型参数的Java类


当你使用reified关键字修饰一个内联函数的类型参数时,你可以通过T::class.java获取类型参数对应的Java类。这在需要访问泛型类型参数的具体类型时非常有用,比如在反射操作中。


下面是一个简单的例子:


import kotlin.reflect.KClass

inline fun <reified T : Any> getClass(): KClass<T> {
return T::class
}

inline fun <reified T : Any> getJavaClass(): Class<T> {
return T::class.java
}

fun main() {
val stringKClass = getClass<String>()
println("KClass for String: $stringKClass") // 输出 "KClass for String: class kotlin.String"

val stringJavaClass = getJavaClass<String>()
println("Java class for String: $stringJavaClass") // 输出 "Java class for String: class java.lang.String"
}

在这个示例中,我们定义了两个内联函数,getClassgetJavaClass,它们都接受一个reified类型参数TgetClass函数返回类型参数对应的KClass对象,而getJavaClass函数返回类型参数对应的Java类。在main函数中,我们用String类型参数调用这两个函数,并输出结果。


注意事项


需要注意的是,reified关键字不能用于非内联函数,因为它们的类型参数在运行时会被擦除。此外,reified类型参数不能用于普通类和接口,只能用于内联函数。


总结


Kotlin中的reified关键字允许我们在内联函数中访问类型参数的具体类型。它在需要访问泛型类型参数的场景中非常有用,例如在反射操作中。本文通过实例介绍了如何使用reified关键字,并讨论了相关注意事项。希望这些示例能够帮助您更好地理解和应用reified关键字。


作者:就不呵呵呵
链接:https://juejin.cn/post/7225457156816355365
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

关于时间管理的一点建议

在成为 Tech Lead 之后我发现时间变得极度不够用,甚至会成为了我焦虑和殚精竭虑的源泉。因为我无法主动的去做我应该(定方向、做定期回顾)做和想做的事情,而总是被动的被他人牵着鼻子走:无穷无尽的决策请求、寻求帮助、会议邀约。 有两个可以解决这个问题的办法可...
继续阅读 »

在成为 Tech Lead 之后我发现时间变得极度不够用,甚至会成为了我焦虑和殚精竭虑的源泉。因为我无法主动的去做我应该(定方向、做定期回顾)做和想做的事情,而总是被动的被他人牵着鼻子走:无穷无尽的决策请求、寻求帮助、会议邀约。


有两个可以解决这个问题的办法可以简单提一嘴:1)首先你应该尽可能的帮助你的团队成长,让他们尽可能的独当一面,你也就自然不会成为单点依赖;2)根据问题的重要程度和紧急程度划分优先级依然奏效,在精力有限的情况下,有些问题可以暂且搁置不用去解决。


今天我想聊的是第三个办法来源于哈佛商业评论的一篇文章:《Management Time: Who's Got the Monkey》


猴子在谁那呢


问题


文章从一个再正常不过的场景开始说起:经理与下属 A 在走廊上相遇了,下属 A 向经理发起了求助:“早上好啊,顺便说一句我现在遇到了一个问题,情况是这样的……”;经理也很自然的回答道:“很高兴你告诉了我,我现在有点忙,先让我想想再答复你”。


同样的事件在一天之内发生了三次,B 和 C 也同时向经理发起了求助。经理忙的焦头烂额,直至下班前 A、B、C 都没有得到经理的答复。他们在经理门外等待答复的过程中难免开始质疑起经理的能力,因为他现在成为了多数人工作的瓶颈。


第二天刚好是周六,经理为了避免下周继续阻塞其他人的工作决定周末去公司加班,在开车经过公司附近的一片高尔夫球场时,你猜他看到了哪三位熟悉的身影?


“到底谁在为谁工作呢?”经理不由得思考起来。


办法


如果我们把问题比喻成猴子的话,从 A 向经理求助的那一刻起,猴子就从 A 的背上跳到了经理的背上,也就是下属的问题成了经理的问题。经理采取了三个手段来解决这个困境。



  • 摆脱猴子


在新一周开始的第一天,经理将 A、B、C 依次喊入办公室进行一对一沟通。经理把“猴子”摆在他们的中间,商讨下一步下属能针对问题能够采取些哪些独立行动。在达成一致的同时约定好下次沟通进展的时间。这样下属便又可以继续工作在问题上,猴子得到归还。



  • 明确主动性


我们必须要回答的另一个问题是,下属究竟是真的遇到了困难,还是他根本就是想甩锅而已。主动性从低到高可以分为5类:



  1. 等着被告诉要做什么(主动性最低)

  2. 主动询问我要做什么

  3. 建议应该做些什么,并且采取相应行动

  4. 直接行动起来,并且给出自己的建议

  5. 独自行动起来,定期进行汇报(主动性最高)


前两类主动性不应该被鼓励,或者直接点说是不被允许的。时间管理的关键在于掌控自己的工作内容和工作时机。(“等着被告诉要做什么”即无法让自己掌控工作内容也无法控制自己的工作时机)。



  • 对待猴子(问题)的原则



  1. 猴子要么被投喂(持续解决)要么被击毙(立即关闭)。等待它自然死亡的过程等无异于无限投入时间却又看不到任何结果,等同于浪费

  2. 猴子数量应该保持在经理的投喂带宽之下。

  3. 猴子只应该在约定的时间被投喂(追着猴子投喂,或者允许被随时邀请投喂意味着经理被问题牵着鼻子走)

  4. 猴子应该通过面对面的方式进行投喂——通过邮件的方式相当于问题又异步的被甩给了经理

  5. 每只猴子的下一次投喂时间应该被明确下来


作为 Tech Lead 当面对求助时,会惯性的将问题包揽下来。无论这种“我来搞定”的态度无论是出自下意识还是顾虑都不是一个好的实践。不妨把问题当作机会,推他们一把,甚至允许一定范围内的犯错,是让团队成长的一个途径


三类时间


文章把经理时间划分为三类:



  • 老板强加给你的时间(Boss-imposed Time)——你必须完成老板交给你的那些任务,否则会得到迅速且直接的惩罚

  • 系统强加给你的时间(System-imposed Time)——你必须响应同级别同事的工作诉求

  • 自我时间(Self-imposed Time)——做那些你的经理和团队同意你去做的事情。这类时间又可以继续划分为两类

    • 下属时间(Subordinate-imposed Time)——用于支援下属的时间

    • 自由支配时间(Discretionary Time)——真正属于经理自己的时间




很明显,对于前两者你能够拒绝的空间十分有限。适当的降低下属占用你的时间,也许是更切实有效为自己争取一点自由的方法。


作者:李熠
链接:https://juejin.cn/post/7225941608225652773
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

两个故事:送给面试失败的你

故事1:从世界五百强高管手中拿下项目 那年我大二。 在北五环外的宏福校区上满一年课后,我们正式搬回了位于市中心的海淀区本部,终于算是进城了。 进城的第一个好处,就是做项目的机会变多了! 当年为了尽早的实现经济独立,课没怎么好好上,兼职项目和实习倒是干了不少。...
继续阅读 »

故事1:从世界五百强高管手中拿下项目


图片


那年我大二。


在北五环外的宏福校区上满一年课后,我们正式搬回了位于市中心的海淀区本部,终于算是进城了。


进城的第一个好处,就是做项目的机会变多了!


当年为了尽早的实现经济独立,课没怎么好好上,兼职项目和实习倒是干了不少。


北邮有一个著名的BBS,上面啥都有,极其热闹。其中最热门的板块有俩,一个是“缘来如此”,听名字就知道是用来谈情说爱的。另一个则是就业机会交流板块,各种招聘内推资讯满天飞。


我当时天天刷帖子找实习和兼职机会,自然也收到不少面试邀约,而我要聊的这一次,格外的与众不同。


面试约在了晚上8点,北师大东门外的一个安静的咖啡店里,二楼。


我面试从来不迟到,一般都会掐着点到场,可那次我到的时候,面试官已经落座了。是一个四十出头的中年男人,高高瘦瘦,戴银边方框眼镜。桌上摆了一壶明亮的金丝皇菊花茶,两个小巧精致的玻璃茶杯。


我入座后,他客气的给我倒了一杯茶,面试便开始了。说是面试,其实更像是一场闲聊,整个谈话氛围非常轻松自在,咖啡店是文艺范儿的,灯光幽暗,空气里飘荡着舒缓的爵士乐和淡淡的松香,木质的楼板被过往的客人踩出咯咯吱吱的响声。


我们大约是聊了半个多小时的样子,从他的表情可以看得出他挺满意。结束谈话的时候他说,我稳重的样子不太像90后。我羞涩的笑了笑,带着他给我布置的第一个项目走出咖啡店。


没错,这个项目就这么轻而易举的被我拿到手了,也许是出于对我母校的信任,又或许是当晚的聊天氛围实在舒服,总之我获得了他的信任。


可好戏才刚刚开始。


我收到的第一个任务,要求我在一周内根据需求文档写出一份静态网站Demo出来。


这个任务现在看来很easy,但是当时的我,连最基本的网页怎么写都不会,我只用过Dreamweaver拖拖拽拽搞过一个蹩脚且丑陋的页面。而这一次,我面对的是一个商业任务,并且限定了交付日期,一周!这可把我愁坏了。甚至都不是时间紧不紧的问题,是我根本不知道从哪里下手啊。


事情的突破口出现在我大学舍友身上。


这小子是个富二代,家境优渥,从小就接触计算机,自然是见多识广,啥都会一点。我撺掇着让他给我演示“如何使用现成框架搭建网页”,当时用的是Bootstrap 1.0。我俩在通信原理的课堂上,坐在教室的后排,偷偷摸摸的教学着。我目不转睛的盯着他一点点用现成的类名,逐渐拼出了一个漂亮的页面,那种感觉真是兴奋极了!


其实现在回头看,我们当时的编码方法非常拙劣,完全上不了台面的那种,还真是一个敢教,一个敢学哈哈哈。


一节课偷偷摸摸下来,我基本上算是知道了一个静态页面如何从0到1的写出来了,剩下的事情就只是时间问题了。一下课我就飞快地跑回宿舍,埋头学习Bootstrap的API文档,一点点一点点,小心翼翼的拼凑着页面。


一周后,我如期把Demo交给了老板,保住了这次兼职机会。这份工作给我带来了每个月2000块的收入,整整持续了一年(当时我一个月生活费也就不到800)。


我是在后来的一年的交往中才知道,这个老板是某世界五百强的集团高管,空闲时间和朋友一起做了个创业公司,出于竞业关系,不方便公开招募团队,于是私下找学生兼职做点项目。


而我,就成了那个幸运的学生。


故事2:屡败屡战拿下百度Offer


图片


转眼到了大三。


杂七杂八的项目做了不少,钱也倒是有赚一些,但基本上都是小打小闹,尤其是技术层面,苦于一直没有接触过企业级项目,我并不知道一个成熟的商业项目的代码长什么样。


抱着这样一个期望,我开始争取大公司的实习机会。


还是从北邮人论坛,我拿到了一个百度的面试机会,具体哪个部门我已经记不太清了。


面试官安排我在茶水间坐下,丢给我一份试题和一支笔。


那份题目我做得稀烂,面试官看了看卷子,当场跟我说,你可能不太行。不过没等他赶我走,我迅速拿出电脑,打开作品集,指着我画的一些设计图对他说:那么……你们招UI设计师么?这是我的作品。


面试官先是一愣(心想这小子不是码农么,怎么还会设计),然后让我等一下,便拿着我的作品,跑去找他们团队的UI设计师帮忙过目。


是不是觉得我的行为很奇怪?没错,我自己也没想明白其实。当时我还没想好毕业后从事什么工作,由于从小就喜欢画点东西,平时也会看一些用户体验设计相关的书,大学期间在学生社团里做了不少有意思的图,所以我天真的以为自己毕业后也是可以从事UI设计工作的。


面试官很快就回来了,跟我摇摇头,结束了这场面试。


这次经历给我打击是比较大的,我原本自豪的以为我既能写代码,又能做设计,一定是个抢手货,但事实上,我的两种技能在学校里勉强能秀一下,到了职场专业人士眼里,就是些玩具级别的东西,根本不够看的。


回去后我继续寻找实习机会,中间拿到了亚信联创的Offer,在亚联实习了三个月,学了些CSS基础知识。但我一直不甘心,还是一心想去大公司。


不久后,我等来了百度的另一个面试机会。这次是核心部门:网页搜索部,百度的立足之本。


经过亚联的短暂实习,我对自己的前端技能颇有信心,感觉这次应该是稳了。


然而,是我天真了。


网页搜索部的前端是重逻辑的,需要写大量的JS代码。而彼时的我,才刚把CSS入门,JS的部分只会使用jQuery写一些简单的页面交互效果。


面试官跟我反馈说没过的时候,我赶紧叫住他,说,能否指点一下我,如果想要在百度做前端的话,我应该学习些什么知识?


他也愣了一下(心想这小子不按套路出牌啊),然后拿过笔,在我笔试卷子的背面空白处,一边说一边写下一些零零散散的知识点。


拿过这张画得乱七八糟的A4纸,我如获至宝,连声感谢之后便离开了百度。


参考着这份凌乱的前端知识图谱,我窝在宿舍学习了一个月。一个月后,我给这个面试官发了条短信,请求说能不能再给我一次面试机会,我感觉我准备好了。


他同意了。于是我第3次到百度面试。


面试很快就结束了。面试官跟我说,看得出来这一个月你确实学到不少东西,进步很大,但是距离录用标准还是有点距离的,抱歉。


我又又又一次叫住面试官,和上次一样,我又跟他要了一份更加进阶的前端知识图谱。我说我回去再学习下,还会再来的。


他尴尬而不失礼貌的跟我笑了笑,便起身离开了。


这次的白纸更加密密麻麻,而且看得出来知识点比上一次又更加专业和精深了许多,学起来自然也吃力了不少。


两个月后,我再次联系到他,请求再一次面试。


他又同意了。于是我第4次到百度面试。


这次面试更快的结束了,可能我们彼此已经相对比较熟悉了吧,前几次考察过的知识点这次也就直接跳过了。


看得出来他有些犹豫,可能是他已经不太好意思当面拒绝我了,于是让我等等,找来了他的同事,给我加了一次交叉技术面。


这位新面试官说话也很直肠子,聊了二十分钟后,他直接跟我说:“技术的话勉勉强强吧,但是你这小子身上有一股抑制不住的热情和活力,学习能力也不错,感觉可以培养一下试试,我这里就给你过了吧,我再跟同事商量下,你稍等”。


过了几分钟,先前那个被我屡次骚扰的面试官来了,通知我,面试过了!


这可把我高兴坏了,经过半年多,4次5轮面试,我终于凭自己本事(厚脸皮)拿到了大公司的实习机会!(当年的百度在技术领域可是BAT之首)


这份实习工作给我带来了4000块每月的收入,让我实现了彻底的经济独立。不过这都不是最重要的,最最最重要的是,我终于知道大公司的前端开发是什么样的了!


后来我入职百度后,当我面对着屏幕上漂亮的,模块化的面向对象风格的JS代码的时候,我终于知道了业余和专业的差距。


Anyway,幸运再一次光顾了我这个小子。




在我十多年的工作经历中,诸如此类的幸运不胜枚举。旁人看到的,是我的一路顺风顺水,但只有我自己明白,生活没有奇迹,所有的幸运,都是一次次暗中努力换来的福报


作者:沐洒
链接:https://juejin.cn/post/7220997060136140858
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

终于可以彻底告别手写正则表达式了

大家好,我是风筝 这篇文章的目的是让你能得到完美的正则表达式,而且还不用自己拼。 说到正则表达式,一直是令我头疼的问题,这家伙一般时候用不到,等用到的时候发现它的规则是一点儿也记不住,\d表示一个数字,\s表示包括下划线在内的任意单词字符,也就是 [A-Za-...
继续阅读 »

大家好,我是风筝


这篇文章的目的是让你能得到完美的正则表达式,而且还不用自己拼。


说到正则表达式,一直是令我头疼的问题,这家伙一般时候用不到,等用到的时候发现它的规则是一点儿也记不住,\d表示一个数字,\s表示包括下划线在内的任意单词字符,也就是 [A-Za-z0-9_],还有[\s\S]*可以匹配包括换行在内的任意字符串。



这你都能记住吗,如果能的话,那真的佩服,反正我是记不住,之前每次手写的时候都得跟查字典似的一个个的查,简单的还好,复杂的就很痛苦了。



过程往往是这个样子的:


1、 先打开 Google,搜索一篇正则表达式,找到一份像上图那样的字典教程,先看个几分钟,回忆回忆,还有可能回忆不起来。


2、然后就开始根据需求写一个正则表达式。


3、放到程序中执行一下。


4、诶,怎么不好用,匹配不上啊,接着修改正则。


5、继续从 3 - 4 的循环,直到运气来了,正常出结果了。


这是最早的时候,真的是全靠那点仅有的实力和运气了。


记得刚毕业不久的时候,有一次领导给安排一个任务,要在一堆 PDF 文件里把我们需要的数据摘出来。PDF 这玩意儿吧,你把它的内容读出来,它就是一大段文本,要在这一堆内容不一致的文件中准确的拿到数据,第一反应就是用正则。


当时的做法就是上面的 1-5这几步来的,加上当时候刚毕业比较菜,跌跌撞撞才把程序写好,中间有几次调试的时候,程序一跑起来,VS(Visual Studio)就特别卡。对的,就是宇宙第一强大的 IDE ,当时我还在写 C#,纵然是宇宙第一强大,也被我弄的特别卡。


当时只道是正则写的有问题,然后就一直改。


后来才知道,那是因为正则写的不合理,发生了回溯现象,越不合理,回溯越严重,加上当时的 PDF 内容很多,所以导致开发工具都卡了,这要是整到线上,那怕是混不下去了。


关于回溯的问题,可以参考下面这篇文章《失控的正则表达式:灾难性的回溯》


http://www.regular-expressions.info/catastrophi…



后来就不至于那么菜了,知道了一些关于正则表达式的在线网站,上面有一些常用的正则表达式,不用自己捣鼓了,能偷懒当然要偷懒了。可以在 Goolge 上搜索关键词「正则表达式 在线」,然后就会出来一大堆,直接在上面用那些常用的正则,例如手机号、邮箱、网址啊,基本上能解决90%的需求场景。


另外的10%呢,以前可能只能自己琢磨了,现在都2023年了,基本上99%的概率都不用亲自动手了,当然了,如果是大佬呢,就想自己写,那完全没问题。


ChatGPT 完美解决


ChatGPT 是LLM(大语言模型)的产品,最最擅长的事情就是分析语言,而正则表达式的应用场景是什么呢,其实就是在一大堆文本语言中按照我们的规则,找到我们需要的内容,总的来说,也是对于文本语言的处理,所以用 ChatGPT 解决正则表达式的问题简直太合适不过了。


比如最简单的,匹配中国的手机号,直接让 ChatGPT 把正则写出来,而且连代码都给你写好了。



至于网址、邮箱等等也不在话下了。


不仅ChatGPT 可以,连百度文心一言也可以。百度文心一言虽然这样可以,但是如果你反过来问它,它就蒙圈了。


比如我问 aaa@126.com 是不是一个合法的邮箱,ChatGPT 会告诉你这个邮箱是合法的,但是百度文心一言就不行了。


下面这个是 ChatGPT 的回答:


ChatGPT 的回答


下面这个是百度文心一言的回答:


文心一言的回答


不仅邮箱不行,你问它一个手机号是否合法,百度文心一言也不行,还会告诉你这个号码的归属地,但是这个归属地也是错误的。


这样就看出来什么是智能,什么是大数据了,明显 ChatGPT 更智能一点,希望国产的大模型能在这两年追上吧。


再举一个例子


匹配一段 HTML 中的某个部分也是正则的常用场景,做过爬虫的或多或少都用过正则吧。


比如我在一大段 HTML 中有这么一部分


<div class="time">这是一个,this is some</div>

现在要拿到这个 div 中的内容部分,当然有很多其他的方式了,比如 Java 版的 jsoup,使用 xpath、css selector 等都可以,但是如果就要用正则呢,是不是自己写的话,一般菜鸟就感觉很麻烦了。


这时候我们问问 ChatGTP ,看看它怎么搞的。


直接就这么问了:



<div> <div> <div>这是一个,this is some</div> <div>button</div> </div> </div>, 用 Java 正则表达式匹配这段 HTML 中 的这个标签的 Text 部分



image-20230418224312067


直接拿过代码跑一下,没有任何问题。


有同学说了,这么明显的标签,还用的着 ChatGPT ,直接拿过来就写了。


这里只是举个例子,如果哪位有比较复杂的匹配逻辑,也可以用ChatGPT 来试试,基本上99%都能直接解决。


还有一个网站很厉害


如果你没有办法或者不想用 ChatGPT ,也不想用百度文心一言这些,我还发现一个网站,这个网站我严重怀疑它已经接入了 ChatGPT ,它也支持通过自然语言描述,就能给出相应的正则表达式。


网站地址:wangwl.net/static/proj…


比如我跟他说:提取一段字符串中的中国手机号码部分,而且还有正则可视化。



上面的那个匹配 HTML 的例子,我也在这个网站上试过,结果也是可以的。


纯粹的好东西分享,我跟这个网站没有任何关系。


一个帮你分析正则的网站


接下来这个网站呢,如果你想对正则有比较深入的理解,或者想看看自己写好的正则或ChatGPT 帮你生成的正则表达式效果怎么样,性能好不好,都可以在这个网站进行。


网站地址:regex101.com/



网站左侧可以选择你的目标语言,也就是你的代码实现是哪种语言 Java 还是 JavaScript 等。


中间上方是正则表达式,中间下方是待匹配的内容。


右侧上方是你写的正则对待匹配内容完整的匹配分析过程,非常详细,可以通过这里清楚的看出这个正则匹配的时候经过了哪些路径。


右侧下方是最终的匹配结果。


如果你写的正则在工作的时候发生了明显的回溯,这里也会给出提示,告诉你问题,让你去优化。


总结


君子善假于物也,虽然我很菜,但是工具好用啊,我+好用的工具,等于我也很厉害了。


作者:古时的风筝
链接:https://juejin.cn/post/7226013021842948156
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

超有用的Android开发技巧:拦截界面View创建

本篇文章主要是分析如何拦截Activity中View的创建流程,实现无感知的使用自定义View替换指定的系统View,这对于换肤、埋点设计等等将是非常有帮助的一种方式。 LayoutInflater.Factory2是个啥? Activity内界面的创建是由...
继续阅读 »

本篇文章主要是分析如何拦截ActivityView的创建流程,实现无感知的使用自定义View替换指定的系统View,这对于换肤、埋点设计等等将是非常有帮助的一种方式。



LayoutInflater.Factory2是个啥?


Activity内界面的创建是由LayoutInflater负责,LayoutInflater最终会交给内部的一个类型为LayoutInflater.Factory2factory2成员变量进行创建。


这个属性值可以外部自定义传入,默认的实现类为AppCompatDelegateImpl


image.png


然后在AppCompatActivity的初始化构造方法中向LayoutInflater注入AppCompatDelegateImpl:


image.png


image.png


image.png


常见的ImageViewTextView被替换成AppcompatImageViewAppCompatTextView等就是借助AppCompatDelegateImpl进行实现的。


这里有个实现的小细节,在initDelegate()方法中,调用了addOnContextAvailableListener()方法传入一个监听事件实现的factory2注入,这个addOnContextAvailableListener()方法有什么魅力呢?


addOnContextAvailableListener()是干啥用的?


咱们先看下这个方法是干啥用的:


image.png


image.png


最终是将这个监听对象加入到了ContextAwareHelper类的内部mListeners集合中,咱们接下里看下这个监听对象集合最终是在哪里被调用的。


image.png


image.png


可以看到,这个集合最终在ComponetActivityonCreate()方法中调用,请注意,这个调用时机还是在父类的super.onCreate()方法前进行调用的。


所以我们可以得出结论,addOnContextAvailableListener()添加的监听器将在父类onCreate()方法前进行调用。


这个用处的场景还是比较多的,比如我们设置Activity的主题就必须在父类的onCreate()方法前调用,借助这个监听,可以轻松实现。


代码实战



请注意,这个factory2的设置必须在ActivityonCreate()方法前调用,所以我们可以直接借助addOnContextAvailableListener()进行实现,也可以重写onCreate()方法在指定位置实现。当然了,前者更加的灵活,这里我们还是以后者进行举例。



override fun onCreate(savedInstanceState: Bundle?) {
LayoutInflaterCompat.setFactory2(layoutInflater, object : LayoutInflater.Factory2 {
override fun onCreateView(
parent: View?,
name: String,
context: Context,
attrs: AttributeSet
): View? {

return if (name == "要替换的系统View名称") {
CustumeView()
} else delegate.createView(parent, name, context, attrs)
}
})
}

请注意,这里也有一个实现的小细节,如果当某个系统View不属于我们要替换的View,请继续委托给AppCompatDelegateImpl进行处理,这样就保证了实现系统组件特有功能的前提下,又能完成我们的View替换工作。


统一所有界面View的替换工作


如果要替换View的界面非常多,一个Activity一个Activity替换过去太麻烦 ,这个时候就可以使用我们经常使用到的ApplicationregisterActivityLifecycleCallbacks()监听所有Activity的创建流程,其中我们用到的方法就是onActivityPreCreated():


registerActivityLifecycleCallbacks(object : Application.ActivityLifecycleCallbacks {
override fun onActivityPreCreated(activity: Activity, savedInstanceState: Bundle?) {
LayoutInflaterCompat.setFactory2(activity.layoutInflater, object : LayoutInflater.Factory2 {
override fun onCreateView(
parent: View?,
name: String,
context: Context,
attrs: AttributeSet
): View? {

return if (name == "要替换的系统View名称") {
CustumeView()
} else (activity as? AppCompatActivity)?.delegate?.createView(parent, name, context, attrs) ?: null
}

override fun onCreateView(name: String, context: Context, attrs: AttributeSet): View? {
TODO("Not yet implemented")
}
})

}
}

不过这个Application.ActivityLifecycleCallbacks接口要重写好多无用的方法,太麻烦了,之前写过一篇关于接口优化相关的文章吗,详情可以参考:接口使用额外重写的无关方法太多?优化它


总结


之前看过很多换肤、埋点统计上报等相关文章,多多少少都介绍了向AppCompatActivity中注入factory2拦截系统View创建的思想,我们设置还可以借助此实现界面黑白化的效果,非常的好用,每个开发者都应该去了解掌握的知识点。


作者:长安皈故里
链接:https://juejin.cn/post/7137305357415612452
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

Transform API 废弃了,路由插件怎么办?

前言 在 AGP 7.2 中,谷歌废弃了Android开发过程非常常用的Transform API,具体信息可以查看Android Gradle 插件 API 更新。 可以看到Transform API在 AGP 7.2 标记了废弃,且在 AGP 8.0 将...
继续阅读 »

前言


在 AGP 7.2 中,谷歌废弃了Android开发过程非常常用的Transform API,具体信息可以查看Android Gradle 插件 API 更新


image.png


可以看到Transform API在 AGP 7.2 标记了废弃,且在 AGP 8.0 将面临移除的命运。如果你将Android工程的AGP升级到7.2.+,尝试运行使用了Transform API的插件的项目时,将得到以下警告。


API 'android.registerTransform' is obsolete.
It will be removed in version 8.0 of the Android Gradle plugin.
The Transform API is removed to improve build performance. Projects that use the
Transform API force the Android Gradle plugin to use a less optimized flow for the
build that can result in large regressions in build times. It’s also difficult to
use the Transform API and combine it with other Gradle features; the replacement
APIs aim to make it easier to extend the build without introducing performance or
correctness issues.

There is no single replacement for the Transform API—there are new, targeted
APIs for each use case. All the replacement APIs are in the
`androidComponents {}` block.
For more information, see https://developer.android.com/studio/releases/gradle-plugin-api-updates#transform-api.
REASON: Called from: /Users/l3gacy/AndroidStudioProjects/Router/app/build.gradle:15
WARNING: Debugging obsolete API calls can take time during configuration. It's recommended to not keep it on at all times.

看到这种情况,相信很多人第一反应都是how old are you?。Gradle API的频繁变动相信写过插件的人都深受其害,又不是一天两天了。业界一些解决方案大都采用封装隔离来最小化Gradle API的变动。常见的如



此次 Transform API 将在 AGP 8.0 移除,这一改动对于目前一些常用的类库、插件都将面临一个适配的问题,常见的如路由、服务注册、字符串加密等插件都广泛使用了Transform API。那么究竟该怎么解决此类适配问题找到平替方案呢?本篇将探讨目前主流的一些观点是否能够满足需求以及如何真正的做到适配。


主流观点



当你尝试解决此问题时,一通检索基本会得到两种不同的见解,目前也有一些同学针对这两个API进行了探索。




那么上述提到的两种API是否真的就能解决我们的问题呢?其实行也不行!


AsmClassVisitorFactory



首先来看看AsmClassVisitorFactory



AsmClassVisitorFactory是没有办法做到像Transform一样,先扫描所有class收集结果,再执行ASM修改字节码。原因是AsmClassVisitorFactoryisInstrumentable方法中确定需要对哪些class进行ASM操作,当返回true之后,就执行了createClassVisitor方法进行字节码操作去了,这就导致可能你路由表都还没收集完成就去修改了目标class


机灵的小伙伴可能会想,那我再注册一个收集路由表的AsmClassVisitorFactory,然后在注册一个真正执行ASM操作的AsmClassVisitorFactory不就好了,那么这种做法可以吗,其实在你的插件想适配Transform Action? 可能还早了点 - 掘金这边文章里已经给出了答案。


TransformAction



既然 AsmClassVisitorFactory 不能打,那 TransformAction 能打不,我们来看下AGP中的实现。




可以看到是有相关ASM实现的。TransformAction 的应用目前较少,主要常见的有 JetifyTransformAarTransform等,主要做产物转换。但 TransformAction 操作起来比较麻烦,详细可以看Transforming dependency artifacts on resolution


平替方案



既然两种观点,一个不能打,一个嫌麻烦,那有没有简单既易用,又可少量修改即可完成适配的方案呢,答案当然是有了。不然水本篇就没有意义了。那么本篇就带大家来简单探索下 Transform API的废弃,针对路由类库的插件适配的一种平替方案。



首先我们要知道Transform在Gradle中其实也对应一个Task,只是有点特殊。我们来看下定义:


public abstract class Transform {

··· omit code ···

public void transform(
@NonNull Context context,
@NonNull Collection<TransformInput> inputs,
@NonNull Collection<TransformInput> referencedInputs,
@Nullable TransformOutputProvider outputProvider,
boolean isIncremental) throws IOException, TransformException, InterruptedException {
}

public void transform(@NonNull TransformInvocation transformInvocation)
throws TransformException, InterruptedException, IOException {
// Just delegate to old method, for code that uses the old API.
//noinspection deprecation
transform(transformInvocation.getContext(), transformInvocation.getInputs(),
transformInvocation.getReferencedInputs(),
transformInvocation.getOutputProvider(),
transformInvocation.isIncremental());
}

··· omit code ···
}

看到这里,有些同学就要疑问了。你这不扯淡吗,Transform根本没有继承 DefaultTaskAbstractTask或者实现 Task 接口。你怎么断定Transform本质上也是一个GradleTask呢?这部分完全可以由Gradle的源码里找到答案,这里不赘述了。


Plugin



回到正题。究竟该怎么去使用Task去适配呢?我们先用伪代码来简要说明下。



class RouterPlugin : Plugin<Project> {

override fun apply(project: Project) {

··· omit code ···

with(project) {

··· omit code ···

plugins.withType(AppPlugin::class.java) {
val androidComponents =
extensions.findByType(AndroidComponentsExtension::class.java)
androidComponents?.onVariants { variant ->
val name = "gather${variant.name.capitalize(Locale.ROOT)}RouteTables"
val taskProvider = tasks.register<RouterClassesTask>(name) {
group = "route"
description = "Generate route tables for ${variant.name}"
bootClasspath.set(androidComponents.sdkComponents.bootClasspath)
classpath = variant.compileClasspath
}
variant.artifacts.forScope(ScopedArtifacts.Scope.ALL)
.use(taskProvider)
.toTransform(
ScopedArtifact.CLASSES,
RouterClassesTask::jars,
RouterClassesTask::dirs,
RouterClassesTask::output,
)
}
}
}

··· omit code ···
}
}

我们使用了onVariants API 注册了一个名为gather[Debug|Release]RouteTablesTask,返回一个TaskProvider对象,然后使用variant.artifacts.forScope(ScopedArtifacts.Scope.ALL)来使用这个Task进行toTransform操作,可以发现我们无需手动执行该Task。来看下这个toTransform的定义。


注意ScopedArtifacts需要AGP 7.4.+以上才支持


/**
* Defines all possible operations on a [ScopedArtifact] artifact type.
*
* Depending on the scope, inputs may contain a mix of [org.gradle.api.file.FileCollection],
* [RegularFile] or [Directory] so all [Task] consuming the current value of the artifact must
* provide two input fields that will contain the list of [RegularFile] and [Directory].
*
*/
interface ScopedArtifactsOperation<T: Task> {

/**
* Append a new [FileSystemLocation] (basically, either a [Directory] or a [RegularFile]) to
* the artifact type referenced by [to]
*
* @param to the [ScopedArtifact] to add the [with] to.
* @param with lambda that returns the [Property] used by the [Task] to save the appended
* element. The [Property] value will be automatically set by the Android Gradle Plugin and its
* location should not be considered part of the API and can change in the future.
*/
fun toAppend(
to: ScopedArtifact,
with: (T) -> Property<out FileSystemLocation>,
)

/**
* Set the final version of the [type] artifact to the input fields of the [Task] [T].
* Those input fields should be annotated with [org.gradle.api.tasks.InputFiles] for Gradle to
* property set the task dependency.
*
* @param type the [ScopedArtifact] to obtain the final value of.
* @param inputJars lambda that returns a [ListProperty] or [RegularFile] that will be used to
* set all incoming files for this artifact type.
* @param inputDirectories lambda that returns a [ListProperty] or [Directory] that will be used
* to set all incoming directories for this artifact type.
*/
fun toGet(
type: ScopedArtifact,
inputJars: (T) -> ListProperty<RegularFile>,
inputDirectories: (T) -> ListProperty<Directory>)

/**
* Transform the current version of the [type] artifact into a new version. The order in which
* the transforms are applied is directly set by the order of this method call. First come,
* first served, last one provides the final version of the artifacts.
*
* @param type the [ScopedArtifact] to transform.
* @param inputJars lambda that returns a [ListProperty] or [RegularFile] that will be used to
* set all incoming files for this artifact type.
* @param inputDirectories lambda that returns a [ListProperty] or [Directory] that will be used
* to set all incoming directories for this artifact type.
* @param into lambda that returns the [Property] used by the [Task] to save the transformed
* element. The [Property] value will be automatically set by the Android Gradle Plugin and its
* location should not be considered part of the API and can change in the future.
*/
fun toTransform(
type: ScopedArtifact,
inputJars: (T) -> ListProperty<RegularFile>,
inputDirectories: (T) -> ListProperty<Directory>,
into: (T) -> RegularFileProperty)

/**
* Transform the current version of the [type] artifact into a new version. The order in which
* the replace [Task]s are applied is directly set by the order of this method call. Last one
* wins and none of the previously set append/transform/replace registered [Task]s will be
* invoked since this [Task] [T] replace the final version.
*
* @param type the [ScopedArtifact] to replace.
* @param into lambda that returns the [Property] used by the [Task] to save the replaced
* element. The [Property] value will be automatically set by the Android Gradle Plugin and its
* location should not be considered part of the API and can change in the future.
*/
fun toReplace(
type: ScopedArtifact,
into: (T) -> RegularFileProperty
)
}

可以看到不光有toTransform,还有toAppendtoGettoReplace等操作,这部分具体用法和案例感兴趣的同学可以自行尝试。接下来来看看Task中的简要代码


Task


abstract class RouterClassesTask : DefaultTask() {

@get:InputFiles
@get:PathSensitive(PathSensitivity.RELATIVE)
abstract val jars: ListProperty<RegularFile>

@get:InputFiles
@get:PathSensitive(PathSensitivity.RELATIVE)
abstract val dirs: ListProperty<Directory>

@get:OutputFile
abstract val output: RegularFileProperty

@get:Classpath
abstract val bootClasspath: ListProperty<RegularFile>

@get:CompileClasspath
abstract var classpath: FileCollection

@TaskAction
fun taskAction() {
// 输入的 jar、aar、源码
val inputs = (jars.get() + dirs.get()).map { it.asFile.toPath() }
// 系统依赖
val classpaths = bootClasspath.get().map { it.asFile.toPath() }
.toSet() + classpath.files.map { it.toPath() }

··· omit code ···

JarOutputStream(BufferedOutputStream(FileOutputStream(output.get().asFile))).use { jarOutput ->

jars.get().forEach { file ->
Log.d("handling jars:" + file.asFile.absolutePath)
val jarFile = JarFile(file.asFile)
jarFile.entries().iterator().forEach { jarEntry ->
if (jarEntry.isDirectory.not() &&
// 针对需要字节码修改的class进行匹配
jarEntry.name.contains("com/xxx/xxx/xxx", true)
) {
// ASM 自己的操作
} else {
// 不处理,直接拷贝自身到输出
}
jarOutput.closeEntry()
}
jarFile.close()
}

··· omit code ···
}
}

··· omit code ···

}

看完了伪代码,相信很多同学已经知道该怎么做了。那么我们再来个简单🌰来看下我们如何适配现有的路由插件。


在开始之前,我们要知道主流的路由插件使用Transform主要是干了啥,简单概括下其实就是两大步骤:



  • 扫描依赖,收集路由表使用容器存储结果

  • 根据收集到的路由表修改字节码进行路由注册


前面的伪代码其实也是按照这两大步来做的。


示例


chenenyu/Router 为例我们来具体实现以下,至于其他类似库如:alibaba/ARouter 操作方法也类似,这部分工作就留给其他说话又好听的同学去做了。


期望结果


chenenyu/Router需要进行ASM字节码操作的类是com.chenenyu.router.AptHub,这里仅以chenenyu/RouterSample进行演示。我们先看一下使用Transform进行字节码修改后的代码是什么,可以看到通过Gradle动态的新增了一个静态代码块,里面注册了各个module的路由表、拦截器表、路由拦截器映射表等。


static {
HashMap hashMap = new HashMap();
routeTable = hashMap;
HashMap hashMap2 = new HashMap();
interceptorTable = hashMap2;
LinkedHashMap linkedHashMap = new LinkedHashMap();
targetInterceptorsTable = linkedHashMap;
new Module1RouteTable().handle(hashMap);
new Module2RouteTable().handle(hashMap);
new AppRouteTable().handle(hashMap);
new AppInterceptorTable().handle(hashMap2);
new AppTargetInterceptorsTable().handle(linkedHashMap);
}

Plugin



  1. RouterPlugin代码与伪代码基本一致


Task


RouterClassesTask大部分实现与伪代码也相同。这里我们主要以说明用法为主,相应的接口设计以及优化不做处理。通俗点说,就是代码将就看~


abstract class RouterClassesTask : DefaultTask() {

@get:InputFiles
@get:PathSensitive(PathSensitivity.RELATIVE)
abstract val jars: ListProperty<RegularFile>

@get:InputFiles
@get:PathSensitive(PathSensitivity.RELATIVE)
abstract val dirs: ListProperty<Directory>

@get:OutputFile
abstract val output: RegularFileProperty

@get:Classpath
abstract val bootClasspath: ListProperty<RegularFile>

@get:CompileClasspath
abstract var classpath: FileCollection

@TaskAction
fun taskAction() {
val inputs = (jars.get() + dirs.get()).map { it.asFile.toPath() }
val classpaths = bootClasspath.get().map { it.asFile.toPath() }
.toSet() + classpath.files.map { it.toPath() }
val grip: Grip = GripFactory.newInstance(Opcodes.ASM9).create(classpaths + inputs)
val query = grip select classes from inputs where interfaces { _, interfaces ->
descriptors.map(::getType).any(interfaces::contains)
}
val classes = query.execute().classes

val map = classes.groupBy({ it.interfaces.first().className.separator() },
{ it.name.separator() })

Log.v(map)

JarOutputStream(BufferedOutputStream(FileOutputStream(output.get().asFile))).use { jarOutput ->

jars.get().forEach { file ->
println("handling jars:" + file.asFile.absolutePath)
val jarFile = JarFile(file.asFile)
jarFile.entries().iterator().forEach { jarEntry ->
if (jarEntry.isDirectory.not() &&
jarEntry.name.contains("com/chenenyu/router/AptHub", true)
) {
println("Adding from jar ${jarEntry.name}")
jarOutput.putNextEntry(JarEntry(jarEntry.name))
jarFile.getInputStream(jarEntry).use {
val reader = ClassReader(it)
val writer = ClassWriter(reader, 0)
val visitor =
RouterClassVisitor(writer, map.mapValues { v -> v.value.toSet() })
reader.accept(visitor, 0)
jarOutput.write(writer.toByteArray())
}
} else {
kotlin.runCatching {
jarOutput.putNextEntry(JarEntry(jarEntry.name))
jarFile.getInputStream(jarEntry).use {
it.copyTo(jarOutput)
}
}
}
jarOutput.closeEntry()
}
jarFile.close()
}

dirs.get().forEach { directory ->
println("handling " + directory.asFile.absolutePath)
directory.asFile.walk().forEach { file ->
if (file.isFile) {
val relativePath = directory.asFile.toURI().relativize(file.toURI()).path
println("Adding from directory ${relativePath.replace(File.separatorChar, '/')}")
jarOutput.putNextEntry(JarEntry(relativePath.replace(File.separatorChar, '/')))
file.inputStream().use { inputStream ->
inputStream.copyTo(jarOutput)
}
jarOutput.closeEntry()
}
}
}
}
}

companion object {
@Suppress("SpellCheckingInspection")
val descriptors = listOf(
"Lcom/chenenyu/router/template/RouteTable;",
"Lcom/chenenyu/router/template/InterceptorTable;",
"Lcom/chenenyu/router/template/TargetInterceptorsTable;"
)
}

}

需要额外说明一下的是,一般我们进行路由表收集的工作都是扫描所有classesjarsaars,找到匹配条件的class即可,这里我们引入了一个com.joom.grip:grip:0.9.1依赖,能够像写SQL语句一样帮助我们快速查询字节码。感兴趣的可以详细了解下grip的用法。



  1. 这里我们把所有依赖产物作为Input输入,然后创建grip对象。


val inputs = (jars.get() + dirs.get()).map { it.asFile.toPath() }
val classpaths = bootClasspath.get().map { it.asFile.toPath() }
.toSet() + classpath.files.map { it.toPath() }

val grip: Grip = GripFactory.newInstance(Opcodes.ASM9).create(classpaths + inputs)


  1. 查询所有满足特定描述符的类。


val query = grip select classes from inputs where interfaces { _, interfaces ->
descriptors.map(::getType).any(interfaces::contains)
}
val classes = query.execute().classes


  1. 对查询的结果集进行分类,组装成ASM需要处理的数据源。标注的separator扩展函数是由于字节码描述符中使用/,在ASM操作中需要处理为.


val map = classes.groupBy({ it.interfaces.first().className.separator() }, { it.name.separator() })

通过打印日志,可以看到路由表已经收集完成。




  1. 至此几行简单的代码即实现了字节码的收集工作,然后把上面的map集合直接交给ASM去处理。ASM的操作可以沿用之前的ClassVisitorMethodVisitor,甚至代码都无需改动。至于ASM的操作代码该如何编写,这个不在本篇的讨论范围。由于我们需要修改字节码的类肯定位于某个jar中,所以我们直接针对输入的jars进行编译,然后根据特定条件过滤出目标字节码进行操作。


JarOutputStream(BufferedOutputStream(FileOutputStream(output.get().asFile))).use { jarOutput ->

jars.get().forEach { file ->
val jarFile = JarFile(file.asFile)
jarFile.entries().iterator().forEach { jarEntry ->
if (jarEntry.isDirectory.not() &&
jarEntry.name.contains("com/chenenyu/router/AptHub", true)
) {
println("Adding from jar ${jarEntry.name}")
jarOutput.putNextEntry(JarEntry(jarEntry.name))
jarFile.getInputStream(jarEntry).use {
val reader = ClassReader(it)
val writer = ClassWriter(reader, 0)
val visitor =
RouterClassVisitor(writer, map.mapValues { v -> v.value.toSet() })
reader.accept(visitor, 0)
jarOutput.write(writer.toByteArray())
}
} else {
kotlin.runCatching {
jarOutput.putNextEntry(JarEntry(jarEntry.name))
jarFile.getInputStream(jarEntry).use {
it.copyTo(jarOutput)
}
}
}
jarOutput.closeEntry()
}
jarFile.close()
}

dirs.get().forEach { directory ->
println("handling " + directory.asFile.absolutePath)
directory.asFile.walk().forEach { file ->
if (file.isFile) {
val relativePath = directory.asFile.toURI().relativize(file.toURI()).path
println("Adding from directory ${relativePath.replace(File.separatorChar, '/')}")
jarOutput.putNextEntry(JarEntry(relativePath.replace(File.separatorChar, '/')))
file.inputStream().use { inputStream ->
inputStream.copyTo(jarOutput)
}
jarOutput.closeEntry()
}
}
}
}

所有需要修改的代码已经写完了,是不是很简单。最后我们来验证下是否正常。执行编译后发现字节码修改成功,且与Transform执行结果一致。至此,基本完成了功能适配工作。



总结



  • 本篇通过一些伪代码对适配 AGP 7.4.+ 的 Transform API 进行了简单说明,并通过一个示例进行了实践。

  • 实践证明,对于 Transform API 的废弃,此方案简单可用,但此方案存在一定限制,需AGP 7.4.+。

  • 相比较于TransformAction,迁移成本小且支持增量编译、缓存


示例代码已上传至Router,有需要的请查看v1.7.6分支代码。主要代码在RouterPluginRouterClassesTask


作者:5upport
链接:https://juejin.cn/post/7222091234100330554
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

中小型项目统一处理请求重复提交

请求重复提交的危害 数据重复:例如用户重复提交表单,造成数据重复。 资源浪费:多次重复请求提交将会浪费服务器的处理资源。但这个相比数据重复的危害性较小。 不一致性:假设我们触发请求增加用户的积分500,如果多次触发这个请求,积分是累加的。这个危害性比重复的数...
继续阅读 »

请求重复提交的危害



  • 数据重复:例如用户重复提交表单,造成数据重复。

  • 资源浪费:多次重复请求提交将会浪费服务器的处理资源。但这个相比数据重复的危害性较小。

  • 不一致性:假设我们触发请求增加用户的积分500,如果多次触发这个请求,积分是累加的。这个危害性比重复的数据更大。

  • 安全性:例如我们在登录页面触发手机验证码的发送请求。频繁触发这个请求将会耗费我们的验证码成本。


防请求重复提交的方案


前端



  • 在用户第一次点击按钮后,即禁用提交按钮。

  • 限制用户提交请求间隔,在一定的时间间隔内只允许用户发起某个请求一次。

  • 在表单提交前,检查前一次请求是否提交成功,已成功的话则提示用户无需再重复提交。


后端



  • 严谨的做法

    • Token机制,在每一个请求中都添加一个Token。Token由服务端生成并发放给前端。服务端接收到请求时,根据Token进行校验。看这个Token是否已被使用。(一般基于缓存)

    • 唯一标志,比如在创建订单的时候,即生成一个唯一的订单号,并将其作为订单的唯一标识。在后续的请求中携带该订单号。当收到订单创建请求时,检查订单号是否已经存在。(一般基于数据库)



  • 非严谨的做法

    • 后端拦截请求,检查请求的用户和参数是否和上次请求相同,相同的话即为重复请求。




这种防请求重复提交的实现有基于Filter的实现,也有基于HandlerInterceptor的实现。最后考量下笔者认为利用RequestBodyAdviceAdapter类来实现代码实现更加简洁,配置更加简单。


在此笔者提供一个注解+RequestBodyAdviceAdapter配合使用的防重复提交的实现。
但是这个方案有个小弊端。仅生效于有RequestBody注解的参数,因为使用RequestBodyAdvice来实现。但是大部分我们需要做请求防重复提交的接口一般都是POST请求,且有requestBody。


完整实现在开源项目中:github.com/valarchie/A…


实现


声明注解


/**
* 自定义注解防止表单重复提交
* 仅生效于有RequestBody注解的参数 因为使用RequestBodyAdvice来实现
* @author valarchie
*/
@Inherited
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Resubmit {

/**
* 间隔时间(s),小于此时间视为重复提交
*/
int interval() default 5;

}

继承RequestBodyAdviceAdapter实现ResubmitInterceptor


大致的实现是。



  • 覆写了supports方法,指明我们仅处理拥有Resubmit注解的方法。

  • 生成每一个请求的签名作为Key。key的生成由generateResubmitRedisKey方法实现。格式如下:resubmit:{}:{}:{}。比如用户是userA。我们请求的类是UserService。方法名是addUser。则这个key为resubmit:userA:UserService:addUser

  • 将Key和请求的参数作为值存到redis当中去

  • 每一次请求过来时,我们检查缓存中这个请求的签名对应的参数是否相同,相同的话即为重复请求。


/**
* 重复提交拦截器 如果涉及前后端加解密的话 也可以通过继承RequestBodyAdvice来实现
*
* @author valarchie
*/
@ControllerAdvice(basePackages = "com.agileboot")
@Slf4j
@RequiredArgsConstructor
public class ResubmitInterceptor extends RequestBodyAdviceAdapter {

public static final String NO_LOGIN = "Anonymous";
public static final String RESUBMIT_REDIS_KEY = "resubmit:{}:{}:{}";

@NonNull
private RedisUtil redisUtil;

@Override
public boolean supports(MethodParameter methodParameter, Type targetType,
Class<? extends HttpMessageConverter<?>> converterType) {
return methodParameter.hasMethodAnnotation(Resubmit.class);
}

/**
* @param body 仅获取有RequestBody注解的参数
*/
@NotNull
@Override
public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType,
Class<? extends HttpMessageConverter<?>> converterType) {
// 仅获取有RequestBody注解的参数
String currentRequest = JSONUtil.toJsonStr(body);

Resubmit resubmitAnno = parameter.getMethodAnnotation(Resubmit.class);
if (resubmitAnno != null) {
String redisKey = generateResubmitRedisKey(parameter.getMethod());

log.info("请求重复提交拦截,当前key:{}, 当前参数:{}", redisKey, currentRequest);

String preRequest = redisUtil.getCacheObject(redisKey);
if (preRequest != null) {
boolean isSameRequest = Objects.equals(currentRequest, preRequest);

if (isSameRequest) {
throw new ApiException(ErrorCode.Client.COMMON_REQUEST_RESUBMIT);
}
}
redisUtil.setCacheObject(redisKey, currentRequest, resubmitAnno.interval(), TimeUnit.SECONDS);
}

return body;
}

public String generateResubmitRedisKey(Method method) {
String username;

try {
LoginUser loginUser = AuthenticationUtils.getLoginUser();
username = loginUser.getUsername();
} catch (Exception e) {
username = NO_LOGIN;
}

return StrUtil.format(RESUBMIT_REDIS_KEY,
method.getDeclaringClass().getName(),
method.getName(),
username);
}
}

使用


通过在Controller上打上Resubmit注解即可,interval即多久的间隔内相同参数视为重复请求。


/**
* 新增通知公告
*/
@Resubmit(interval = 60)
@PostMapping
public ResponseDTO<Void> add(@RequestBody NoticeAddCommand addCommand) {
noticeApplicationService.addNotice(addCommand);
return ResponseDTO.ok();
}

这是笔者关于中小型项目防请求重复提交的实现,如有不足欢迎大家评论指正。


作者:CoderV的进阶笔记
链接:https://juejin.cn/post/7226322524496953399
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

Android 13 平行视界 ActivityEmbedding详解

背景 Android 13推出了一个大屏幕设备显示方案:Activity嵌入(Activity Embedding)。该功能不同于分屏模式(将多个应用同时显示在屏幕上),而是类似华为平行视界将同一个应用的多个不同Activity同时显示到屏幕上。 本文结合An...
继续阅读 »

背景


Android 13推出了一个大屏幕设备显示方案:Activity嵌入(Activity Embedding)。该功能不同于分屏模式(将多个应用同时显示在屏幕上),而是类似华为平行视界将同一个应用的多个不同Activity同时显示到屏幕上。


本文结合Android 13窗口架构,介绍Activity Embedding的创建流程。


image.png


image.png


窗口模型与Activity Embedding平行视界


Actiivty Embedding的实现流程与Android 13的窗口模型紧密相关。最简单最抽象的情况下,窗口对象之间的关系如下:


image.png


简单来说,Activity所在的Task,是以DisplayArea的形式在整个层级中组织管理的。代表Activity节点的ActivityRecord作为Task的child来管理,Task则由TaskDisplayArea来管理。


用层级结构来看非常直观。下图为常规情况(未进入Activity Embedding平行视界的情况)的层级描述:


image.png


简单解释一下这个层级,该Task位于一个DisplayArea,并以Activity栈的形式管理多个Activity,Activity管理WindowState。其中“V“图标含义是”可见“。


而进入平行视界的分屏模式时,两个Activity将同时显示,而Task本身不提供这个能力,而是由TaskFragment来实现。TaskFragment插入到Task和Activity之间,分割了Task在屏幕上的显示区域,提供给平行视界的两个Activity:


image.png


进入平行视界的层级,可见Task不再管理Actiivty栈,而被TaskFragment取代。


因此,TaskFragment是实现Activity Embedding平行视界的关键。进入平行视界实际上也就是创建TaskFragment并排布位置。


平行视界的一大特征是,Configuration有专属的WindowingMode、MaxBounds不等于Bounds。


image.png


Activity Embedding的两个Activity是独立绘制的:


image.png


Activity Embedding平行视界的流程


Activity Embedding的应用层经过封装,使用相对简单,并且可以根据配置的分屏规则自动完成分屏。


其中关键的两个技术点,自动完成分屏、执行分配操作分别依靠Instrumentation.ActivityMonitor和android.window.ITaskFragmentOrganizerController这个Binder来实现。当新的Activity启动时,ActivityMonitor.onActivityStart()被回调,判断需要启动平行视界时,自动调用ITaskFragmentOrganizerController,实现自动进入分屏。


ITaskFragmentOrganizerController


进入Activity Embedding分屏的关键接口为ITaskFragmentOrganizerController.applyTransaction(),该接口在WindowManagerService中由WindowOrganizerController实现


该方法主要处理Transaction,分为两大类类:Change、HierachyOps。对于平行视界的进入流程,为HierachyOps,简称为HOPs。


通过Transaction为左右两个Activity创建平行视界


创建平行视界的流程封装到了Transaction内,作为HOPs进行处理,保存到Transaction.hops(ArrayLists)内。


创建一个平行视界,实际上分为4步走:1. 创建左边Activity的TaskFragment,设置Configuration内的Bounds属性为左边的平行视界面积大小,并添加到Task内;2. 将左边Activity添加到TaskFragment内;3. 重复第一步,只不过创建的是右边Activity的Fragment;4. 重复第2步,只是目标是右边的Activity。


对应到源码,分别为HIERARCHY_OP_TYPE_CREATE_TASK_FRAGMENT、HIERARCHY_OP_TYPE_REPARENT_ACTIVITY_TO_TASK_FRAGMENT、HIERARCHY_OP_TYPE_CREATE_TASK_FRAGMENT、HIERARCHY_OP_TYPE_SET_ADJACENT_TASK_FRAGMENTS。


image.png


image.png


image.png


image.png


创建的各个参数,关键点为initialBounds属性记录的Rect,它确定了TaskFragment的大小和位置,最终确定了平行视界左右两个Activity的位置和大小。


添加完成后,会按照常规方式触发窗口的relayout和绘制,将平行视界的内容显示到屏幕上。


作者:飞起来_飞过来
链接:https://juejin.cn/post/7225914608552181821
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

程序员的6个真面目,没有一个被冤枉!

纵使工作中有许多酸甜苦辣 你在岗位上的每一点付出 每一行代码的敲下 每一次需求的完成 每一个bug的修复 都让我们的生活变得更加高效便捷 让科技绽放出向善而动人的力量 致敬在岗位上创造不凡的你! 作者:腾讯云开发者来源:juejin.cn/post/72265...
继续阅读 »

图片图片


图片


图片


图片


图片


图片


图片


图片


图片


图片


图片


图片


图片


图片


图片


图片


图片


图片


图片


图片


图片


图片


图片


图片图片图片


图片


图片


图片


图片


图片


图片


纵使工作中有许多酸甜苦辣


你在岗位上的每一点付出


每一行代码的敲下


每一次需求的完成


每一个bug的修复


都让我们的生活变得更加高效便捷


让科技绽放出向善而动人的力量


致敬在岗位上创造不凡的你!



作者:腾讯云开发者
来源:juejin.cn/post/7226526110171889720
收起阅读 »