对于触控式操作来说，滑动是一个特别重要的手势操作，如何做到让应用程序的页面滑动起来如丝般顺滑，让用户感觉到手起刀落的流畅感，是开发人猿需要重点解决的问题，这对提升用户体验是最为重要的事情。本文就将探讨一下，Android中View的滑动相关知识，以及如何做到丝般顺滑。

如何让View滑动起来

View的滑动是GUI支持的一项基本特性，就像触摸事件一件，这是废话，平台如果不支持，你还搞个毛线。

View滑动的基本原理

我们先来看一下Android中实现View的滑动的基本原理。其实屏幕并没有动啊，一个View的可绘制区域，对于屏幕来说，对于view tree来说都是没有变化 的。父布局给某一个View的绘制区域是在layout之后就确定好了的，当View的真实高度或者宽度超过了这块可绘制区域，那么就需要滑动才可以把整个View做到用户可见。View内部通过两个关键成员变量mScrollX和mScrollY来记录滑动之后的坐标，View本身有mLeft和mTop来标识自己相对于父布局的坐标位置，那么当有滑动的时候，在此View当中具体要绘制的区域就变成了以mLeft+mScrollX和mTop+mScrollY为起点的区域了。由此View便滚动起来了。

如何实现View的滑动

对于开发人猿来说，实现View的滑动，需要关注三个重要的方法，也即是View#scrollBy，View#scrollTo以及View#onScrollChanged，这是实现滑动的三个最为核心的方法。

scrollBy提供的参数是需要滑动的距离，而scrollTo则是需要传入要滑动到的目标坐标值，这两个方法都是要修改mScrollX和mScrollY的值，本质上是一样的。而onScrollChanged则是一个回调，用以通知更新了的滑动位置。

Scroll手势

要想让View滑动起来，离不开事件手势的支持。最简单也是最直接的手势就是onScroll手势，这个在GestureDetecor中可以识别出此手势，或者自己去直接处理touch event也可以得出此手势。这个并不复杂，就是直接通过touch 事件来计算滑动多少距离就好了，按照View预设计的可以滑动的方向，比如横向就计算不同时间点MotionEvent的坐标值，得到一个水平距离deltaX，然后调用scrollBy即可。垂直方向依此类推。

Scroll手势简单是因为它是直接来源于事件，且速度较慢，并不需要额外处理，所以整体逻辑处理流程并不复杂。

在GestureDetector中的识别就是在ACTION_MOVE时，查看滑动过的距离，这个距离（由sqrt(dx x dx, dy x dy）如果大于touch slop，就会触发onScroll手势回调。

Fling手势

Fling也即是快速滑动，就是手指在屏幕上使劲的『挠』一下，手势的要点是手指在屏幕快速滑过一小段短距离，就像把一个小球弹出去的感觉一样。对于Fling手势来说，最重要的是速度，水平方向的速度和垂直方向的速度，可以理解为高中物理常讲到的平抛运动一样。

GestureDetector识别Fling的逻辑是，在ACTION_UP时，检查此次事件的速度，如果水平方向速度或者垂直方向速度超过了阈值，便会触发Fling手势回调。

注意：留意Scroll与Fling的区别，Scroll是慢的，不关心时间与速度，只关心滑动的距离，是在ACTION_MOVE时，手指并未有离开屏幕时就触发了，只要是ACTION_MOVE还在继续，就会继续触发onScroll，并且ACTION_UP时终止整个Scroll，而Fling只关心速度，不关心距离，是在ACTION_UP时，手指离开了屏幕了（此次事件流处理结了）才会触发。

VelocityTracker

Fling事件速度是决定性的，仔细看GestureDetector的处理过程会发现它使用了一个叫做VelocityTracker的对象，来帮忙处理一些关于速度的具体逻辑，那么有必要深入了解一下这个对象。

VelocityTracker使用起来并不复杂，获取它的一个对象后，只需要不断的把MotionEvent塞给它就可以了，然后在需要的时候让其计算两个方向上的速度，然后就没有然后了：

    velocityTracker = VelocityTracker.obtain();

    

    onTouchEvent(MotionEvent ev) {

        velocityTracker.addMovement(ev);

        

        if (want to know velocities) {

           velocityTracker.computeCurrentVelocity(100);

           vx = velocityTracker.getXVelocity();

           vy = veolocityTracker.getYVelocity();

           be happy with vx and vy.

        }

     }

这个类的实现，值得仔细看一下，它主要的实现都是用JNI去实现，可能是因为计算方式较复杂，所以computeCurrentVelocity方法也说明了，让你真用的时候再调，这个不用去管细节实现。重点看一下这个类，里面有一个对象池，用以缓存对象，并且创建对象的方式并不是直接new，而是用其obtain方法。这里用的是叫享元（Flyweight Pattern)的设计模式，也就是说VelocityTracker对象其实是共享的。

顺滑如丝

前面提到了，让View滑动，只需要调用scrollBy或者scrollTo即可，但这个吧，是直接修改了mScrollX，mScrollY，然后invalidate，View下次draw时就直接在把目标区域内容绘制出来了，换句话说这两个方法滑动是瞬间跳格式的。

一般来说，这也没有问题，就像onScroll手势，ACTION_MOVE时，不断的scrollBy刚刚滑过的距离，都还okay，没有什么问题。

但是对于Fling事件就不行了，Fling事件，也即快速滑动，要求短时间内进行大距离滑动，或者像有跳转的需求时，也是短时间内要滑动大距离。如果直接scrollBy或者scrollTo一步到位了，会显得 相当的突兀，体验相当不好，卡顿感特别强。如果能像做动画那样，在一定时间内，让其平滑的滑动，就会如丝般顺滑，体验好很多。Scroller就是专门用来解决此问题的。

Scroller

Scroller是对滑动的封装，并不是View的子类，其实它跟View一点关系也没有，也不能操作View，实际上它与属性动画类似，它仅是一个滚动位置的计算器，告诉它起始位置和要滚动的距离，然后它就会告诉你位置随时间变化的值。其实这是一个中学物理题，也即给定初始位置，给定要滚动的距离，以一定的方式来计算每个时间点的位置。具体的计算方式由mInterpolater成员来控制，默认是ViscousFluid，是按自然指数为减速度来计算的，具体的可以查看Scroller的源码。如果不喜欢默认的计算方式，可以自己实现个Interpolator，然后在构造时传进去。

Scroller的作用在于实现平稳滑动，不让View的滚动出现跳跃，比如滑动一下ListView，开始滑动时的位置是x0，y0（ActionDown的位置），要向下滑动比如500个像素，不平稳的意思是，从x0，一下跳到x0+500的位置。要平稳，就要不断的一点点的改变x的值然后invalidate，这也就是Scroller的典型使用场景：

Scroller scroller = new Scroller(getContext());

scroller.startScroll(x0, y0, 500, 0);

然后在computeScroll时：

if (scroller.computeScrollOffset()) {

   int currX = scroller.getCurrX();

   int currY = scroller.getCurrY();

   invalidate(); // with currX and currY

}

computeScrollOffset在滚动没结束时返回true，也就是说你需要继续刷新view。返回false时表明滚动结束了，当然也就没有必要再刷新view（当然如果你乐意也可以继续刷，但是位置啥的都不变了，所以刷了也白刷）。

滑动冲突处理

关于View的滑动，最难搞的问题便是手势冲突处理，特别是当页面的结构变得复杂了以后。一般来讲，滑动手势，是让某一个View沿着某一个方向『平移』一段距离，如果某一个页面中只有一个View是可以滑动的，或者页面中不同的View的可滑动方向是垂直正交的，那么就不会有冲突的问题。

所谓滑动冲突，是指父View和子View都接受滑动手势，并且方向又是一样的，这时就产生了滑动冲突，常见就是ScrollView中套着ListView（这个通常是垂直Y方向上面有滑动冲突），或者ViewPager中套着ScrollView（这个是水平X方向上有滑动冲突）。

要想解决好滑动冲突问题，需要先确实好整体的设计方案，有了大的原则后，就容易用技术方案找到解法。最理想的方案，也是目前用的最多的方案就是在子View的边界设定一个margin区域，当ACTION_DOWN在margin区域以外，认定滑动手势归父View处理，否则交由子View处理。像一些全局手势也是要用如此的方案，当点击距离屏幕一定范围内(margin区域)认定此事件归当前页面处理，否则就认定为全局手势，就好比从屏幕左边向右滑动，很多应该将此识别为BACK到上一页，但如果离左边较远时滑动，就会是页面内部的滑动事件（假如它有可滑动的组件的话，事件手势会被其滑消耗掉）。

监听事件

我们可以使用 v-on 指令 (简写为 @) 来监听 DOM 事件，并在事件触发时执行对应的 JavaScript。用法：v-on:click="handler" 或 @click="handler"。

事件处理器 (handler) 的值可以是：

1. 内联事件处理器：事件被触发时执行的内联 JavaScript 语句 (与 onclick 类似)。


2. 方法事件处理器：一个指向组件上定义的方法的属性名或是路径。

内联事件处理器

内联事件处理器通常用于简单场景，例如：

data() {

  return {

    count: 0

  }

}

<button @click="count++">Add 1</button>

<p>Count is: {{ count }}</p>

方法事件处理器

随着事件处理器的逻辑变得愈发复杂，内联代码方式变得不够灵活。因此 v-on 也可以接受一个方法名或对某个方法的调用。

data() {

  return {

    name: 'Vue.js'

  }

},

methods: {

  greet(event) {

    // 方法中的 `this` 指向当前活跃的组件实例

    alert(`Hello ${this.name}!`)

    // `event` 是 DOM 原生事件

    if (event) {

      alert(event.target.tagName)

    }

  }

}

<!-- `greet` 是上面定义过的方法名 -->

<button @click="greet">Greet</button>

方法与内联事件判断

模板编译器会通过检查 v-on 的值是否是合法的 JavaScript 标识符或属性访问路径来断定是何种形式的事件处理器。举例来说，foo、foo.bar 和 foo['bar'] 会被视为方法事件处理器，而 foo() 和 count++ 会被视为内联事件处理器。

在内联处理器中调用方法

除了直接绑定方法名，你还可以在内联事件处理器中调用方法。这允许我们向方法传入自定义参数以代替原生事件：

methods: {

  say(message) {

    alert(message)

  }

}

<button @click="say('hello')">Say hello</button>

<button @click="say('bye')">Say bye</button>

在内联事件处理器中访问事件参数

有时我们需要在内联事件处理器中访问原生 DOM 事件。你可以向该处理器方法传入一个特殊的 $event 变量，或者使用内联箭头函数：

<!-- 使用特殊的 $event 变量 -->

<button @click="warn('Form cannot be submitted yet.', $event)">

  Submit

</button>



<!-- 使用内联箭头函数 -->

<button @click="(event) => warn('Form cannot be submitted yet.', event)">

  Submit

</button>

methods: {

  warn(message, event) {

    // 这里可以访问 DOM 原生事件

    if (event) {

      event.preventDefault()

    }

    alert(message)

  }

}

事件修饰符

在处理事件时调用 event.preventDefault() 或 event.stopPropagation() 是很常见的。尽管我们可以直接在方法内调用，但如果方法能更专注于数据逻辑而不用去处理 DOM 事件的细节会更好。

为解决这一问题，Vue 为 v-on 提供了事件修饰符。修饰符是用 . 表示的指令后缀，包含以下这些：

• .stop


• .prevent


• .self


• .capture


• .once


• .passive

<!-- 单击事件将停止传递 -->

<a @click.stop="doThis"></a>



<!-- 提交事件将不再重新加载页面 -->

<form @submit.prevent="onSubmit"></form>



<!-- 修饰语可以使用链式书写 -->

<a @click.stop.prevent="doThat"></a>



<!-- 也可以只有修饰符 -->

<form @submit.prevent></form>



<!-- 仅当 event.target 是元素本身时才会触发事件处理器 -->

<!-- 例如：事件处理器不来自子元素 -->

<div @click.self="doThat">...</div>

例子说明：

stop

阻止了事件冒泡，相当于调用了event.stopPropagation方法

<div @click="shout(2)">

  <button @click.stop="shout(1)">ok</button>

</div>

点击shout只输出1，不会触发shout(2)

prevent

单击“提交”按钮，阻止其提交表单
阻止了事件的默认行为，相当于调用了event.preventDefault方法
<form v-on:submit.prevent="onSubmit"></form>

self

只当在 event.target 是当前元素自身时触发处理函数

<div v-on:click.self="doThat">...</div>

使用修饰符时，顺序很重要；相应的代码会以同样的顺序产生。因此，用 v-on:click.prevent.self 会阻止所有的点击，而 v-on:click.self.prevent 只会阻止对元素自身的点击

once

绑定了事件以后只能触发一次，第二次就不会触发
<button @click.once="shout(1)">ok</button>

capture

使事件触发从包含这个元素的顶层开始往下触发

<div @click.capture="shout(1)">  

    obj1  

        <div @click.capture="shout(2)">  

            obj2  

            <div @click="shout(3)">  

                obj3  

                    <div @click="shout(4)">  

                        obj4  

                    </div>  

            </div>  

        </div>  

</div>

passive

在移动端，当我们在监听元素滚动事件的时候，会一直触发onscroll事件会让我们的网页变卡，因此我们使用这个修饰符的时候，相当于给onscroll事件整了一个.lazy修饰符
<div v-on:scroll.passive="onScroll">...</div>

native

让组件变成像html内置标签那样监听根元素的原生事件，否则组件上使用 v-on 只会监听自定义事件

按键修饰符

在监听键盘事件时，我们经常需要检查特定的按键。Vue 允许在 v-on 或 @ 监听按键事件时添加按键修饰符。

<!-- 仅在 `key` 为 `Enter` 时调用 `submit` -->

<input @keyup.enter="submit" />

你可以直接使用 [KeyboardEvent.key]

<input @keyup.page-down="onPageDown" />

在上面的例子中，仅会在 $event.key 为 'PageDown' 时调用事件处理。

按键别名

Vue 为一些常用的按键提供了别名：

• .enter


• .tab


• .delete (捕获“Delete”和“Backspace”两个按键)


• .esc


• .space


• .up


• .down


• .left


• .right

系统按键修饰符

你可以使用以下系统按键修饰符来触发鼠标或键盘事件监听器，只有当按键被按下时才会触发。

• .ctrl


• .alt


• .shift


• .meta

例子：

<!-- Alt + Enter --> <input @keyup.alt.enter="clear" /> <!-- Ctrl + 点击 --> 

<div @click.ctrl="doSomething">Do something</div>

.exact 修饰符

.exact 修饰符允许控制触发一个事件所需的确定组合的系统按键修饰符。

<!-- 当按下 Ctrl 时，即使同时按下 Alt 或 Shift 也会触发 -->

<button @click.ctrl="onClick">A</button>



<!-- 仅当按下 Ctrl 且未按任何其他键时才会触发 -->

<button @click.ctrl.exact="onCtrlClick">A</button>



<!-- 仅当没有按下任何系统按键时触发 -->

<button @click.exact="onClick">A</button>

鼠标按键修饰符

• .left


• .right


• .middle

这些修饰符将处理程序限定为由特定鼠标按键触发的事件。

class 绑定

数据

data() { return { isActive: true, hasError: false } }

模板：

<div :text-danger': hasError }" ></div>

渲染：

<div></div>

计算属性：

computed: { 

    classObject() 

    { 

    return 

        { 

            active: this.isActive && !this.error, 

            'text-danger': this.error && this.error.type === 'fatal' 

        } 

    } 

}

绑定数组

<div :></div>

数组中嵌套对象
<div :></div>

在组件上使用

<!-- 子组件模板 -->

<p class="foo bar">Hi!</p>

在使用时添加一些 class：

<!-- 在使用组件时 -->

<MyComponent class="baz boo" />

渲染出的 HTML 为：

<p class="foo bar baz boo">Hi!</p>

如果你的组件有多个根元素，你将需要指定哪个根元素来接收这个 class。你可以通过组件的 $attrs 属性来实现指定：

<!-- MyComponent 模板使用 $attrs 时 -->

<p :class="$attrs.class">Hi!</p>

<span>This is a child component</span>

<MyComponent class="baz" />

这将被渲染为：

<p>Hi!</p>

<span>This is a child component</span>

绑定内联Style

data() {

  return {

    activeColor: 'red',

    fontSize: 30

  }

}

<div :style="{ color: activeColor, fontSize: fontSize + 'px' }"></div>

直接绑定一个样式对象

data() {

  return {

    styleObject: {

      color: 'red',

      fontSize: '13px'

    }

  }

}

<div :style="styleObject"></div>

绑定一个包含多个样式对象的数组

<div :style="[baseStyles, overridingStyles]"></div>

样式多值

你可以对一个样式属性提供多个 (不同前缀的) 值，举例来说：

<div :style="{ display: ['-webkit-box', '-ms-flexbox', 'flex'] }"></div>

数组仅会渲染浏览器支持的最后一个值。在这个示例中，在支持不需要特别前缀的浏览器中都会渲染为 display: flex。

条件渲染

v-if 

指令用于条件性地渲染一块内容。这块内容只会在指令的表达式返回真值时才被渲染。

<h1 v-if="awesome">Vue is awesome!</h1>

v-else

你也可以使用 v-else 为 v-if 添加一个“else 区块”。

<button @click="awesome = !awesome">Toggle</button>



<h1 v-if="awesome">Vue is awesome!</h1>

<h1 v-else>Oh no 😢</h1>

一个 v-else 元素必须跟在一个 v-if 或者 v-else-if 元素后面，否则它将不会被识别。

v-else-if

顾名思义，v-else-if 提供的是相应于 v-if 的“else if 区块”。它可以连续多次重复使用：

<div v-if="type === 'A'">

  A

</div>

<div v-else-if="type === 'B'">

  B

</div>

<div v-else-if="type === 'C'">

  C

</div>

<div v-else>

  Not A/B/C

</div>

和 v-else 类似，一个使用 v-else-if 的元素必须紧跟在一个 v-if 或一个 v-else-if 元素后面。

<template> 上的 v-if

<template v-if="ok">

  <h1>Title</h1>

  <p>Paragraph 1</p>

  <p>Paragraph 2</p>

</template>

v-else 和 v-else-if 也可以在 <template> 上使用。

v-show

另一个可以用来按条件显示一个元素的指令是 v-show。其用法基本一样：

<h1 v-show="ok">Hello!</h1>

不同之处在于 v-show 会在 DOM 渲染中保留该元素；v-show 仅切换了该元素上名为 display 的 CSS 属性。

v-show 不支持在 <template> 元素上使用，也不能和 v-else 搭配使用。

v-if 对比 v-show

v-if 是“真实的”按条件渲染，因为它确保了在切换时，条件区块内的事件监听器和子组件都会被销毁与重建。

v-if 也是惰性的：如果在初次渲染时条件值为 false，则不会做任何事。条件区块只有当条件首次变为 true 时才被渲染。

相比之下，v-show 简单许多，元素无论初始条件如何，始终会被渲染，只有 CSS display 属性会被切换。

总的来说，v-if 有更高的切换开销，而 v-show 有更高的初始渲染开销。因此，如果需要频繁切换，则使用 v-show 较好；如果在运行时绑定条件很少改变，则 v-if 会更合适

列表渲染

v-for

我们可以使用 v-for 指令基于一个数组来渲染一个列表。v-for 指令的值需要使用 item in items 形式的特殊语法，其中 items 是源数据的数组，而 item 是迭代项的别名：

data() {

  return {

    items: [{ message: 'Foo' }, { message: 'Bar' }]

  }

}

<li v-for="item in items">

  {{ item.message }}

</li>

在 v-for 块中可以完整地访问父作用域内的属性和变量。v-for 也支持使用可选的第二个参数表示当前项的位置索引。

data() {

  return {

    parentMessage: 'Parent',

    items: [{ message: 'Foo' }, { message: 'Bar' }]

  }

}

<li v-for="(item, index) in items">

  {{ parentMessage }} - {{ index }} - {{ item.message }}

</li>

v-for 变量的作用域和下面的 JavaScript 代码很类似：

const parentMessage = 'Parent'

const items = [

  /* ... */

]



items.forEach((item, index) => {

  // 可以访问外层的 `parentMessage`

  // 而 `item` 和 `index` 只在这个作用域可用

  console.log(parentMessage, item.message, index)

})

注意 v-for 是如何对应 forEach 回调的函数签名的。实际上，你也可以在定义 v-for 的变量别名时使用解构，和解构函数参数类似：

<li v-for="{ message } in items">

  {{ message }}

</li>



<!-- 有 index 索引时 -->

<li v-for="({ message }, index) in items">

  {{ message }} {{ index }}

</li>

对于多层嵌套的 v-for，作用域的工作方式和函数的作用域很类似。每个 v-for 作用域都可以访问到父级作用域：

<li v-for="item in items">

  <span v-for="childItem in item.children">

    {{ item.message }} {{ childItem }}

  </span>

</li>

你也可以使用 of 作为分隔符来替代 in，这更接近 JavaScript 的迭代器语法：

<div v-for="item of items"></div>

v-for 与对象

你也可以使用 v-for 来遍历一个对象的所有属性。遍历的顺序会基于对该对象调用 Object.keys() 的返回值来决定。

data() {

  return {

    myObject: {

      title: 'How to do lists in Vue',

      author: 'Jane Doe',

      publishedAt: '2016-04-10'

    }

  }

}

<ul>

  <li v-for="value in myObject">

    {{ value }}

  </li>

</ul>

可以通过提供第二个参数表示属性名 (例如 key)：

<li v-for="(value, key) in myObject">

  {{ key }}: {{ value }}

</li>

第三个参数表示位置索引：

<li v-for="(value, key, index) in myObject">

  {{ index }}. {{ key }}: {{ value }}

</li>

在 v-for 里使用范围值

v-for 可以直接接受一个整数值。在这种用例中，会将该模板基于 1...n 的取值范围重复多次。

<span v-for="n in 10">{{ n }}</span>

注意此处 n 的初值是从 1 开始而非 0。

<template> 上的 v-for

与模板上的 v-if 类似，你也可以在 <template> 标签上使用 v-for 来渲染一个包含多个元素的块。例如：

<ul>

  <template v-for="item in items">

    <li>{{ item.msg }}</li>

    <li class="divider" role="presentation"></li>

  </template>

</ul>

通过 key 管理状态

Vue 默认按照“就地更新”的策略来更新通过 v-for 渲染的元素列表。当数据项的顺序改变时，Vue 不会随之移动 DOM 元素的顺序，而是就地更新每个元素，确保它们在原本指定的索引位置上渲染。

<div v-for="item in items" :key="item.id"> <!-- 内容 --> </div>

必要性
vue在patch过程中判断两个节点是否为相同节点，key是一个必要条件，渲染一组列表时key往往是唯一标识，如果不定义key，vue会认为比较的两个节点是同一个（哪怕不是），这会导致频繁更新元素，使得整个patch过程比较低效，影响性能

实际使用方式
实际使用中在渲染一组列表时key必须设置，而且是唯一标识，应避免使用数组索引作为key，因为这可能会导致一些隐藏的bug；vue在相同标签元素过渡切换的时候也会使用可以，目的也是让vue能够区分它们，否则vue只会替换其内部属性，而不会触发过渡效果

数组变化侦测

变更方法

Vue 能够侦听响应式数组的变更方法，并在它们被调用时触发相关的更新。这些变更方法包括：

• push()


• pop()


• shift()


• unshift()


• splice()


• sort()


• reverse()

在计算属性中使用 reverse() 和 sort() 的时候务必小心！这两个方法将变更原始数组，计算函数中不应该这么做。请在调用这些方法之前创建一个原数组的副本：

- return numbers.reverse() + return [...numbers].reverse()

前言

在Kotlin中声明一个Lambda表达式，在编译字节码中会产生一个匿名类。此匿名类中有一个 invoke方法，为Lambda的调用方法，每次调用会创建一个新匿名类对象。可想而知，Lambda语法虽简洁，但额外增加的开销也不少。还有，若Lambda捕捉某个变量，每次调用时都会创建一个新对象，会导致效率较低。

在Kotlin中采取优化Lambda额外开销的方式就是：内联函数。

回顾Java中采取的优化方式：invokedynamic

invokedynamic技术是Java7后提出，在运行期才产生相应翻译代码。
invokedynamic被首次调用时，会触发产生一个匿名类来替换中间码invokedynamic，后续调用会直接采用该匿名类代码。这种做的好处主要有：

• 具体的转换实现是在运行时产生，在字节码中只有一个固定的invokedynamic，所以需要静态生成的类的个数及字节码大小都显著减少。


• 与编译时写死在字节码中的策略不同，利用invokedynamic可把实际的翻译策略隐藏在JDK库的实现， 极大提高了灵活性，在确保向后兼容性的同时，后期可以继续对编译策略不断优化升级


• JVM天然支持针对该方式的Lambda表达式的翻译和优化，开发者在书写Lambda表达式时，可以完全不用关心这个问题，极大地提升了开发体验。

Kotlin中采取的优化方式：内联函数

Kotlin拥抱内联函数，在C++、C#等语言中也支持这种特性。可以用 inline 关键字来修饰函数，这些函数就称为内联函数。它的函数体在编译期被嵌入到每一个被调用的地方，以减少额外生成的匿名类数，以及函数执行的时间开销。

内联函数的工作原理并不复杂，就是Kotlin编译器会将内联函数中的代码在编译的时候自动替换到调用它的地方，这样就不存在运行时的开销。

若想在用Kotlin开发时获得尽可能良好的性能支持，以及控制匿名类的生成数量，就来学习下内联函数：

如以下示例:

fun main() {

    foo {

        println("dive into Kotlin...")

    }

}



fun foo(block: () -> Unit) {

    println("before block")

    block()

    println("end block")

}

以上声明一个高阶函数foo，接受一个Lambda 参数为 () -> Unit，最后在main函数中调用它。下面是通过字节码反编译的Java代码:

public static final void main(@NotNull String[] args) {

    Intrinsics.checkParameterIsNotNull(args, "args");

    foo((Function0)null.INSTANCE);	        

}



public static final void foo(@NotNull Function0 block) {

    Intrinsics.checkParameterIsNotNull(block, "block");

    String var1 = "before block";

    System.out.println(var1);

    block.invoke();

    var1 = "end block";

    System.out.println(var1);

}

调用foo会产生一个Function()类型的block类，然后通过 invovke() 来执行，这样会增加额外生成类和调用开销。下面给foo函数加上inline修饰符:

inline fun foo(block: () -> Unit) {

    println("before block")

    block()

    println("end block")

}

看看相应Java代码:

public static final void main(@NotNull String[] args) {

    Intrinsics.checkParameterIsNotNull(args, "args");

    String va1 = "before block";

    System.out.println(var1);

    // block函数体在这里开始粘贴

    String var2 = "dive into Kotlin...";

    System.out.println(var2);

    // block函数体在这里结束粘贴

    var1 = "end block";

    System.out.println(var1);

}



public static final void foo(@NotNull Function0 block) {

    Intrinsics.checkParameterIsNotNull(block, "block");

    String var2 = "before block";

    System.out.println(var2);

    block.invoke();

    var2 = "end block";

    System.out.println(var2);

}

如上面所说，foo 函数体代码及被调用的Lambda代码都粘贴到了相应调用的位置。试想下，若是一个公共方法，或被嵌套在一个循环调用中，该方法势必会被调用很多次。通过inline函数，可以消除这种额外调用，从而节省开销。

内联函数一个典型应用场景就是Kotlin集合类。Kotlin 中集合函数式API，如map、filter都是被定义成内联函数：

inline fun <T, R> Array<out T>.map {

    transform: (T) -> R

}: List<R>



inline fun <T> Array<out T>.filter {

    predicate: (T) -> Boolean

}: List<T>

很容易理解，因这些方法都接收Lambda表达式参数，需要对集合元素进行遍历操作，因此把相应的实现进行内联无疑是适合的。

但内联函数不是万能的，以下情况应避免使用内联函数:

• JVM对普通函数已经能够根据实际情况智能判断是否进行内联优化，因此并不需要对其使用Kotlin的inline语法，否则只会让字节码变得更加复杂


• 尽量避免对具有大量函数体的函数进行内联，会导致过多的字节码数量


• 一个函数被定义为内联函数，就不能获取闭包类的私有成员，除非把它声明为internal

Swift介绍

Swift这门编程语言主要用于iOS和MacOS的开发，可以说是非常流行的一门编程语言，我只想说，如果你会Kotlin，那么你学习Swift会非常容易，反之亦然。下载XCode，然后你就可以创建Playground练习Swift语法了。

playground这个名字起的好，翻译成中文就是操场，玩的地方，也就是说，你可以尽情的测试你的Swift代码。

声明变量和常量

Kotlin的写法：

var a: Int = 10

val b: Float = 20f

Swift的写法：

var a: Int = 10

let b: Float = 20.0

你会发现它俩声明变量的方式一模一样，而常量也只是关键字不一样，数据类型我们暂不考虑。

导包

Kotlin的写法：

import android.app.Activity

Swift的写法：

import SwiftUI

这里kotlin和swift的方式一模一样。

整形

Kotlin的写法：

val a: Byte = -10

val b: Short = 20

val c: Int = -30

val d: Long = 40

Swift的写法：

let a: Int8 = -10

let b: Int16 = 20

let c: Int32 = -30

let d: Int = -30

let e: Int64 = 40

let f: UInt8 = 10

let g: UInt16 = 20

let h: UInt32 = 30

let i: UInt = 30

let j: UInt64 = 40

Kotlin没有无符号整型，Swift中Int32等价于Int，UInt32等价于UInt。无符号类型代表是正数，所以没有符号。

基本运算符

Kotlin的写法：

val a: Int = 10

val b: Float = 20f

val c = a + b

Swift的写法：

let a: Int = 10

let b: Float = 20

let c = Float(a) + b

Swift中没有隐式转换，Float类型不用写f。这里Kotlin没那么严格。

逻辑分支

Kotlin的写法：

val a = 65

if (a > 60) {

}



val b = 1

when (b) {

    1 -> print("b等于1")

    2 -> print("b等于2")

    else -> print("默认值")

}

Swift的写法：

let a = 65

if a > 60 {

}



let b = 1

switch b {

case 1:

    print("b等于1")

case 2:

    print("b等于2")

default:

    print("默认值")

}

Swift可以省略if的括号，Kotlin不可以。switch的写法倒是有点像Java了。

循环语句

Kotlin的写法：

for (i in 0..9) {

}

Swift的写法：

for var i in 0...9 {

}

// 或

for var i in 0..<10 {

}

Kotlin还是不能省略括号。

字符串

Kotlin的写法：

val lang = "Kotlin"

val str = "Hello $lang"

Swift的写法：

let lang = "Swift"

let str = "Hello \(lang)"

字符串的声明方式一模一样，拼接方式略有不同。

数组

Kotlin的写法：

val arr = arrayOf("Hello", "JYM")

val arr2 = emptyArray<String>()

val arr3: Array<String>

Swift的写法：

let arr = ["Hello", "JYM"]

let arr2 = [String]()

let arr3: [String]

数组的写法稍微有点不同。

Map和Dictionary

Kotlin的写法：

val map = hashMapOf<String, Any>()

map["name"] = "张三"

map["age"] = 100

Swift的写法：

let dict: Dictionary<String, Any> = ["name": "张三", "age": 100]

Swift的字典声明时必须初始化。Map和Dictionary的本质都是哈希。

函数

Kotlin的写法：

fun print(param: String) : Unit {

}

Swift的写法：

func print(param: String) -> Void {

}

或

func print(param: String) -> () {

}

除了关键字和返回值分隔符不一样，其他几乎一模一样。

高阶函数和闭包

Kotlin的写法：

fun showDialog(build: BaseDialog.() -> Unit) {

}

Swift的写法：

func showDialog(build: (dialog: BaseDialog) -> ()) {

}

Kotlin的高阶函数和Swift的闭包是类似的概念，用于函数的参数也是一个函数的情况。

创建对象

Kotlin的写法：

val btn = Button(context)

Swift的写法：

let btn = UIButton()

这里kotlin和swift的方式一模一样。

类继承

Kotlin的写法：

class MainPresenter : BasePresenter {

}

Swift的写法：

class ViewController : UIViewController {

}

这里kotlin和swift的方式一模一样。

Swift有而Kotlin没有的语法

guard...else的语法，通常用于登录校验，条件不满足，就执行else的语句，条件满足，才执行guard外面的语句。

guard 条件表达式 else {

}

另外还有一个重要的语法就是元组。元祖在Kotlin中没有，但是在一些其他编程语言中是有的，比如Lua、Solidity。元组主要用于函数的返回值，可以返回一个元组合，这样就相当于函数可以返回多个返回值了。
Swift的元组：

let group = ("哆啦", 18, "全宇宙最强吹牛首席前台")

Lua的多返回值：

function group() return "a","b" end

Solidity的元组：

contract MyContract {

  mapping(uint => string) public students;

 

  function MyContract(){

      students[0] = "默认姓名";

      students[1] = "默认年龄";

      students[2] = "默认介绍";

  }

 

  function printInfo() constant returns(string,uint,string){

      return("哆啦", 18, "全宇宙最强吹牛首席前台");

  }

}

总结

编程语言很多地方都是相通的，学会了面向对象编程，你学习其他编程语言就会非常容易。学习一门其他编程语言的语法是很快的，但是要熟练掌握，还需要对该编程语言的API有大量的实践。还是那句话，编程语言只是工具，你的编程思维的高度才是决定你水平的重要指标。所以我给新入行互联网的同学的建议是，你可以先学习面向对象的编程思想，不用局限于一门语言，可以多了解下其他的编程语言，选择你更喜欢的方向。选择好后，再深耕一门技术。每个人的道不一样，可能你就更适合某一个方向。

Flutter这么火为什么不了解一下呢？（上）

Flutter是Google移动UI框架，用以创建高质量的native接口，真正跨平台，同时在iOS和Android上运行。Flutter是免费开源的，全球开发者及组织均可以使用。

Flutter有又几个特点：

1.快速开发 毫秒级的热加载快速地将修改应用到app。使用丰富的可完全自定义的组件在几分钟内就可以构建native界面。

2.极具表现力，灵活的UI 快速地将特性集中到native终端用户体验。利用分层结构可以完整地自定义UI，进而完成快速绘制及灵活的设计。

3.native性能 Flutter组件包含了所有平台的关键差异，例如滚动，导航，图标和字体。使得Flutter在iOS和Android上使用可以获得完全的native性能体验。

快速开发

Flutter热加载技术有助于你快速且简单地进行试验，构建UI，增加特性，并且快速修复bug。体验不到一秒的重新加载体验。

漂亮的UI

Flutter内置MD设计风格及iOS组件，更有丰富的手势API，流畅的滚动体验和平台认同感会让用户感到愉悦。

现代的响应式框架（Modern，reactive framework）

利用Flutter响应式框架和丰富的平台，布局和功能组件是的UI构建非常简单。使用灵活并且强大的API（2D，动画，手势，性能等）可以解决在UI上各种问题。

  int counter = 0;



  void increment() {

    // Tells the Flutter framework that state has changed,

    // so the framework can run build() and update the display.

    setState(() {

      counter++;

    });

  }



  Widget build(BuildContext context) {

    // This method is rerun every time setState is called.

    // The Flutter framework has been optimized to make rerunning

    // build methods fast, so that you can just rebuild anything that

    // needs updating rather than having to individually change

    // instances of widgets.

    return new Row(

      children: <Widget>[

        new RaisedButton(

          onPressed: increment,

          child: new Text('Increment'),

        ),

        new Text('Count: $counter'),

      ],

    );

  }

}

使用native特性和SDKs

我们使用平台APIs，第三方SDKs和native代码开发APP。Flutter可以让你在iOS和Android继续使用Java，Swift，Objective-C代码并且使用native特性。

访问平台特性很简单。下边的代码片段开始：

    var batteryLevel = 'unknown';

    try {

        int result = await methodChannel.invokeMethod('getBatteryLevel');

        batteryLevel = 'Battery level: $result%';

      } on PlatformException {

        batteryLevel = 'Failed to get battery level.';

      }

      setState(() {

        _batteryLevel = batteryLevel;

      });

}

学习如何使用包(packages)，或者写platform channels，使用native代码，APIs和SDKs。

统一的开发标准

Flutter拥有工具及库帮助你简单快速地在iOS和Android上实现你的想法。若你还没有任何移动开发经验，那么Flutter将会是你构建漂亮的移动APP的一种简单快速的额方式。若你是有经验的iOS或者Android开发人员，那么你可以使用Flutter组件，并且继续使用已有的Java/Objective-C/Swift程序。

构建 漂亮的APP UI 丰富的2D GPU加速APIs 响应式框架 动画/动作 APIs 兼容Android Material组件及苹果组件样式

流程的编码体验 急速热加载技术 IntelliJ：重构，自动补足功能等 Dart语言及核心库 包管理

拥有App所有特性 与移动OS APIs&SDKs互操作性 Maven/Java Cocoapods/ObjC/Swift

优化 测试 Unit测试 继承测试 无设备测试

Debug IDE debug 基于网络debug 异步/唤醒感知 表达式求值程序

配置 时间线 CPU和内存 应用性能图标

部署 编译 Native ARM程序 消除无效代码

发布 App市场 Play Store

标题安装Flutter

在国内安装Flutter需要首先需要一个值得信任的国内镜像。在镜像上边保存着Flutter需要的依赖及相关库，包等。为了使用Flutter，需要使用一个备用存储位置，我们需要配置环境变量。 配置环境变量名： PUB_HOSTED_URL 和 FLUTTER_STORAGE_BASE_URL。

在windows系统中，需要在环境变量设置中添加：

PUB_HOSTED_URL ： pub.flutter-io.cn FLUTTER_STORAGE_BASE_URL ： storage.flutter-io.cn

然后运行Git命令（前提是安装了GitBash工具）：

git clone -b dev https://github.com/flutter/flutter.git Flutter

Flutter文件夹需要注意：文件夹存放的路径上不要出现空格，否则在IDE中进行工程创建后会有警告，SDK环境路径上存在分隔符。

在clone完成之后，即Flutter Sdk下载完毕，还需要配置Flutter环境： xxxx/Flutter/bin目录下。

重新打开一个命令行，在其中输入命令

flutter doctor

进行环境及缺失的依赖检查，并下载需要的依赖。 运行效果如下图：

在环境及相关依赖检查完成之后，可以开始在Android Studio中进行创建工程行为。

注意：Android Studio 预览版中无法保证运行Flutter成功。因此需要使用稳定版AS，且需要3.0版本以上。

Android Studio中需要安装Flutter Plugin，Dart Plugin两个插件。

Dart SDK也需要手动安装，直接下载zip包免安装。

成功准备好IDE环境之后，就可以创建Flutter Project了，默认创建Flutter Application就可以了，按照IDE创建提示一直到最终完成。

需要注意：同样由于网络环境，直接运行Flutter Project是不可行的，UI会一直停留在Gradle正在初始化工程。这时需要修改build.gradle配置中的中央Maven库到一个可信赖的公共Maven库。 这里我修改成Ali的Maven库

buildscript {

    ext.kotlin_version = '1.1.51'

    repositories {

        maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }

        google()

    }

    // ......

}



// ......



allprojects {

    repositories {

        maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }

    }

    google()

}

// ......

然后再次sync工程，进行运行。

首个创建的Flutter Project工程结构如下：

一、前景提示

最近接到一个查看大图的需求，现在图片展示还不够大，要求还要能缩小能放大还能保存照片。直接开始Google实现方式。

二、实现功能

根据查询到的结果分为两种，一个是使用手势监听来实现，第二种监听触摸事件来实现

• 手势监听-- ScaleGestureDetector Google提供的手势监听类


• 触摸事件--OnTouchListener 自己监听触摸事件自己实现放大缩小的逻辑

2.1 手势监听

先写布局文件

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

<androidx.constraintlayout.widget.ConstraintLayout 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"

  tools:context=".MainActivity">



  <androidx.appcompat.widget.AppCompatImageView

    android:id="@+id/iv_example"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:text="Hello World!"

    android:scaleType="fitCenter"

    android:src="@drawable/muffin_7870491_1920"

    app:layout_constraintBottom_toBottomOf="parent"

    app:layout_constraintEnd_toEndOf="parent"

    app:layout_constraintStart_toStartOf="parent"

    app:layout_constraintTop_toTopOf="parent" />



</androidx.constraintlayout.widget.ConstraintLayout>

再去实现手势监听方法

class MainActivity : AppCompatActivity() {

    private lateinit var mScaleGestureDetector: ScaleGestureDetector

    private var mScaleFactor: Float = 1.0f

    private lateinit var mImageView: AppCompatImageView



    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        setContentView(R.layout.activity_main)

        mImageView = findViewById(R.id.iv_example)

        mScaleGestureDetector = ScaleGestureDetector(this, ScaleGestureListener())

        mImageView.setOnTouchListener { _, event ->

            mScaleGestureDetector.onTouchEvent(event)

            true

        }

    }





    private inner class ScaleGestureListener : ScaleGestureDetector.SimpleOnScaleGestureListener() {

        override fun onScale(detector: ScaleGestureDetector): Boolean {

            mScaleFactor *= detector.scaleFactor

            // 限制缩放因子在0.1到10.0

            mScaleFactor = mScaleFactor.coerceIn(0.1f, 10.0f)

            mImageView.scaleX = mScaleFactor

            mImageView.scaleY = mScaleFactor

            return true

        }

    }

}

代码很简单直接使用ScaleGestureDetector去监听触摸事件，手势本质也是Google内部监听事件判断再回调给我们使用。当然我们这里不去查看源码，只看实现过程。
在使用过程中发现这种缩放并不平滑，而且响应有点慢，有延迟。猜想内部是由很多其他的判断吧。那我们只想简单一点怎么搞呢，那就是自己去判断缩放，还有实现单指滑动用手势也不太好实现的样子。所以我们试试第二种方式实现也就是触摸事件。

2.2 触摸事件

首先我们实现一下缩放，我们还是沿用上次使用onTouchListener来处理我们的触摸事件，布局文件中需要把imageView的缩放属性改为矩阵 android:scaleType="matrix"

private var startMatrix = Matrix()

mImageView.setOnTouchListener { _, event ->

    when(event.action and MotionEvent.ACTION_MASK) {

        MotionEvent.ACTION_POINTER_DOWN -> {

            // 记录双指按下的位置和距离

            startDistance = getDistance(event)

            if (startDistance > 10f) {

                startMatrix.set(mImageView.imageMatrix)

                mode = 2

            }

            return@setOnTouchListener true

        }

    }

    true

}

没有自己处理过触摸事件的小伙伴可能会好奇MotionEvent.ACTION_MASK是什么，其实这个是为了处理多点触摸事件加的一个flag和action做and操作，我们就能处理ACTION_POINTER_DOWN和ACTION_POINTER_UP这两个多点触摸事件。
看下代码逻辑，我们先计算两个手指的距离，如果距离大于10就证明是缩放操作，设置成我们自己定义的模式，再把imageView的矩阵保存，后续对照片移动，缩放都是通过变换矩阵来实现的。
至于计算两个手指之间的距离用的勾股定理，来个示意图，大家就明白了。

计算如下。

 private fun getDistance(event: MotionEvent): Float {

        val dx = event.getX(0) - event.getX(1)

        val dy = event.getY(0) - event.getY(1)

        return sqrt(dx * dx + dy * dy)

    }

通过计算能得到直角边和邻边，对他们使用勾股定理就能得到斜边的值，也就是两个手指之间的距离。
有做过触摸事件监听的同学就应该知道，我们下一步要监听移动事件了也就是MotionEvent.ACTION_MOVE。

mImageView.setOnTouchListener { _, event ->

    when (event.action and MotionEvent.ACTION_MASK) {

        MotionEvent.ACTION_POINTER_DOWN -> {

            // 记录双指按下的位置和距离

            startDistance = getDistance(event)

            if (startDistance > 10f) {

                startMatrix.set(mImageView.imageMatrix)

                mode = 2

            }

            return@setOnTouchListener true

        }

        MotionEvent.ACTION_MOVE -> {

            if (mode == 2) {

                // 双指缩放

                val currentDistance = getDistance(event)

                if (currentDistance > 10f) {

                    val scale = currentDistance / startDistance

                    mImageView.imageMatrix = startMatrix.apply {

                        postScale(scale, scale, getMidX(event), getMidY(event))

                    }

                }

            }

            return@setOnTouchListener true

        }

        MotionEvent.ACTION_POINTER_UP -> {

            mode = 0

            return@setOnTouchListener true

        }



        else -> return@setOnTouchListener true



    }



}

这里在move事件中我们也需要对手指之间的距离进行计算，如果距离超过10，就开始计算缩放倍数，通过postScale进行矩阵变换。
在MotionEvent.ACTION_POINTER_UP事件中对mode值进行复位操作，毕竟还有个单指拖动操作。
如果大家把上面的代码运行过就会发现怎么图片没有居中显示，这是因为我们的缩放属性被改为矩阵也就是android:scaleType="matrix"，那么想要图片居中显示怎么操作呢，只需要在触摸时去改变缩放属性，其他的时候不变即可。
我们把imageView恢复成android:scaleType="fitCenter"，在onTouchListener中加入(放在when前即可)

mImageView.scaleType = ImageView.ScaleType.MATRIX

这样一开始就可以保持图片在中央了。
这样缩放功能实现了，下面实现单指拖动功能，思路很简单记录第一次按下的位置，在移动过程中计算应该需要偏移的距离，再记录下当前的位置，以便于下次计算。

private var lastX = 0f

private var lastY = 0f

mImageView.setOnTouchListener { _, event ->

    mImageView.scaleType = ImageView.ScaleType.MATRIX

    when (event.action and MotionEvent.ACTION_MASK) {

        MotionEvent.ACTION_DOWN -> {

            // 记录单指按下的位置

            lastX = event.x

            lastY = event.y

            mode = 1

            startMatrix.set(mImageView.imageMatrix)

            return@setOnTouchListener true

        }

        MotionEvent.ACTION_POINTER_DOWN -> {

            // 记录双指按下的位置和距离

            startDistance = getDistance(event)

            if (startDistance > 10f) {

                startMatrix.set(mImageView.imageMatrix)

                mode = 2

            }

            return@setOnTouchListener true

        }

        MotionEvent.ACTION_MOVE -> {

            if (mode == 1) {

                // 单指拖动

                val dx = event.x - lastX

                val dy = event.y - lastY

                mImageView.imageMatrix = startMatrix.apply {

                    postTranslate(dx, dy)

                }

                lastX = event.x

                lastY = event.y

            } else if (mode == 2) {

                // 双指缩放

                val currentDistance = getDistance(event)

                if (currentDistance > 10f) {

                    val scale = currentDistance / startDistance

                    mImageView.imageMatrix = startMatrix.apply {

                        postScale(scale, scale, getMidX(event), getMidY(event))

                    }

                }

            }

            return@setOnTouchListener true

        }

        MotionEvent.ACTION_UP, MotionEvent.ACTION_POINTER_UP -> {

            mode = 0

            return@setOnTouchListener true

        }



        else -> return@setOnTouchListener true



    }



}

代码实现和思路一样，我们还需要在MotionEvent.ACTION_UP中复位模式，调用postTranslate进行偏移。
这样基本上功能我们都简单实现了。下面我们就需要优化了代码，如果各位跟着实现了，就会发现缩放倍数太大了导致轻轻动一下就会放很大，还有别的都是需要我们优化的。

三、功能优化

3.1 优化缩放倍数太大问题

其实这个问题和我们处理move事件有关系，熟悉Android事件机制都知道一个完整的事件流程就是down->move.....move->up。知道了这个之后，再仔细看我们的代码

val currentDistance = getDistance(event)

if (currentDistance > 10f) {

	val scale = currentDistance / startDistance

	mImageView.imageMatrix = startMatrix.apply {

		postScale(scale, scale, getMidX(event), getMidY(event))

	}

}

在move事件中我们这样处理的，计算缩放倍数然后缩放，大体一看是没有什么问题的。但是，我们的move事件不止执行一次，这就导致我们的缩放不止执行一次，每次都是在原来的基础上放大或者缩小。所以轻轻移动倍数就会很多。
最简单的办法就是我们记录一下move过程中累计的倍数，如果到达最大值或者最小值就不让放大或者缩小了。代码如下。

if (scale > 1.0f) {

	sumScale += scale

} else {

	sumScale -= scale

}

if (sumScale >= maxScale || sumScale <= minScale) {

	return@setOnTouchListener true

}

简单但是有效的方式。其中max和min，可以自己赋值。

3.2 保持原图不缩小

实现起来也很简单，需要先定义一个变量记录当前缩放之后的倍数。大家测试就会发现，如果是放大操作那么倍数就会大于1如果是缩小倍数就会比1 小。我们就可以利用这点来处理我们的逻辑。

private var lastScaleFactor = 1f

if (scale * lastScaleFactor > 1.0f) {

	if (sumScale >= maxScale || sumScale <= minScale) {

		return@setOnTouchListener true

	}

	sumScale += scale

	mImageView.imageMatrix = startMatrix.apply {

		postScale(scale, scale, getMidX(event), getMidY(event))

		lastScaleFactor *= scale

	}

} else {

	sumScale -= scale

}

demo在这里点我点我

tips：demo好像不是放大不是很顺畅，但是在项目里用Gilde加载后很流畅，猜测是照片大小问题。但是思路是一样的问题不大。

前言

注：只想看实现的朋友们可以直接跳到最后面的最终实现

大家是否还在为动态权限申请感到苦恼呢？传统的动态权限申请需要在Activity中重写onRequestPermissionsResult方法来接收用户权限授予的结果。试想一下，你需要在一个子模块中申请权限，那得从这个模块所在的Activity的onRequestPermissionsResult中将结果一层层再传回到这个模块中，相当的麻烦，代码也相当冗余和不干净，逼死强迫症。

使用

为了解决这个痛点，我封装出了两个方法，用于随时随地快速的动态申请权限，我们先来看看我们的封装方法是如何调用的：

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)

}

总结

其实很多实用技巧本质上都是很简单的，但没有接触过就很难想到，我将我的开发经验分享给大家，希望能帮助到大家。

1、外观配置

1.1 基本配置

图 1.1-1 修改更改主题 + 背景图片

如果IDEA版本是2023.1.2以后的版本可以开启 newUI 体验新版的UI界面，我个人是挺喜欢的🌝

1.2 快捷键配置

图1.2-1 修改快捷键

2、配置开发环境

2.1 配置GIT

图2.1-1配置git

2.2 配置maven

2.3 配置JDK

图 2.3-1 配置项目的JDK

配置项目的语言版本指的是设置 JDK 版本，比如有些比较老的项目需要JDK-6启动，此时不需要安装JDK-6，可以把语言版本设置为6即可运行项目。

3、编辑器设置

3.1 基本配置

图 3.1-1 代码补全提示去掉匹配规则

图 3.1-2 配置字体样式和大小

字体建议使用等宽字体，如 Consolas 或者 JetBrains Mono，最近英特尔开源的 intel-one-mono 字体也挺好用的，喜欢的话可以安装一下。

图3.1-3 配置行号显示和方法分割

3.3 编码风格配置

图 3.3-1 Java引入折叠

图 3.3-2 Java代码超字符数换行

3.4 配置代码模板

可以生成常见的代码模板，方便开发使用

1. 配置文件模板，如图3.4-1所示；


2. 配置文件的所有者信息，新建文件后会添加在类的头部，如图3.4-2所示；


3. 代码生成模板，输入关键词，点击回车后即可触发生成代码，配置如图 3.4-3所示，使用效果如图3.4-4所示；

图 3.4-1 文件生成模板

图 3.4-2 文件头设置

图 3.4-3 配置代码生成模板

代码生成模板建议建立新的分组后，在新的分组内编写代码生成模板。

图 3.4-4 代码模板使用效果

3.5 配置编辑器编码格式

建议都设置为 UTF-8 避免出现文件乱码问题

3.5-1 配置编辑器编码格式

3.6 配置忽略的文件和文件夹

建议在忽略文件和文件夹内配置IDEA编辑器生成的文件，防止git提交时提交IDEA配置文件被打🦉

图 3.6-1 配置忽略的文件和文件夹

4、好玩的插件

过年期间闲来没事，手撸了一个辅助Android开发调试的工具App，适合Android开发者和测试同学使用。

Github地址下载,
Gitee地址下载(需要登录gitee)

或者去Google Play安装

功能概览

对我这样的懒人开发者来说，反复的做同样一件事简直太煎熬了，因此我把我平时开发中需要反复操作的命令和一些繁琐的操作整理成了一个工具。

废话不多说, 先上图了解下工具的大概功能有哪些(内容比截图丰富，欢迎下载体验)

CodeCrafts的核心是一个可拖动的侧边栏的悬浮窗，悬浮窗可以折叠或展开，悬浮窗中包含5大块功能分别对应一个TAB, 这5大块功能分别是应用控制、开发者选项、常用功能，常用系统设置和全局功能

请看视频预览:

高清原图 introduction-floating-bar.gif

功能明细

1. 应用控制

应用控制能力将一些日常开发过程中对应用的一些繁琐的操作或者命令行指令转变为可视化的操作，而且还有自动收集和整理Crash， ANR日志，并且可以自动关联Logcat日志

文字太繁琐， 请直接看视频

高清原图 introduction-application-controls.gif

2. 开发者选项

这里的开发者选项功能是将系统的开发者选项中一些最常用的开关放在悬浮窗中， 随时启用或关闭。
优势是不需要频繁去系统的开发者选项中去找对应开关，一键开闭。

我调研了其他有类似能力的工具App,都是引导用户去开发者选项中去开启或关闭功能。CodeCrafts一键开闭，无需跳转到系统开发者选项页面。

请看视频预览:

p2.gif

3. 最常用功能

没什么好介绍的，略。

4. 常用系统设置页面

这里承载了一些开发过程中经常需要打开的系统设置页面的快捷按钮，没什么好介绍的，略

5. 全局功能

这里的全局是相对于应用控制的，应用控制可以选择你正在开发的任意一款App, 然后应用控制中的所有能力都是对你的这个App的操作。 而全局控制中的功能不针对选中的App，所有App都适用

5.1 实时数据(Realtime data)

实时数据会随着当前页面变化或者系统事件实时变化

(以上图为例介绍, 实时数据的内容不仅仅只有这些)

5.2 不锁定屏幕

不会进入锁屏状态，也不会灭屏，避免开发过程中老是自动锁屏。

和系统开发者选项中的功能类似，区别是无论是否插入USB线都有效，开发者选项中的拔掉USB线后就无效了。
都可以用，具体选择看你的使用场景。

5.3 Latest Crashes

显示缓存中最近发生的Crash的调用堆栈，可能为空也可能不止一个Crash堆栈， 需要自行查看是否是你关注的Crash。

使用说明

CodeCrafts的很多功能依赖Shell权限， 如果发现存在功能不可用的情况，一般都是shell权限获取失败了, 只需要通过在电脑终端输入adb命令"adb tcpip 5555"指令, CodeCrafts就可以自动获取shell权限了。

adb tcpip 5555

1. 第一次使用,连接电脑终端发送"adb tcpip 5555" 或


2. 手机断电重启，连接电脑终端发送"adb tcpip 5555" 或


3. 莫名其妙功能不能用了，连接电脑终端发送"adb tcpip 5555"

新增功能

有不少人反馈对CodeCrafts的实现原理感兴趣，后面新增的功能尽量配上实现原理

1. CodeCrafts之断点调试 (1.0.15新增)

建设中

1. 文件沙盒, 快速浏览App的文件目录


2. 自动化，自动化点击，输入(比如自动跳广告，自动输入账号密码?)


3. 组件检查， 快速查看View的类型, id, 颜色等


4. ...

后期规划

1. 悬浮窗的tab和内容可动态配置


2. 应用控制增加应用性能数据


3. 提供外部SDK接口，外部应用可接入CodeCrafts进行定制化改造

CodeCrafts持续更新中...

Github地址下载,
Gitee地址下载(需要登录gitee)

或者去Google Play安装

异步路由长啥样？

原理不做过多介绍（大家都知道），直接上代码了

一般来说，只有SPA需要异步路由。当配置了异步路由，通过split chunk，打包后都会生成单独的chunk，以webpack为例，建议添加魔法注释，并开启prefetch，以进一步提升体验

import loadable from '@loadable/component';



const XXXA = loadable(() => import('@/views/xx/XXXA'/* webpackChunkName: 'XXXA', webpackPrefetch: true  */));



const XXXB = loadable(() => import('@/views/xx/XXXB'/* webpackChunkName: 'XXXB', webpackPrefetch: true  */));



// ...



const allRoutes: IRoute[] = [

  {

    path: '/xxx-a',

    component: XXXA,

  },

  {

    path: '/xxx-b',

    component: XXXB,

  },

  // ...

];



// ...

SPA应用，白屏现象能不能解决？？

首先我们要搞明白的是，异步路由给我们解决的痛点是啥？

balabala....

Yes, 你打的很对👍🏾，就是为了缩减🐷包的大小，减少资源加载的时间。

但是，结合页面的加载过程，我先给您下个结论：

“SPA无论怎么优化，都无法避免白屏的现象产生，哪怕网速快，一闪而过（实际上你调成3g或带宽更低的网络，白屏一直伴随着你🤮）”

为啥🤬？

• SPA的入口是index.html, 初始dom，只有div#app，并且一般都没有任何样式


• 页面加载需要先加载必要js，比如main.[hash].js


• 当main.[hash].js加载并解析成功，页面才会正常展示，so，空档期一定存在，这就是白屏现象的原因所在（注意：此时和是否有其他路由没有任何关系）

为什么说异步路由不是100%保险？？

问题的根本在于这句话：异步路由能提升首屏用户体验 👀

但是，很多人不知道，这里的首屏并不是单指index.html，举个例子：

对于移动端混合应用开发，首屏可能变成SPA中的任何一个路由路径。原因也很简单，APP首页中有很多菜单：每个菜单都可以配置路径，这些路径很可能来自同一个SPA。 我们暂且把这些路径叫做一级路由（不包括index.html）

对于以上场景，首屏不再单一。

开始划重点

• 上述一级路由（不包括index.html）请不要配置成异步加载，使用普通的import即可, 让它打进主包中。


• 对于其他非一级路由，只是通过push、replace进行跳转，那么配置为异步路由就很合适

实际案例分析

还是先下个结论：

比如有个路由/xx-a，它作为一级路由配置在了APP菜单中，那么它就变成了"所谓的首屏页面"，如果我们还是使用异步路由，就会延长白屏的时间

import loadable from '@loadable/component';



const XxxA = loadable(() => import('@/views/xx/XxxA'/* webpackChunkName: 'XxxA', webpackPrefetch: true  */));



// ...



const allRoutes: IRoute[] = [

  {

    path: '/xxx-a',

    component: XXXA,

  },

  // ...

];



// ...

此时，build目录中存在

• main.[hash].js （包含react路由逻辑）


• XxxA.[hash].js

此时，打卡devtools，就会知道，network中资源加载顺序如下

0. index.html


1. main.js


2. 如果index.html中引入了其他资源, 比如jquery, lodash...，也会优先download这些资源（哪怕你配置的defer或者async）


3. 当main加载并执行后，才会触发路由逻辑，并开始加载XxxA.[hash].js


4. 加载XxxA.[hash].js成功，开始解析执行XxxA，XxxA页面才会被正常渲染

以上过程中，白屏的开始是main的加载和执行（包含了路由逻辑）的时间消耗产生的，而XxxA.[hash].js的加载解析和执行，又无疑增加了空档期，这样白屏时间也就被延长了

若index.html中引入了若干其他script资源，并且处于http1.1的服务器环境中，这个现象就会变得特别明显

• 因为1.1多路复用对于资源的请求数量有限制，chrome下6个作为一组。

我们可以借助network和performance进行实际演示说明：

为了演示，我们将网络调慢些（实际上客户的网络环境也有这样的情况）

network

后续每组都需等待前一组加载完成，才开始加载

只有main加载成功并执行，才会触发路由逻辑，从而开始加载XxxA脚本。如果网络慢，main.js加载过程就会更长，从而间接导致XxxA脚本的加载和解析执行被推迟, 这无疑也就延长了白屏时间！！🦮

performance截图 （异步路由）

performance截图 （非异步路由）

此时代码逻辑被打进了main.js中，直接第一波解析执行即可，很明显缩短了白屏时间。

对比一下，就可以一目了然，哎，什么也不说了～

总结

异步路由并不能100%缩短白屏时间，最关键的是我们要知道“首屏”这个词的意义，它并不是单指index.html入口，它可以是SPA中的任何一个路由（结合混合移动开发场景就知道了）

So：

• 如果SPA中的“首屏”只有一个，不存在移动混合开发场景或者路径分享场景(比如分享微信，支付宝等)，那所有路由都可以进行异步加载


• 如果存在移动混合开发场景或者路径分享场景，那对应的路由请不要异步加载，使用import即可。

好了，到此结束，如果对您有帮助，还望点个小💖💖

从输入 URL 到页面展示这中间到底发生了什么？，这是一道非常经典的面试题，这一过程涉及到了计算机网络、操作系统、Web等一系列知识，如果对这一过程有非常好的了解，对以后的开发甚至是程序的优化都是非常有益的。现将过程梳理如下：

1. 解析URL

分析所需要使用的传输协议和请求的资源路径。如果url中的协议或主机名不合法，将会把地址栏中输入的内容传递给搜索引擎，如果没有问题，浏览器会检查url中是否出现了非法字符，如果存在，对非法字符（空格、汉字等双字节字符）进行转义后在进行下一过程。

编码和解码：

• encodeURI()/decodeURI()：encodeURI()函数只会把参数中的空格编码为%20，汉字进行编码，其余特殊字符不会转换


• encodeURIComponent()/decodeURIComponent()：由于这个方法对:/都进行了编码，所以不能用它来对网址进行编码，适合对URL中的参数进行编码


• escape()/unescape()：将字符的unicode编码转化为16进制序列，不对ASCII字母和数字进行编码，也不会对' * @ - _ + . / '这些ASCII符号进行编码，用于服务器与服务器端传输多

let url = "http://www.baidu.com/test /中国"

console.log(encodeURI(url)); // http://www.baidu.com/test%20/%E4%B8%AD%E5%9B%BD

let url1 = `https://www.baidu.com/from=${encodeURIComponent('http://wwws.udiab.com')}`

console.log(url1); // https://www.baidu.com/from=http%3A%2F%2Fwwws.udiab.com

console.log(escape(url)); // http%3A//www.baidu.com/test%20/%u4E2D%u56FD

1.1 URL地址格式

传统格式：scheme://host:port/path?query#fragment。例：http://www.urltest.cn/system/user…

• scheme（必写）：协议。http（超文本传输协议）、https（安全超文本传输协议）、ftp（文件传输协议，用于将文件下载或上传至网站）、file（计算机上的文件）


• host（必写）：域名或IP地址


• port（可省略）：端口号,http默认80，https默认443


• path：路径，例如 /system/user


• query：参数，例如 username=falcon&age=18


• fragment：锚点（哈希hash），用于定位页面的某个位置

Restful格式：可以通过不同的请求方式（get、post、put、delete）来实现不同的效果

• （GET） http://www.webtest.com/users


• （POST） http://www.webtest.com/users


• （PUT） http:http://www.webtest.com/users/217


• （DELETE） http:http://www.webtest.com/users/217

2. 缓存判断

浏览器缓存就是浏览器将用户请求过的资源存储到本地电脑。当浏览器再次访问时就可以直接从本地加载，不需要去服务器请求，能有效减少不必要的数据传输，减轻服务器负担，提升网站性能，提高客户端网页打开速度。浏览器缓存一般分为强缓存和协商缓存

• 浏览器在请求某一资源时，会先获取该资源缓存的header信息，判断是否命中强缓存（cache-control、expires信息），命中则直接从缓存中获取资源信息，不会向服务器发起请求；


• 如果没有命中强缓存，浏览器会发送请求（携带该资源缓存的第一次请求返回的header字段信息，Last-Modified/If-Modified-Since、Etag/If-None-Match）到服务器，由服务器根据请求中携带的相关header字段进行对比来判断是否命中协商缓存，命中则返回新的header信息更新缓存中对应的header信息，不返回资源内容，浏览器直接从缓存中获取；否则返回最新的资源内容

2.1 强缓存

• expires,绝对时间字符串，发送请求在这个时间之前有效，之后无效

catch-control，几个比较常用的字段如下：

• max-age=number，相对字段，利用资源第一次请求时间和Cache-Control设定的有效期，计算出一个资源过期时间，然后再进行比较


• no-cache，不使用本地缓存，需要使用协商缓存


• no-store，禁止浏览器缓存数据，每次用户都需要向服务器发送请求获取完整资源


• public，可以被所有的用户缓存，包括终端用户和CDN等中间代理服务器


• private，只能被终端用户浏览器缓存

【注】

• 强缓存如何重新加载缓存过的资源？使用强缓存，不用向服务器发送请求就可以获取到资源，如果在强缓存期间，资源发生了变化，浏览器就一直得不到最新的资源，如何操作：通过更新页面中引用的资源路径，让浏览器主动放弃缓存，加载新的资源


• 如果二者同时存在，cache-control的优先级高于expires

2.2 协商缓存

Last-Modified/If-Modified-Since

• 浏览器第一次跟服务器请求一个资源，服务器在返回这个资源的同时，会在response的header上加上Last-Modified（表示资源在服务器上的最后修改时间）字段


• 浏览器再次跟服务器请求这个资源时，在request的header上加上If-Modified-Since（值就是上一次请求返回的Last-Modified值）字段，来判断是否发生变化，没变化返回304，从缓存中加载，也不会重新在response的header上添加Last-Modified；发生变化则直接从服务器加载，并且更新Last-Modified值

Etag/If-None-Match

• 这两个值是由服务器生成的每个资源的唯一标识字符串，只要资源变化值就会发生改变


• 判断过程与上面一组逻辑类似


• 不同的是，当服务器返回304时，由于Etag重新生成过，response的header还是会把这个Etag返回

【注】

• 为什么需要Etag？一些文件也许会周期性的更改，但是他的内容并不改变（仅仅改变修改时间）；某些文件修改非常频繁（例如在秒以下的时间进行修改）；某些服务器不能精确得到文件的最后修改时间等这些情况下，利用Etag能够更加精确的控制缓存


• 两者可以一起使用，服务器会优先验证Etag，在一致的情况下，才会继续比对Last-Modified

2.3 用户行为对缓存的影响

3. DNS解析

获取输入url中的域名对应的IP地址。

• 第一步，检查浏览器缓存中是否缓存过该域名对应的IP地址；


• 第二步，检查本地的hosts文件（系统缓存）；


• 第三步，本地域名解析服务器进行解析；


• 第四步，根域名解析服务器进行解析；


• 第五步，gTLD服务器进行解析（顶级域名）；


• 第六步，权威域名服务器进行解析，最终获得域名IP地址；

3.1 域名层级结构图

• 根域：位于域名空间最顶层，一般用一个点“.”表示


• 顶级域：一般表示一种类型的组织机构或者国家地区。.net(网络供应商) .com(工商企业) .org(团体组织) .edu(教育机构) .gov(政府部门) .cn(中国国家域名)


• 二级域：用来标明顶级域内一个特定的组织。.com.cn .net.cn .edu.cn


• 子域：二级域下所创建的各级域名，各个组织或用户可以自由申请注册


• 主机：位于域名空间最下层，一台具体的计算机。完整格式域：http://www.sina.com.cn

3.2 递归查询、迭代查询

用户向本地DNS服务器发起请求属于递归请求；本地DNS服务器向各级域名服务器发起请求属于迭代请求

• 递归查询：以本地DNS服务器为中心，客户端发出请求报文后就一直处于等待状态，直到本地DNS服务器发来最终查询结果


• 迭代查询：DNS服务器如有客户端请求数据则返回正确地址；没有则返回一个指针；按指针继续查询

4. TCP三次握手建立连接

• 第一步，客户端发送SYN包（seq=x）到服务器，等待服务器确认


• 第二步，服务器收到SYN包，确认客户的SYN（ack=x+1），同时自己也发送一个SYN包（seq=y），即SYN+ACK包


• 第三步，客户端收到SYN+ACK包，向服务器发送确认包ACK（ack=y+1）

三次握手完成，客户端和服务器正式开始传递数据

4.1 TCP、UDP

• TCP 面向连接的协议，只有建立后才可以传递数据


• UDP 无连接的协议，可以直接传送数据，传输效率较高，但不能保证数据的完整性

5. 发起http、https请求

5.1 http1.0、http1.1、http2.0区别

空

5.2 http、https

• https需要CA申请证书，一般需要交费


• http运行在TCP之上，明文传输；https运行在SSL/TLS之上，SSL/TLS运行在TCP之上，加密传输


• http默认端口80，https默认端口443


• https可以有效的防止运营商劫持

5.3 XSS、CSRF

XSS

XSS(Cross-site Scripting)。跨域脚本攻击，指通过利用网页开发时留下的漏洞，通过巧妙的方法注入恶意指令代码到网页，使用户加载并执行攻击者恶意制造的网页程序等。

分类如下：

• 反射型。发出请求时，xss代码出现在URL中，作为输入提交到服务器端，服务器端解析后响应，xss代码随响应内容一起传回浏览器，最后浏览器解析执行xss代码。例如："http://www.a.com/xss/reflect…"
  


• 存储型。和反射型的差别是提交的代码会存储在服务器端（数据库、内存、文件系统等），下次请求目标页面时不用再提交XSS代码。例如：留言板xss，用户提交留言到数据库，目标用户查看留言板时，留言的内容会从数据库查询出来并显示，浏览器解析执行，触发xss攻击


• DOM型。不需要服务器的参与，触发xss靠的是浏览器端的DOM解析，完全是客户端触发

防御措施：

• 过滤。对用户的输入（和URL参数）进行过滤。移除用户输入的和事件相关的属性，如onerror、onclick等；移除用户输入的Style节点、Script节点（一定要特别注意，它是支持跨域的）、Iframe节点


• 编码。对输出进行html编码。对动态输出到页面的内容进行html编码，使脚本无法再浏览器中执行


• 服务端设置会话Cookie的HTTP Only属性，这样客户端的JS脚本就不能获取cookie信息了

CSRF

CSRF(Cross-site request forgery)。跨站请求伪造，攻击者通过伪造用户的浏览器请求，向用户曾经认证访问过的网站发送出去，使目标网站接收并误以为是用户的真实操作而去执行命令。常用于转账、盗号、发送虚假消息等

防御措施：

• token验证。服务器返回给客户端一个token信息，客户端带着token发送请求，如果token不合法，服务器拒绝这个请求


• 隐藏令牌。将token隐藏在http的header中


• referer验证。页面请求来源验证，只接受本站的请求，其他进行拦截

5.4 get、post

GET

• 一般用于获取数据；


• 参数放在url中；


• 浏览器回退或刷新无影响；


• 请求可被缓存；


• 请求的参数放url上，有长度限制；


• 请求的参数只能是ASCII码；


• url对所有人可见，安全性差；


• get产生一个tcp数据包，hearder、data一起发送一次请求，服务器返回200

POST

• 一般用于向后台传递数据、创建数据；


• 参数放在body里；


• 浏览器回退或刷新数据会被需重提交；


• 请求不会被缓存；


• 请求的参数放body上，无长度限制；


• 请求的参数类型无限制，允许二进制数据；


• 请求参数不会被保存在浏览器历史或web服务器日志中，相对更安全；


• post产生两个tcp数据包，先发送header，返回100 continue，再发送data，服务器返回200，但不是绝对的，Firefox只发送一次

5.5 状态码

1XX - 通知

• 100 -- 客户端继续发送请求


• 101 -- 切换协议

2XX - 成功

• 200 -- 请求成功，一般应用与 get 或 post 请求


• 201 -- 请求成功并创建新的资源，

3XX - 重定向

• 301 -- 永久移动，请求的资源已被永久移动到新的 url，返回信息包括新的 url，浏览器会自动定向到新的 url，今后所有的请求都是新的 url


• 302 -- 临时移动，资源只是临时移动，客户端应继续使用旧的 url


• 304 -- 所请求的资源未修改，不会返回任何资源。浏览器请求的时候，会先访问强缓存，没有则访问协商缓存，协商缓存命中，资源未修改，返回 304

4XX - 客户端错误

• 400 -- 客户端请求的语法错误，服务器无法理解（z 字段类型，或对应的值类型不一致；或者没有进行 JSON.toStringfy 的转换）


• 401 -- 请求需要用户的认证


• 403 -- 服务器理解客户端请求，但是拒绝执行


• 404 -- 服务器无法根据客户端的请求找到资源

5XX - 服务器端错误

• 500 -- 服务器内部错误，无法完成资源的请求


• 501 -- 服务器不支持请求功能，无法完成资源请求


• 502 -- 网关或代理服务器向远程服务器发送请求返回无效

5.6 跨域

• 跨域：浏览器不能执行其他网站的脚本，这是由于同源策略（同协议、同域名、同端口）限制造成的


• 同源策略限制的行为：cookie，localstorage和IndexDB无法读取；DOM无法获取；Ajax请求不能发送

跨域的几种解决方式：

• jsonp,实现原理是<script>标签的src可以发跨域请求，不受同源策略限制，缺点是只能实现get一种请求


• document.domain + iframe跨域domain属性可返回下载当前文档的服务器域名，此方案仅限主域相同，子域不同的跨域场景


• 跨域资源共享（CORS）只服务端设置Access-Control-Allow-Origin即可，前端无需设置；若要带cookie请求，前后端都需要设置


• nginx反向代理跨域,项目中常用的一种方案


• html5的postMessage（跨文档消息传输），WebSocket（全双工通信、实时通信）

6. 返回数据

当页面请求发送到服务器端后，服务器端会返回一个html文件作为响应

7. 页面渲染

7.1 加载过程

• HTML会被渲染成DOM树。HTML是最先通过网址请求过来的，请求过来之后，HTML本身会由一个字节流转化成一个字符流，浏览器端拿到字符流，之后通过词法分析，将相应的词法分析成相应的token，转化不同的token tag，然后通过token类型append到DOM树


• 遇到link token tag，去请求css，然后对css进行解析，生成CSSOM树


• DOM树和CSSOM树结合形成Render Tree，再进行布局和渲染


• 遇到script tag，然后去请求JS相关的web资源，请求回来的js交给浏览器的v8引擎进行解析
  

7.2 加载特点

• html文档解析，对tag依次从上到下解析，顺序执行


• html中可能会引入很多css,js的web资源，这些资源在浏览器中是并发加载的。


• DOM树和CSSOM树通常是并行构建的， 所以CSS加载不会阻塞DOM的解析；Render树依赖DOM树和CSSOM树进行，所以CSS加载会阻塞DOM的渲染；css会阻塞js文件执行，但不会阻塞js文件下载，因为GUI渲染线程与JavaScript线程互斥,JS有可能影响样式;js会阻塞DOM的解析（把js文件放在最下面），也就会阻塞DOM的渲染,同时js顺序执行，也会阻塞后续js逻辑的执行


• 依赖关系。页面渲染依赖于css的加载；js的执行顺序依赖关系；js逻辑对于dom节点的依赖关系，有些js需要去获取dom节点


• 引入方式。直接引入，不会阻塞页面渲染；defer不会阻塞页面渲染，顺序执行；async不会阻塞页面渲染，先到先执行，不保证顺序；异步动态js，需要的时候引入

【注】css样式置顶；js脚本置底；用link代替import；合理使用js异步加载

资源加载完成后，通过样式计算、布局设置、分层、绘制等过程，将页面呈现出来

7.3 重绘回流

根据渲染树，浏览器可以计算出网页中有哪些节点，各节点的CSS以及从属关系，发生回流；根据渲染树以及回流得到的节点信息，计算出每个节点在屏幕中的位置，发生重绘

• 元素的规模尺寸、布局、显隐性发生变化时，发生回流，每个页面至少产生一次回流，第一次加载


• 元素的外观、风格、颜色等发生变化而不影响布局，发生重绘


• 回流一定发生重绘，重绘不一定发生回流

【避免措施】

样式设置

• 避免使用层级较深的选择器


• 避免使用 css 表达式


• 元素适当的定义高度或最小高度


• 给图片设置尺寸


• 不要使用 table 布局


• 能 css 实现的，尽量不要使用 js 实现

渲染层

• 将需要多次重绘的元素独立为 render layer，如设置 absolute，可以减少重绘范围


• 对于一些动画元素，使用硬件渲染

DOM 优化

• 缓存 DOM


• 减少 DOM 深度及 DOM 数量


• 批量操作 DOM


• 批量操作 CSS 样式


• 在内存中操作 DOM


• DOM 元素离线更新


• DOM 读写分离


• 事件代理


• 防抖和节流


• 及时清理环境

TCP四次挥手断开连接

• 客户端发送一个FIN（seq=u）数据包到服务器，用来关闭客户端到服务器的数据连接


• 服务器接受FIN数据包，发送ACK（seq=u+1）数据包到客户端


• 服务器关闭与客户端的连接并发送一个FIN（seq=w）数据包到客户端，请求关闭连接


• 客户端发送ACK（seq=w+1）数据包到服务器，服务器在收到ACK数据包后进行CLOSE状态，客户端在一定时间没有收到服务器的回复证明其关闭后，也进入关闭状态

VUE是一款用于构建用户界面的 JavaScript 框架。它基于标准 HTML、CSS 和 JavaScript 构建，并提供了一套声明式的、组件化的编程模型。

个人学习感受：构建模板，通过数据就可以生成展示的html，上手简单，快速。

引用：VUE官网

• 声明式渲染：Vue 基于标准 HTML 拓展了一套模板语法，使得我们可以声明式地描述最终输出的 HTML 和 JavaScript 状态之间的关系。


• 响应性：Vue 会自动跟踪 JavaScript 状态并在其发生变化时响应式地更新 DOM。

开始：

1.安装环境

1.node.js (已安装 16.0 或更高版本的 Node.js)

说明：Node.js是一种基于Chrome V8引擎的JavaScript运行环境，是一个可以在服务器端运行JavaScript的开源工具。
NodeJS已经集成了npm，所以npm也一并安装好了。
验证测试： node -v npm -v

2.cnpm

说明 ：由于npm的服务器在海外，所以访问速度比较慢，访问不稳定 ，cnpm的服务器是由淘宝团队提供 服务器在国内cnpm是npm镜像。但是一般cnpm只用于安装时候，所以在项目创建与卸载等相关操作时候我们还是使用npm。

全局安装cnpm

npm install -g cnpm --registry=https://registry.npm.taobao.org

验证测试： cnpm -v

1.IDE与简单上手

1.IDE:webstorm

说明：我个人一直在用jetbrains 旗下的各种 IDA ，我使用起来比较熟练。

配置IDE：

2.简单上手：

到需要创建项目的文件目录

npm init vue@latest

这一指令将会安装并执行 create-vue，它是 Vue 官方的项目脚手架工具。你将会看到一些诸如 TypeScript 和测试支持之类的可选功能提示：

如果不确定是否要开启某个功能，你可以直接按下回车键选择 No。在项目被创建后，通过以下步骤安装依赖并启动开发服务器：

之后执行：

npm install

执行完安装后执行启动：

npm run dev

执行成功： 打开网页 http://localhost:5173/

当你准备将应用发布到生产环境时，请运行：

npm run build

此命令会在 ./dist 文件夹中为你的应用创建一个生产环境的构建版本。

简单例子 与 说明：

<script setup>  

defineProps({  

    msg: {  

    type: String,  

    required: true  

    }  

})  

</script>  

  

  <!--模板区域-->

<template>  

    <div class="greetings">  

        <h1 class="green">{{ msg }}</h1>  

        <h3>  You’ve successfully created a project with  <a href="https://vitejs.dev/" target="_blank" rel="noopener">Vite</a> +  <a href="https://vuejs.org/" target="_blank" rel="noopener">Vue 3</a>.  

        </h3>  

    </div>  

</template>  

<!--样式区域-->

<style scoped>  

h1 {  

    font-weight: 500;  

    font-size: 2.6rem;  

    position: relative;  

    top: -10px;  

}  

</style>

大喊一声Fuck！代码就能跑了是什么体验？

1 前言

大家好，我是心锁，23届准毕业生。

程序员的世界，最多的不是代码，而是💩山和bug。

近期我在学习过程中，在github找到了这么一个项目，能在我们输错命令之后，大喊一声Fuck即可自动更正命令，据说喊得越大声效果越好。

2 项目基本介绍

thefuck是一个基于Python编写的项目，它能够自动纠正你在命令行中输入的错误命令。如果你输错了一个命令，只需要在命令行中输入“fuck”，thefuck就会自动纠正你的错误。该项目支持众多的终端和操作系统，包括Linux、macOS和Windows。

2.1 环境要求

• python环境（3.4+）

2.2 安装方式

thefuck支持brew安装，非常方便，在macOS和Linux上都可以通过brew安装。

brew install thefuck

也支持通过pip安装，便携性可以说是一流了。

pip3 install thefuck

2.3 配置环境变量

建议将下边的代码配置在环境变量中（.bash_profile、.bashrc或.zshrc），不要问为什么，问就是有经验。

eval $(thefuck --alias)

eval $(thefuck --alias FUCK)

eval $(thefuck --alias fuck?)

eval $(thefuck --alias fuck？)

接着运行source ~/.bashrc（或其他配置文件，如.zshrc）确认更改立即可用。

3 使用效果

4 thefuck的工作原理

thefuck的工作原理非常简单。当你输入一个错误的命令时，thefuck会根据你输入的命令和错误提示自动推测你想要输入的正确命令，并将其替换为正确的命令。thefuck能够自动推测正确的命令是因为它内置了大量的规则，这些规则能够帮助thefuck智能地纠正错误的命令。

所以，该项目开放了自定义规则。

4.1 创建自己的规则

如果thefuck内置的规则不能够满足你的需求，你也可以创建自己的规则。thefuck的规则是由普通的Python函数实现的。你可以在~/.config/thefuck/rules目录下创建一个Python脚本，然后在其中定义你的规则函数。

以创建一个名为my_rule的规则为例，具体步骤如下：

4.1.1 创建rule.py文件

在~/.config/thefuck/rules目录下创建一个Python脚本，比如my_rules.py

4.1.2 遵循的规则

在自定义脚本中，必须实现以下两个函数，match显然是用来匹配命令是否吻合的函数，而get_new_command则会在match函数返回True时触发。

match(command: Command) -> bool

get_new_command(command: Command) -> str | list[str]

同时可以包含可选函数，side_effect的作用是开启一个副作用，即除了允许原本的命令外，你可以在side_effect做更多操作。

side_effect(old_command: Command, fixed_command: str) -> None

5 yarn_uninstall_to_remove

以创建一个名为yarn_uninstall_to_remove的规则为例，该规则会在我们错误使用yarn uninstall …命令时，自动帮助我们修正成yarn remove … 。具体步骤如下：

5.1 创建yarn_uninstall_to_move.py文件

在~/.config/thefuck/rules目录下创建一个Python脚本，yarn_uninstall_to_remove.py

5.2 编写代码

from thefuck.utils import for_app



@for_app('yarn')

def match(command):

    return 'uninstall' in command.script



def get_new_command(command):

    return command.script.replace('uninstall', 'remove')



priority=1 # 优先级，数字越小优先级越高

5.3 效果

6 总结

世界之大，无奇不有。不得不说的是，伴随着AI的逐渐发展，类似这种项目未来一定是优先接入AI者才可以继续发展。

友情提示，喊fuck的时候先设置后双击control打开听写功能，喊完再点击一下control完成输入。

在Android开发中，我们总是会碰到各种各样的适配问题。如果要解决适配问题，我们必须就要解决，出现问题的是什么机型？出现问题的是什么系统？怎么判断当前机型是不是出问题的机型？这几个问题。这篇文章，就将介绍如何判断机型和系统，介绍目前应该如何解决这些问题。

判断指定的机型

在Android里面可以通过 android.os.Build这个类获取相关的机型信息，它的参数如下：（这里以一加的手机为例）

Build.BOARD = lahaina

Build.BOOTLOADER = unknown

Build.BRAND = OnePlus //品牌名

Build.CPU_ABI = arm64-v8a

Build.CPU_ABI2 = 

Build.DEVICE = OP5154L1

Build.DISPLAY = MT2110_13.1.0.100(CN01) //设备版本号

Build.FINGERPRINT = OnePlus/MT2110_CH/OP5154L1:13/TP1A.220905.001/R.1038728_2_1:user/release-keys

Build.HARDWARE = qcom

Build.HOST = dg02-pool03-kvm97

Build.ID = TP1A.220905.001

Build.IS_DEBUGGABLE = false

Build.IS_EMULATOR = false

Build.MANUFACTURER = OnePlus //手机制造商

Build.MODEL = MT2110 //手机型号

Build.ODM_SKU = unknown

Build.PERMISSIONS_REVIEW_REQUIRED = true

Build.PRODUCT = MT2110_CH //产品名称

Build.RADIO = unknown

Build.SERIAL = unknown

Build.SKU = unknown

Build.SOC_MANUFACTURER = Qualcomm

Build.SOC_MODEL = SM8350

Build.SUPPORTED_32_BIT_ABIS = [Ljava.lang.String;@fea6460

Build.SUPPORTED_64_BIT_ABIS = [Ljava.lang.String;@3a22d19

Build.SUPPORTED_ABIS = [Ljava.lang.String;@2101de

Build.TAGS = release-keys

Build.TIME = 1683196675000

Build.TYPE = user

Build.UNKNOWN = unknown

                                                                            Build.USER = root

其中重要的属性已经设置了注释，所有的属性可以看官方文档。在这些属性中，我们一般使用 Build.MANUFACTURER 来判断手机厂商，使用 Build.MODEL 来判断手机的型号。

tips: 如果你是使用kotlin开发，可以使用 android.os.Build::class.java.fields.map { "Build.${it.name} = ${it.get(it.name)}"}.joinToString("\n") 方便的获取所有的属性

上面的获取机型的代码在鸿蒙系统（HarmonyOS）上也同样适用，下面是在华为P50 Pro的机型上测试打印的日志信息：

Build.BOARD = JAD

Build.BOOTLOADER = unknown

Build.BRAND = HUAWEI

Build.CPU_ABI = arm64-v8a

Build.CPU_ABI2 = 

Build.DEVICE = HWJAD

Build.DISPLAY = JAD-AL50 2.0.0.225(C00E220R3P4)

Build.FINGERPRINT = HUAWEI/JAD-AL50/HWJAD:10/HUAWEIJAD-AL50/102.0.0.225C00:user/release-keys

Build.FINGERPRINTEX = HUAWEI/JAD-AL50/HWJAD:10/HUAWEIJAD-AL50/102.0.0.225C00:user/release-keys

Build.HARDWARE = kirin9000

Build.HIDE_PRODUCT_INFO = false

Build.HOST = cn-east-hcd-4a-d3a4cb6341634865598924-6cc66dddcd-dcg9d

Build.HWFINGERPRINT = ///JAD-LGRP5-CHN 2.0.0.225/JAD-AL50-CUST 2.0.0.220(C00)/JAD-AL50-PRELOAD 2.0.0.4(C00R3)//

Build.ID = HUAWEIJAD-AL50

Build.IS_CONTAINER = false

Build.IS_DEBUGGABLE = false

Build.IS_EMULATOR = false

Build.IS_ENG = false

Build.IS_TREBLE_ENABLED = true

Build.IS_USER = true

Build.IS_USERDEBUG = false

Build.MANUFACTURER = HUAWEI

Build.MODEL = JAD-AL50

Build.NO_HOTA = false

Build.PERMISSIONS_REVIEW_REQUIRED = true

Build.PRODUCT = JAD-AL50

Build.RADIO = unknown

Build.SERIAL = unknown

Build.SUPPORTED_32_BIT_ABIS = [Ljava.lang.String;@a90e093

Build.SUPPORTED_64_BIT_ABIS = [Ljava.lang.String;@8ce98d0

Build.SUPPORTED_ABIS = [Ljava.lang.String;@366a0c9

Build.TAGS = release-keys

Build.TIME = 1634865882000

Build.TYPE = user

Build.UNKNOWN = unknown

判断手机厂商的代码如下：

//是否是荣耀设备

fun isHonorDevice() = Build.MANUFACTURER.equals("HONOR", ignoreCase = true)

//是否是小米设备

fun isXiaomiDevice() = Build.MANUFACTURER.equals("Xiaomi", ignoreCase = true)

//是否是oppo设备

//realme 是oppo的海外品牌后面脱离了；一加是oppo的独立运营品牌。因此判断

//它们是需要单独判断

fun isOppoDevice() = Build.MANUFACTURER.equals("OPPO", ignoreCase = true)

//是否是一加手机

fun isOnePlusDevice() = Build.MANUFACTURER.equals("OnePlus", ignoreCase = true)

//是否是realme手机

fun isRealmeDevice() = Build.MANUFACTURER.equals("realme", ignoreCase = true)

//是否是vivo设备

fun isVivoDevice() = Build.MANUFACTURER.equals("vivo", ignoreCase = true)

//是否是华为设备

fun isHuaweiDevice() = Build.MANUFACTURER.equals("HUAWEI", ignoreCase = true)

需要判断指定的型号的代码如下：

//判断是否是小米12s的机型

fun isXiaomi12S() = isXiaomiDevice() && Build.MODEL.contains("2206123SC") //xiaomi 12s

如果你不知道对应机型的型号，可以看基于谷歌维护的表格，支持超过27,000台设备。如下图所示：

判断手机的系统

除了机型外，适配过程中我们还需要考虑手机的系统。但是相比于手机机型，手机的系统的判断就没有统一的方式。下面介绍几个常用的os的判断

● 鸿蒙

private static final String HARMONY_OS = "harmony";

/**

* check the system is harmony os

*

* @return true if it is harmony os

*/

public static boolean isHarmonyOS() {

    try {

        Class clz = Class.forName("com.huawei.system.BuildEx");

        Method method = clz.getMethod("getOsBrand");

        return HARMONY_OS.equals(method.invoke(clz));

    } catch (ClassNotFoundException e) {

        Log.e(TAG, "occured ClassNotFoundException");

    } catch (NoSuchMethodException e) {

        Log.e(TAG, "occured NoSuchMethodException");

    } catch (Exception e) {

        Log.e(TAG, "occur other problem");

    }

    return false;

}

● Miui

fun checkIsMiui() = !TextUtils.isEmpty(getSystemProperty("ro.miui.ui.version.name"))



private fun getSystemProperty(propName: String): String? {

    val line: String

    var input: BufferedReader? = null

    try {

        val p = Runtime.getRuntime().exec("getprop $propName")

        input = BufferedReader(InputStreamReader(p.inputStream), 1024)

        line = input.readLine()

        input.close()

    } catch (ex: IOException) {

        Log.i(TAG, "Unable to read sysprop $propName", ex)

        return null

    } finally {

        if (input != null) {

            try {

                input.close()

            } catch (e: IOException) {

                Log.i(TAG, "Exception while closing InputStream", e)

            }

        }

    }

    return line

}

● Emui 或者 Magic UI

Emui是2018之前的荣耀机型的os，18年之后是 Magic UI。历史关系如下图所示：

判断的代码如下。需要注意是对于Android 12以下的机型，官方文档并没有给出对于的方案，下面代码的方式是从网上找的，目前测试了4台不同的机型，均可正在判断。

fun checkIsEmuiOrMagicUI(): Boolean {

    return if (Build.VERSION.SDK_INT >= 31) {

        //官方方案，但是只适用于api31以上（Android 12）

        try {

            val clazz = Class.forName("com.hihonor.android.os.Build")

            Log.d(TAG, "clazz = " + clazz)

            true

        }catch (e: ClassNotFoundException) {

            Log.d(TAG, "no find class")

            e.printStackTrace()

            false

        }

    } else {

        //网上方案，测试了 荣耀畅玩8C

        // 荣耀20s、荣耀x40 、荣耀v30 pro 四台机型，均可正常判断

        !TextUtils.isEmpty(getSystemProperty("ro.build.version.emui"))

    }

}

● Color Os

下面是网上判断是否是Oppo的ColorOs的代码。经测试，在 OPPO k10 、 oppo findx5 pro、 oneplus 9RT 手机上都是返回 false，只有在 realme Q3 pro 机型上才返回了 true。

//这段代码是错的

fun checkIsColorOs() = !TextUtils.isEmpty(getSystemProperty("ro.build.version.opporom"))

从测试结果可以看出上面这段代码是错的，但是在 ColorOs 的官网上，没有找到如何判断ColorOs的代码。这种情况下，有几种方案：

1.  判断手机制造商，即 Build.MANUFACTURER 如果为 oneplus、oppo、realme就认为它是ColorOs

2.  根据系统应用的包名判断，即判断是否带有 com.coloros.* 的系统应用，如果有，就认为它是ColorOs

这几种方案都有很多问题，暂时没有找到更好的解决方法。

● Origin Os

//网上代码，在 IQOQ Neo5、vivo Y50、 vivo x70三种机型上

//都可以正常判断

fun checkIsOriginOs() = !TextUtils.isEmpty(getSystemProperty("ro.vivo.os.version"))

总结

对于手机厂商和机型，我们可以通过Android原生的 android.os.Build  类来判断。使用 Build.MANUFACTURER 来判断手机厂商，使用 Build.MODEL 来判断手机的型号。如果是不知道的型号，还可以尝试在谷歌维护的手机机型表格中查询。

但是对于厂商的系统，就没有统一的判断方法了。部分厂商有官方提供的判断方式，如Miui、Magic UI；部分厂商暂时没有找到相关的内容。这种情况下，只能通过网上的方式判断，但是部分内容也不靠谱，如判断Oppo的ColorOs。如果你有靠谱的方式，欢迎补充。

简述

要启动未注册的Activity主要是要逃避AMS的检测，思路是，检测前要启动的Activity换成注册的，检测通过了，再在启动前换回来。这里主要是两个点。检测前，hookAMS。检测后hookHandler。hook点有很多尽量找静态变量、单例和public

hookAMS

1、android 11举例，启动acitivty是在ATMS中（11之前是AMS，这个自己可以去适配）

2、拿到ATMS的代理。

3、然后ATMS整个动态代理在startActivity之前将Intent 偷梁换柱

4、换成已经注册的Activity之后记得原目标Acitivty存起来，在骗完AMS之后换回来

 

public static void hookAMS() {

    // 10之前

    try {

        Class<?> clazz = Class.forName("android.app.ActivityTaskManager");

        Field singletonField = clazz.getDeclaredField("IActivityTaskManagerSingleton");



        singletonField.setAccessible(true);

        Object singleton = singletonField.get(null);









        Class<?> singletonClass = Class.forName("android.util.Singleton");

        Field mInstanceField = singletonClass.getDeclaredField("mInstance");

        mInstanceField.setAccessible(true);

        Method getMethod = singletonClass.getMethod("get");

        Object mInstance = getMethod.invoke(singleton);



        Class IActivityTaskManagerClass = Class.forName("android.app.IActivityTaskManager");



        Object mInstanceProxy = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),

                new Class[]{IActivityTaskManagerClass}, new InvocationHandler() {

                    @Override

                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {



                        if ("startActivity".equals(method.getName())) {

                            int index = -1;



                            // 获取 Intent 参数在 args 数组中的index值

                            for (int i = 0; i < args.length; i++) {

                                if (args[i] instanceof Intent) {

                                    index = i;

                                    break;

                                }

                            }

                            // 生成代理proxyIntent -- 孙悟空（代理）的Intent

                            Intent proxyIntent = new Intent();

                            // 这个包名是宿主的

                            proxyIntent.setClassName("com.leo.amsplugin",

                                    ProxyActivity.class.getName());



                            // 原始Intent能丢掉吗？保存原始的Intent对象

                            Intent intent = (Intent) args[index];

                            proxyIntent.putExtra(TARGET_INTENT, intent);



                            // 使用proxyIntent替换数组中的Intent

                            args[index] = proxyIntent;

                        }



                        // 原来流程

                        return method.invoke(mInstance, args);

                    }

                });



        // 用代理的对象替换系统的对象

        mInstanceField.set(singleton, mInstanceProxy);

    } catch (Exception e) {

        e.printStackTrace();

    }

}

hookHandler

hookAMS完成，欺骗了AMS，接下来要把Intent中的原目标扶起回正位，
启动Activity要用handler，我们从这里hook吧

1、Activtiy thread 中的handler用来启动activity class H extends Handler

2、handlerMessage中的EXECUTE_TRANSACTION(159)来启动activity

3、
final ClientTransaction transaction = (ClientTransaction) msg.obj;--包含Intent

mTransactionExecutor.execute(transaction);--执行启动

launchActivityItem中有Intent，而ta继承于ClientTransactionItem，而ClientTransaction中包含List<ClientTransactionItem>

4、所以我只要拿到msg就可以拿到Intent。
msg.obj --> ClientTransaction --> List mActivityCallbacks(LaunchActivityItem)
--> private Intent mIntent 替换