注册
环信即时通讯云

环信即时通讯云

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

环信开发文档

Demo体验

Demo体验

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

RTE开发者社区

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

技术讨论区

技术交流、答疑
资源下载

资源下载

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

iOS Library

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

Android Library

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

iOS之手写单例

一、 不严谨写法先附上不严谨的创建单例的写法SignalModel.h@interface SignalModel : NSObject+ (instancetype)shareInstance;@endSignalModel.m@implementation...
继续阅读 »

一、 不严谨写法

先附上不严谨的创建单例的写法

  • SignalModel.h
@interface SignalModel : NSObject
+ (instancetype)shareInstance;
@end
  • SignalModel.m
@implementation SignalModel

+ (instancetype)shareInstance {
static SignalModel *_instance = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
_instance = [[SignalModel alloc] init];
});
return _instance;
}

外界使用

SignalModel *signal1 = [[SignalModel alloc] init];
SignalModel *signal2 = [SignalModel shareInstance];
SignalModel *signal3 = [SignalModel shareInstance];
NSLog(@"\nsignal1 = %@\nsignal2 = %@\nsignal3 = %@\n",signal1,signal2,signal3);

打印结果


1. 通过上面的测试,可以看到通过shareInstance方法获取的对象是相同的,但是用alloc和init构造对象时,得到的对象却是不一样的。

2. 通过不同的方式获得不同的对象,是有问题的,所以要封锁初始化的方式,如alloc,copy,mutableCopy,new

摘抄的原理哈
创建对象的步骤分为申请内存(alloc)、初始化(init)这两个步骤,我们要确保对象的唯一性,因此在第一步这个阶段我们就要拦截它。当我们调用alloc方法时,OC内部会调用allocWithZone这个方法来申请内存,我们覆写这个方法,然后在这个方法中调用shareInstance方法返回单例对象,这样就可以达到我们的目的。拷贝对象也是同样的原理,覆写copyWithZone方法,然后在这个方法中调用shareInstance方法返回单例对象

二、正确写法

  • SignalModel.m
// 实现copy协议
@interface SignalModel()<NSCopying, NSMutableCopying>

@end

+ (instancetype)shareInstance {
static SignalModel *_instance = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
_instance = [[super allocWithZone:NULL] init];
});
return _instance;
}

+ (instancetype)allocWithZone:(struct _NSZone *)zone {
return [self shareInstance];
}

- (id)copyWithZone:(NSZone *)zone {
return self;
}

- (id)mutableCopyWithZone:(NSZone *)zone {
return self;
}

1. shareInstance单例方法中,变量的初始化改成[[super allocWithZone:NULL] init]

2. 实现copyWithZone:和mutableCopyWithZone:方法

测试代码

SignalModel *signal1 = [[SignalModel alloc] init];
SignalModel *signal2 = [SignalModel shareInstance];
SignalModel *signal3 = [SignalModel shareInstance];
SignalModel *signal4 = [SignalModel new];
SignalModel *signal5 = [signal1 copy];
SignalModel *signal6 = [signal2 mutableCopy];

NSLog(@"\nsignal1 = %@\nsignal2 = %@\nsignal3 = %@\nsignal4 = %@\nsignal5 = %@\nsignal6 = %@",signal1,signal2,signal3,signal4,signal5,signal6);

打印结果


无论通过哪种方式创建出来的实例对象,其内存地址都是一样的,所以该种写法才是严谨的。

转自:https://juejin.cn/post/6844903806027694087


收起阅读 »

AdapterViewFlipper 图片/文字 轮播动画控件

1. 问题/坑点 1.1 item宽高不生效问题 需要注意的是,AdapterViewFlipper 在布局时,宽高一定要用 match_parent 或者 具体dp值。 如果宽、高中使用了 wrap_content 时,会导致 AdapterViewFlip...
继续阅读 »

1. 问题/坑点


1.1 item宽高不生效问题


需要注意的是,AdapterViewFlipper 在布局时,宽高一定要用 match_parent 或者 具体dp值


如果宽、高中使用了 wrap_content 时,会导致 AdapterViewFlipper 容器的宽高,最终变成第一个item的宽高。即使后续item的宽高超过第一个item,也不会生效,内容显示只会被限定在第一个的宽高范围内


原理也很好理解,后续item没有绘制出来时, wrap_content 计算出来的结果,就是第一个item的宽高。当后续 item 显示的时候,没有地方去重新更新父容器 AdapterViewFlipper 的宽高。


2. 常用方法




  1. AdapterViewAnimator支持的XML属性如下:



    • android:animateFirstView:设置显示组件的第一个View时是否使用动画。

    • android:inAnimation:设置组件显示时使用的动画。

    • android:loopViews:设置循环到最后一个组件时是否自动跳转到第一个组件。

    • android:outAnimation:设置组件隐藏时使用的动画。




  2. 轮播控制:



    • startFlippingstopFlipping : 开始、停止播放

    • showPreviousshowNext:上一个、下一个




  3. 轮播状态与参数



    • isFlipping:是否轮播中

    • flipInterval: 动画间隔




  4. 设置入场、出场动画:setInAnimationsetOutAnimation




3. 文字/图片 轮播 Demo



/**
* 图片/文字轮播
* 坑点:text_flipper height 如果设置wrap_content 导致item宽度只会以第一个item的为准
*/
class FlipperAnimActivity : AppCompatActivity(), View.OnClickListener {

private var textFlipper: AdapterViewFlipper? = null
private var imgFlipper: AdapterViewFlipper? = null
private var preBtn: Button? = null
private var nextBtn: Button? = null
private var autoBtn: Button? = null

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_flipper_anim)
initTextFlipper()
initImgFlipper()
}

// 文字轮播
private fun initTextFlipper() {
textFlipper = findViewById(R.id.text_flipper)
val list = listOf("文字轮播测试0", "文字轮播测试02...")
textFlipper?.adapter = TextFlipperAdapter(this, list)
textFlipper?.setInAnimation(this, R.animator.text_flipper_in_from_bottom)
textFlipper?.setOutAnimation(this, R.animator.text_flipper_out_to_top)
// textFlipper?.flipInterval
// textFlipper?.startFlipping()
}

// 图片轮播
private fun initImgFlipper() {
imgFlipper = findViewById(R.id.img_flipper)
val list = listOf("http://www.nicesoso.com/test/file/img/test.jpg", "http://www.nicesoso.com/test/file/img/test_h_1.jpg",
"http://www.nicesoso.com/test/file/img/test_h_2.jpg")
imgFlipper?.adapter = ImgFlipperAdapter(this, list)
imgFlipper?.setInAnimation(this, R.animator.img_flipper_in)
preBtn = findViewById(R.id.prev_btn)
nextBtn = findViewById(R.id.next_btn) as Button
autoBtn = findViewById(R.id.auto_btn) as Button

preBtn?.setOnClickListener(this)
nextBtn?.setOnClickListener(this)
autoBtn?.setOnClickListener(this)
}

override fun onClick(v: View?) {
when (v?.id) {
R.id.prev_btn -> {
imgFlipper?.showPrevious()
imgFlipper?.stopFlipping()
}
R.id.next_btn -> {
imgFlipper?.showNext()
imgFlipper?.stopFlipping()
}
R.id.auto_btn -> {
imgFlipper?.startFlipping()
}
}
}

override fun onDestroy() {
super.onDestroy()
textFlipper?.takeIf { it.isFlipping }?.stopFlipping()
imgFlipper?.takeIf { it.isFlipping }?.stopFlipping()
}
}
复制代码

3.1 文字轮播:TextFlipperAdapter


class TextFlipperAdapter(private val context: Context, private val datas: List<String>) : BaseAdapter() {
override fun getView(position: Int, convertView: View?, parent: ViewGroup?): View {
val view = convertView ?: LayoutInflater.from(context).inflate(R.layout.item_flipper_text, parent, false)
val textView = view?.findViewById<TextView?>(R.id.text)
textView?.text = datas.get(position)
return view
}

override fun getItem(position: Int): Any {
return datas.get(position)
}

override fun getItemId(position: Int): Long {
return position.toLong()
}

override fun getCount(): Int {
return datas.size
}
}
复制代码

3.2 图片轮播:ImgFlipperAdapter


class ImgFlipperAdapter(private val context: Context, private val datas: List<String>) : BaseAdapter() {
override fun getView(position: Int, convertView: View?, parent: ViewGroup?): View {
val view = convertView ?: ImageView(context)
(view as? ImageView)?.scaleType = ImageView.ScaleType.FIT_XY
view.layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
(view as? ImageView)?.let { Glide.with(context).load(datas.get(position)).into(it) }

return view
}

override fun getItem(position: Int): Any {
return datas.get(position)
}

override fun getItemId(position: Int): Long {
return position.toLong()
}

override fun getCount(): Int {
return datas.size
}
}


复制代码

3.3 布局:activity_flipper_anim.xml


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">

<RelativeLayout
android:layout_width="match_parent"
android:layout_height="100dp"
android:background="@android:color/holo_red_light"
android:orientation="vertical">

<!--宽高要必须设置填充满,否则wrap_content时,大小变成第一个item的大小-->
<AdapterViewFlipper
android:id="@+id/text_flipper"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:autoStart="true"
android:flipInterval="2000" />
</RelativeLayout>

<RelativeLayout
android:layout_width="match_parent"
android:layout_height="0dp"
android:layout_weight="1">

<AdapterViewFlipper
android:id="@+id/img_flipper"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:layout_alignParentTop="true"
android:flipInterval="5000" />

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:gravity="center"
android:text="图片轮播测试(5s)"
android:textSize="24sp" />

<Button
android:id="@+id/prev_btn"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
android:layout_alignParentBottom="true"
android:text="上一个" />

<Button
android:id="@+id/next_btn"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentBottom="true"
android:layout_centerHorizontal="true"
android:text="下一个" />

<Button
android:id="@+id/auto_btn"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentRight="true"
android:layout_alignParentBottom="true"
android:text="自动播放" />

</RelativeLayout>
</LinearLayout>
复制代码

3.4 动画


文字轮播,入场动画:res/animator/text_flipper_in_from_bottom.xml


<?xml version="1.0" encoding="utf-8"?>
<objectAnimator xmlns:android="http://schemas.android.com/apk/res/android"
android:duration="300"
android:interpolator="@android:anim/accelerate_decelerate_interpolator"
android:propertyName="y"
android:valueFrom="100"
android:valueTo="0"
android:valueType="floatType" />
复制代码

文字轮播,出场动画:res/animator/text_flipper_out_to_top.xml


<?xml version="1.0" encoding="utf-8"?>
<objectAnimator xmlns:android="http://schemas.android.com/apk/res/android"
android:duration="300"
android:interpolator="@android:anim/accelerate_decelerate_interpolator"
android:propertyName="y"
android:valueFrom="0"
android:valueTo="-100"
android:valueType="floatType" />
复制代码

图片轮播,入场动画:res/animator/img_flipper_in.xml


<?xml version="1.0" encoding="utf-8"?>
<objectAnimator xmlns:android="http://schemas.android.com/apk/res/android"
android:duration="300"
android:interpolator="@android:anim/accelerate_decelerate_interpolator"
android:propertyName="x"
android:valueFrom="500"
android:valueTo="0"
android:valueType="floatType" />
复制代码

参考



  1. AdapterViewFlipper轻松完成图片轮播

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

Jcenter 停止服务,我哭了 —— 说一说我们的迁移方案

在今年的 2 月 3 日,Jcenter 运营官方发布一则通告称:包括 GoCenter、Bintray、JCenter 在内的多项软件包管理和分发服务都将停止运营。 UPDATE: To better support the community in thi...
继续阅读 »

在今年的 2 月 3 日,Jcenter 运营官方发布一则通告称:包括 GoCenter、Bintray、JCenter 在内的多项软件包管理和分发服务都将停止运营。


UPDATE: To better support the community in this migration, JFrog has extended the JCenter new package versions submission deadline through March 31st 2021.


To clarify, the JCenter repository will keep serving packages for 12 months until February 1st 2022. Only the JCenter REST API and UI will be sunsetted on May 1st 2021.


原文链接如下:jfrog.com/blog/into-t…


对于 JFrog 停止运营 Jcenter 的原因我们不予置评。但是 Jcenter 仓库作为 Android 开发者使用最多的仓库,突然停止运营对于很多开发者和开源企业都带来很大的影响。同样我们神策 Android 系的 SDK 都是开源发布在 Jcenter 仓库上,所以我们内部也开始启动迁移方案的调研,在这个过程中,我们主要调研了三种备选方案:JitPack 仓库、公有 Maven 仓库和私有 Maven 仓库,最终我们采用发布到公有 Maven 仓库作为主选,发布到 JitPack 仓库作为备份应急,过渡阶段也会继续发布到 Jcenter。本篇文章主要介绍公有 Maven 和 JitPack 仓库的发布流程。


1. JitPack 仓库


JitPack 是一个基于 GitHub 开源仓库的发布仓库,它完美地与 GitHub 仓库兼容,使用 Jcenter 发布仓库时,我们需要在脚本中标注对应的 GroupId、Artifac 等信息,但是使用 JitPack 可以省去 Jcenter 发布过程中诸多繁琐的配置。下面介绍基于 JitPack 仓库发布的步骤。


1.1. 发布 GitHub Release


当我们的代码从本地分支推送到 GitHub 远程分支后,我们就可以发布一个版本的 Release。 在仓库的 Release 主页面,点击“Draft a new release”按钮发布一个新版本。这里我们以我们开源的一款 SDK 为例。



分别填写 Tag version、Release title、Describe this release 字段,我们以本次提交的版本是 1.2.3 为例:



  • Tag version:v1.2.3

  • Release title: Release 1.2.3


最后点击下方的“Publish release”绿色按钮。


1.2. Jitpack 发布


进入Jitpack 官方,使用 GitHub 账号进行登录。




  • 点击右上角「Sign In」使用 GitHub 账号登录

  • 在「Git repo url」中输入需要发布的仓库地址


这里依照神策分析埋点 SDK 为例:



配置项说明:



  • Releases:已发布的 Release 版本;

  • Builds:构建记录;

  • Branches:当前仓库的分支;

  • Commits:提交记录;


在 Releases 选项卡页面,点击「Get it」按钮即可进行对应版本的发布。发布成功后 Log 选项卡会呈现绿色,提示「Status:ok」,反之则是红色,提示错误异常信息。


1.3. 版本引用


第一步:在项目根目录的 build.gradle 文件中添加:


allprojects {


repositories {


...


maven { url '[https://jitpack.io](https://jitpack.io/)' }


}


}


第二步:在项目 Module 下的 build.gradle 文件中添加:


dependencies {


implementation 'com.github.sensorsdata:sa-sdk-android:5.1.3'


}


至此我们就完成了版本远程仓库的发布和引用。


1.4. 版本删除


在 JitPack 仓库包中,如果一个版本出现 Bug 需要删除,则需要现在 GitHub 的 Release 中删除该版本即可。


2. 公有 Maven 仓库


或许当初是由于发布到 Maven 仓库流程过于繁琐,Android 才会选择 Jcenter 作为默认的仓库地址。但是随着 Jcenter 的停止运营,仍然需要迁移到 Maven 仓库。


对于发布到 Maven 仓库,Sonatype 官方也提供了基于 Gradle 的脚本配置的指导文档,同时 Android 官方也提供了基于 Maven Publish 插件发布的指导帮助文档。但是由于 Maven 仓库要求对于发布的资源必须进行签名,但是 Android 官方提供的配置文档缺失签名部分,所以会导致发布到 Maven 之后,并不能真正的发布成功。Sonatype 提供的基于的指导文档是基于 maven 插件的 uploadArchives 任务,而 maven 插件在 Gradle 7.0 中已经被废弃并且被删除。所以我们最终采用基于 maven-publish 插件的 publishing 任务来发布到 Maven 仓库。


下面详细介绍一下发布到共有 Maven 仓库的操作步骤。


2.1. 注册 Sonatype 账号和申请项目


2.1.1. 注册 Sonatype 账号


注册地址:issues.sonatype.org/secure/Sign…



2.1.2. 申请创建新项目


在注册完成账号之后,创建 Issue 申请项目。


申请地址:issues.sonatype.org/secure/Crea…



完成申请之后,会与官方的支持人员与你确认沟通,以便确认你是该域名的持有者。需要注意的是,现在针对 GitHub 用户的域名是以:io.github. 开头,不允许自定义。如果有独立的域名可以使用域名作为Group Id。


2.2. GPG 签名


对于发布到 Maven 的资源,需要有签名校验,比较普遍的签名有 GPG 和 PGP,这里使用 GPG 签名作为示例。


2.2.1. GPG 安装


GPG 可以使用安装命令行,也可以通过客户端工具安装。这里我使用 brew 命令进行安装。


➜ ~ brew install gpg


安装完成后,通过 gpg --version 查看是否安装成功。


➜ ~ gpg --version


gpg (GnuPG``/MacGPG2``) 2.2.10


libgcrypt 1.8.3


Copyright (C) 2018 Free Software Foundation, Inc.


License GPLv3+: GNU GPL version 3 or later <https:``//gnu``.org``/licenses/gpl``.html>


This is free software: you are free to change and redistribute it.


There is NO WARRANTY, to the extent permitted by law.


Home: /Users/dengshiwei/``.gnupg


支持的算法:


公钥:RSA, ELG, DSA, ECDH, ECDSA, EDDSA


对称加密:IDEA, 3DES, CAST5, BLOWFISH, AES, AES192, AES256,


TWOFISH, CAMELLIA128, CAMELLIA192, CAMELLIA256


散列:SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224


压缩:不压缩, ZIP, ZLIB, BZIP2


2.2.2. 生成密钥


指令:gpg --gen-key



输入:gpg --gen-key 后,会提示我们输入真实姓名、电子邮箱地址用于标识我们这个用户,最后确认信息时会让我们填入标识该用户的密码信息(很重要,一定要记住)。


2.2.3. 查看密钥


指令:gpg --list-keys


➜ ~ gpg --list-keys


/Users/dengshiwei/``.gnupg``/pubring``.kbx


------------------------------------


pub dsa2048 2010-08-19 [SC] [已过期:2020-06-15]


85E38F69046B44C1EC9FB07B76D78F0500D026C4


uid [已过期] GPGTools Team <team@gpgtools.org>


pub rsa2048 2021-03-01 [SC] [有效至:2023-03-01]


C19CC95F56C5D3EF8ADA2222133C922134E5CD035


uid [ 绝对 ] dengshiwei <dengshiwei@sensorsdata.cn>


sub rsa2048 2021-03-01 [E] [有效至:2023-03-01]


这里可以看到我的公钥 ID = C19CC95F56C5D3EF8ADA2222133C922134E5CD035,仅仅有公钥是不够的,我们需要发布公钥到密钥服务器才能进行识别。


2.2.4. 发布公钥到服务器


指令:gpg --keyserver hkp://pool.sks-keyservers.net --send-keys 公钥 ID


➜ ~ gpg --keyserver hkp:``//pool``.sks-keyservers.net --send-keys C19CC95F56C5D3EF8ADA299933C922134E5CD035


gpg: 将密钥‘33C922134E5CD035’上传到 hkp:``//pool``.sks-keyservers.net


2.2.5. 查看密钥是否发布成功


指令:gpg --keyserver hkp://pool.sks-keyservers.net --recv-keys 公钥 ID


➜ ~ gpg --keyserver hkp:``//pool``.sks-keyservers.net --recv-keys C19CC95F56C5D3EF8ADA299933C922134E5CD035


gpg: 密钥 33C922134E5CD035:“dengshiwei <dengshiwei@sensorsdata.cn>”未改变


gpg: 合计被处理的数量:1


gpg: 未改变:1


这样就标志着发布成功了。


2.2.6. 密钥导出


gpg 中提供了导出公钥和私钥的签名方法。



  • gpg -a -o public-file.key --export KeyId : 导出公钥到 public-file.key 文件中;

  • gpg -a -o private-file.key --export-secret-keys KeyId : 导出私钥到 private-file.key 文件中。


其中:



  • -a 为 --armor 的简写,表示密钥以 ASCII 的形式输出,默认以二进制的形式输出;

  • -o 为 --output 的简写,指定写入的文件。


2.3. 发布脚本


2.3.1. 引入发布和签名插件


在需要发布的工程项目的 build.gradle 文件中引入 maven-public 和 signing 插件。


build.gradle


apply plugin: 'signing'


apply plugin: 'maven-publish'


2.3.2. 配置发布脚本


maven-public 插件通过 publishing 任务来发布资源。这里的配置主要包含:javadoc 文件、pop 文件、javadocJar 文件等。


task sourceJar(``type``: Jar) {


from android.sourceSets.main.java.srcDirs


classifier = 'sources'


}


task javadoc(``type``: Javadoc) {


dependsOn 'assembleRelease'


source = android.sourceSets.main.java.srcDirs +


'build/generated/not_namespaced_r_class_sources/release/generateReleaseRFile/out/com/sensorsdata/analytics/android/sdk/R.java'


classpath += project.files(android.getBootClasspath().``join``(File.pathSeparator))


}


javadoc {


options {


encoding "UTF-8"


charSet 'UTF-8'


}


}


task javadocJar(``type``: Jar, dependsOn: javadoc) {


classifier = 'javadoc'


from javadoc.destinationDir


}


publishing {


publications {


mavenAndroid(MavenPublication) {


groupId = 'com.sensorsdata.analytics.android'


artifactId = 'SensorsAnalyticsSDK'


version = version


artifact sourceJar


artifact javadocJar


artifact(``'build/outputs/aar/SensorsAnalyticsSDK.aar'``)


// 配置 pop 文件格式


pom {


packaging 'aar'


name = 'The official Android SDK for Sensors Analytics.'


description = 'The official Android SDK for Sensors Analytics.'


url = 'The official Android SDK for Sensors Analytics.'


licenses {


license {


name=``'The Apache Software License, Version 2.0'


url=``'[http://www.apache.org/licenses/LICENSE-2.0.txt'](http://www.apache.org/licenses/LICENSE-2.0.txt')


}


}


developers {


developer {


id = 'dengshiwei'


name = 'dengshiwei'


email = 'dengshiwei@sensorsdata.com'


}


}


scm {


connection = '[https://github.com/sensorsdata/sa-sdk-android'](https://github.com/sensorsdata/sa-sdk-android')


developerConnection = '[https://github.com/sensorsdata/sa-sdk-android.git'](https://github.com/sensorsdata/sa-sdk-android.git')


url = '[https://github.com/sensorsdata/sa-sdk-android'](https://github.com/sensorsdata/sa-sdk-android')


}


}


}


}


// 配置远程仓库


repositories {


// maven 对应的用户名和密码自定义存在 local``.properties 文件中


Properties properties = new Properties()


properties.load(project.rootProject.``file``(``'local.properties'``).newDataInputStream())


def mavenUser = properties.getProperty(``"maven.user"``)


def mavenPassword = properties.getProperty(``"maven.password"``)


maven {


// 发布地址,新申请的项目发布地址为:https:``//s01``.oss.sonatype.org``/service/local/staging/deploy/maven2/


url = '[https://oss.sonatype.org/service/local/staging/deploy/maven2/'](https://oss.sonatype.org/service/local/staging/deploy/maven2/')


credentials {


username mavenUser


password mavenPassword


}


}


}


}


// 对 mavenAndroid 发布内容进行签名


signing {


sign publishing.publications.mavenAndroid


}


发布脚本配置中有以下需要注意:



  • groupId:需要配置自己申请的 groupId;

  • artifactId:需要修改为自己项目的 artifactId;

  • pom 中的文件描述需要修改为自己项目的描述;

  • repositories 部分配置了远程仓库对应的用户名和密码,发布地址需要根据是否是新项目进行修改,旧项目域名是 oss.sonatype.org,新项目域名是:s01.oss.sonatype.org

  • signing 签名部分需要配置对应的 gpg 密钥和账户信息


签名密钥配置


signing 签名要求在 gradle.properties 配置文件中配置密钥信息。


signing.keyId=YourKeyId


signing.password=YourPublicKeyPassword


signing.secretKeyRingFile=PathToYourKeyRingFile




  • signing.keyId:指刚才我们发布的公钥 ID,这里有一个坑就是这个 ID 的长度只能是 8 位,所以我们可以直接截取公钥 ID 的后 8 位即可;




  • signing.password:发布公钥对应的密码;




  • signing.secretKeyRingFile:指 gpg key 导出的私钥对应的问题,是绝对路径。可以通过指令 gpg --keyring secring.gpg --export-secret-keys > ~/.gnupg/secring.gpg 进行导出。




至此,我们完成发布相关的所有配置。


2.4. 版本发布


当我们配置好 publishing 后,我们可以通过指令:./gradlew publish 来执行发布任务。还可以通过 Android Studio 中的 Gradle 任务看板来执行 publish 任务。



2.5. 版本引用


第一步:在项目根目录的 build.gradle 文件中添加:


allprojects {


repositories {


...


mavenCentral()


}


}


第二步:在项目 Module 下的 build.gradle 文件中添加:


dependencies {


implementation 'com.github.sensorsdata:sa-sdk-android:5.1.3'


}


至此我们就完成了版本远程仓库的发布和引用。


3. Jcenter 同步到 Maven


对于新发布的版本,我们可以选择直接发布到 Maven,但是对于已经发布到 Jcenter 的仓库,我们需要借助 Jcenter 提供的 Maven Central 功能进行同步。


3.1. Jcenter 配置 GPG 密钥


在 Jcenter 首页点击个人头像后点击「Edit Profile」进入个人信息配置页面,然后选中「GPG Signing」选项,配置导出的公钥和私钥。



配置完成后点击「Update」按钮即可。


3.2. Jcenter 配置 Sonatype 账号


在个人信息配置页面点击「Accounts」选项,配置注册的 Sonatype 账号。



3.3. 同步仓库到 Maven


进入仓库主页,点击「Maven Central」选项卡切换到对应的页面,点击「Sync」同步至 Maven。



至此完成整个 Jecenter 到 Maven 仓库的同步。


4. 总结


本次 Jcenter 的停止维护对于 Android 开发者来说会造成很大的影响,同时在迁移配置脚本的过程中也遇到很多问题,这里就不一一列举了,遇到问题首先要做的就是要反复检查核对自己的配置。希望 Android 官方能尽快出一个快速高效的迁移方案。


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

SparseArray解析

作者:btcw链接:https://juejin.cn/post/6954972237443104782来源:掘金著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

SparseArray


Sparse[spɑːrs]


文档介绍


/**
* <code>SparseArray</code> maps integers to Objects and, unlike a normal array of Objects,
* its indices can contain gaps. <code>SparseArray</code> is intended to be more memory-efficient
* than a
* <a href="/reference/java/util/HashMap"><code>HashMap</code></a>, because it avoids
* auto-boxing keys and its data structure doesn't rely on an extra entry object
* for each mapping.
*
* <p>Note that this container keeps its mappings in an array data structure,
* using a binary search to find keys. The implementation is not intended to be appropriate for
* data structures
* that may contain large numbers of items. It is generally slower than a
* <code>HashMap</code> because lookups require a binary search,
* and adds and removes require inserting
* and deleting entries in the array. For containers holding up to hundreds of items,
* the performance difference is less than 50%.
*
* <p>To help with performance, the container includes an optimization when removing
* keys: instead of compacting its array immediately, it leaves the removed entry marked
* as deleted. The entry can then be re-used for the same key or compacted later in
* a single garbage collection of all removed entries. This garbage collection
* must be performed whenever the array needs to be grown, or when the map size or
* entry values are retrieved.
*
* <p>It is possible to iterate over the items in this container using
* {@link #keyAt(int)} and {@link #valueAt(int)}. Iterating over the keys using
* <code>keyAt(int)</code> with ascending values of the index returns the
* keys in ascending order. In the case of <code>valueAt(int)</code>, the
* values corresponding to the keys are returned in ascending order.
*/
复制代码

SparseArray是谷歌提供的k-v键值对存储类,key固定为int,value为泛型(内部为Object)。虽然


内部主要方法


ContainerHelpers


工具类,二分查找法查找int或者long值,找到返回index,没有找到返回取反后的值(为负数)。


PS:


>>: 	带符号右移
>>>: 无符号右移
最高位为1表示负数,负数则数值位取反

01111111111111111111111111111111 int maxVal 补:01111111111111111111111111111111
10000000000000000000000000000000 int minVal 补:11111111111111111111111111111111
因为在计算机系统中,数值一律用补码来表示和存储。0的补码属于正数范围,所以int值的范围高区间(正数区间)减1:
-2^31~2^31-1

复制代码

// This is Arrays.binarySearch(), but doesn't do any argument validation.
static int binarySearch(int[] array, int size, int value) {
int lo = 0;
int hi = size - 1;

while (lo <= hi) {
final int mid = (lo + hi) >>> 1;
final int midVal = array[mid];

if (midVal < value) {
lo = mid + 1;
} else if (midVal > value) {
hi = mid - 1;
} else {
return mid; // value found
}
}
return ~lo; // value not present 取反为负
}
复制代码

put


public void put(int key, E value) {
int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

if (i >= 0) {
mValues[i] = value;
} else {
i = ~i;

if (i < mSize && mValues[i] == DELETED) {
mKeys[i] = key;
mValues[i] = value;
return;
}
//可能碰到需要重新排列,如果重排则重新计算索引位置。
if (mGarbage && mSize >= mKeys.length) {
gc();

// Search again because indices may have changed.
i = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
}

mKeys = GrowingArrayUtils.insert(mKeys, mSize, i, key);
mValues = GrowingArrayUtils.insert(mValues, mSize, i, value);
mSize++;
}
}
复制代码

先用二分查找法查找查找值的index,index大于0则集合中存在,小于0则不存在(见ContainerHelpers)。找到则更新;没找到,则获取需要插入的index位置(返回的负数为插入位置取反),key数组和value数组分别在对应index插入元素。也就是说这里面的元素是通过key的大小进行排序的。其中插入元素的方法是在GrowingArrayUtils.insert内部中调用System.arraycopy,内部真实数组的size在这里进行改变


delete


删除某个键值对,这里的删除并不是真实删除,而是把它的value标记为DELETED,mGarbage标记为true。然后在put、size、keyAt、valueAt、setValueAt、indexForKey、indexOfValue、indexOfValue、indexOfValueByValue、append等方法中触发成员gc方法


/**
* Removes the mapping from the specified key, if there was any.
*/
public void delete(int key) {
int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

if (i >= 0) {
if (mValues[i] != DELETED) {
mValues[i] = DELETED;
mGarbage = true;
}
}
}
复制代码

gc


遍历数组,把未被标记为DELETE的元素放到数组前面,并刷新size大小。(这里的size并不是内存两个数组的size大小,而是有效位数的大小)


private void gc() {
// Log.e("SparseArray", "gc start with " + mSize);

int n = mSize;
int o = 0;
int[] keys = mKeys;
Object[] values = mValues;

for (int i = 0; i < n; i++) {
Object val = values[i];

if (val != DELETED) {
if (i != o) {
keys[o] = keys[i];
values[o] = val;
values[i] = null;
}

o++;
}
}

mGarbage = false;
mSize = o;

// Log.e("SparseArray", "gc end with " + mSize);
}
复制代码

get


通过key获取元素。根据调用方法获取不到返回默认或者null。


/**
* Gets the Object mapped from the specified key, or <code>null</code>
* if no such mapping has been made.
*/
public E get(int key) {
return get(key, null);
}

/**
* Gets the Object mapped from the specified key, or the specified Object
* if no such mapping has been made.
*/
@SuppressWarnings("unchecked")
public E get(int key, E valueIfKeyNotFound) {
int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

if (i < 0 || mValues[i] == DELETED) {
return valueIfKeyNotFound;
} else {
return (E) mValues[i];
}
}
复制代码

append


对比put,在append的元素大于最大的一个的时候,直接追加在最后,而不是先二分查找再插入。不大于最后一个的时候就调用put。


/**
* Puts a key/value pair into the array, optimizing for the case where
* the key is greater than all existing keys in the array.
*/
public void append(int key, E value) {
if (mSize != 0 && key <= mKeys[mSize - 1]) {
put(key, value);
return;
}

if (mGarbage && mSize >= mKeys.length) {
gc();
}

mKeys = GrowingArrayUtils.append(mKeys, mSize, key);
mValues = GrowingArrayUtils.append(mValues, mSize, value);
mSize++;
}
复制代码

和HashMap、ArrayMap对比,SparseArray的优缺点:


SparseArray的限制在于键必须是int类型,值必须是Object类型。这样可以避免key自动装箱产生过多的Object。但是这样的话,如果key值相同,那么数据就会被直接覆盖。


SparseArray不能保证保留它们的插入顺序,在迭代的时候应该注意。SparseArray中没有Iterator,SparseArray只实现了Cloneable接口,而没有继承Collection、List或者Map接口。


查找数据的时候使用的是二分法,明显比通过hashcode慢,所以数据越大,查找速度慢的劣势越明显,所以SparseArray适于数据一千以内的场景中。


优点:



  • 避免了基本数据类型的装箱操作

  • 不需要额外的结构体,单个元素的存储成本更低

  • 数据量小的情况下,随机访问的效率更高


缺点:



  • 插入操作需要复制数组,增删效率降低

  • 数据量巨大时,复制数组成本巨大,gc()成本也巨大

  • 数据量巨大时,查询效率也会明显下降


————————————————


参考资料:


优缺点总结:blog.csdn.net/b1480521874…


作者:btcw
链接:https://juejin.cn/post/6954972237443104782
来源:掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

最接近朋友圈的图片压缩算法-Luban

Luban(鲁班) —— Android图片压缩工具,仿微信朋友圈压缩策略。Luban-turbo —— 鲁班项目的turbo版本,查看trubo分支。写在前面家境贫寒,工作繁忙。只能不定期更新,还望网友们见谅!项目描述目前做App开发总绕...
继续阅读 »

Luban(鲁班) —— Android图片压缩工具,仿微信朋友圈压缩策略。

Luban-turbo —— 鲁班项目的turbo版本,查看trubo分支

写在前面

家境贫寒,工作繁忙。只能不定期更新,还望网友们见谅!

项目描述

目前做App开发总绕不开图片这个元素。但是随着手机拍照分辨率的提升,图片的压缩成为一个很重要的问题。单纯对图片进行裁切,压缩已经有很多文章介绍。但是裁切成多少,压缩成多少却很难控制好,裁切过头图片太小,质量压缩过头则显示效果太差。

于是自然想到App巨头“微信”会是怎么处理,Luban(鲁班)就是通过在微信朋友圈发送近100张不同分辨率图片,对比原图与微信压缩后的图片逆向推算出来的压缩算法。

因为有其他语言也想要实现Luban,所以描述了一遍算法步骤

因为是逆向推算,效果还没法跟微信一模一样,但是已经很接近微信朋友圈压缩后的效果,具体看以下对比!

效果与对比

内容原图LubanWechat
截屏 720P720*1280,390k720*1280,87k720*1280,56k
截屏 1080P1080*1920,2.21M1080*1920,104k1080*1920,112k
拍照 13M(4:3)3096*4128,3.12M1548*2064,141k1548*2064,147k
拍照 9.6M(16:9)4128*2322,4.64M1032*581,97k1032*581,74k
滚动截屏1080*6433,1.56M1080*6433,351k1080*6433,482k

导入

implementation 'top.zibin:Luban:1.1.8'

使用

方法列表

方法描述
load传入原图
filter设置开启压缩条件
ignoreBy不压缩的阈值,单位为K
setFocusAlpha设置是否保留透明通道
setTargetDir缓存压缩图片路径
setCompressListener压缩回调接口
setRenameListener压缩前重命名接口

异步调用

Luban内部采用IO线程进行图片压缩,外部调用只需设置好结果监听即可:

Luban.with(this)
.load(photos)
.ignoreBy(100)
.setTargetDir(getPath())
.filter(new CompressionPredicate() {
@Override
public boolean apply(String path) {
return !(TextUtils.isEmpty(path) || path.toLowerCase().endsWith(".gif"));
}
})
.setCompressListener(new OnCompressListener() {
@Override
public void onStart() {
// TODO 压缩开始前调用,可以在方法内启动 loading UI
}

@Override
public void onSuccess(File file) {
// TODO 压缩成功后调用,返回压缩后的图片文件
}

@Override
public void onError(Throwable e) {
// TODO 当压缩过程出现问题时调用
}
}).launch();

同步调用

同步方法请尽量避免在主线程调用以免阻塞主线程,下面以rxJava调用为例

Flowable.just(photos)
.observeOn(Schedulers.io())
.map(new Function<List<String>, List<File>>() {
@Override public List<File> apply(@NonNull List<String> list) throws Exception {
// 同步方法直接返回压缩后的文件
return Luban.with(MainActivity.this).load(list).get();
}
})
.observeOn(AndroidSchedulers.mainThread())
.subscribe();


代码下载:Luban-master.zip

原文链接:https://github.com/Curzibn/Luban

收起阅读 »

okhttp 上传下载进度监听-ProgressManager

ProgressManager 一行代码即可监听 App 中所有网络链接的上传以及下载进度,包括 Glide 的图片加载进度,实现原理类似 EventBus,你可在 App 中的任...
继续阅读 »

ProgressManager 一行代码即可监听 App 中所有网络链接的上传以及下载进度,包括 Glide 的图片加载进度,实现原理类似 EventBus,你可在 App 中的任何地方,将多个监听器,以 Url 地址作为标识符,注册到本框架,当此 Url 地址存在下载或者上传的动作时,框架会主动调用所有使用此 Url 地址注册过的监听器,达到多个模块的同步更新.

Feature

  • 使用简单,只需一行代码即可实现进度监听.
  • 多平台支持,支持 Okhttp , Retrofit , Glide ,使用 Okhttp 原生 Api ,不存在兼容问题.
  • 低耦合,实际请求端和进度接收端并不存在直接或间接的关联关系,即可以在 App 任何地方接收进度信息.
  • 侵入性低,使用本框架你并不需要更改之前进行上传或下载的代码,即使用或不使用本框架并不会影响到原有的代码.
  • 多端同步,同一个数据源的上传或下载进度可以指定多个不同的接收端,少去了使用 EventBus 实现多个端口同步更新进度.
  • 支持多文件上传.
  • 支持 URL 重定向.
  • 自动管理监听器,少去了手动注销监听器的烦恼.
  • 默认运行在主线层,少去了切换线程的烦恼.
  • 轻量级框架,不包含任何三方库,体积极小.

Download

 implementation 'me.jessyan:progressmanager:1.5.0'

Usage

Step 1

 // 构建 OkHttpClient 时,将 OkHttpClient.Builder() 传入 with() 方法,进行初始化配置
OkHttpClient = ProgressManager.getInstance().with(new OkHttpClient.Builder())
.build();

Step 2

 // Glide 下载监听
ProgressManager.getInstance().addResponseListener(IMAGE_URL, getGlideListener());


// Okhttp/Retofit 下载监听
ProgressManager.getInstance().addResponseListener(DOWNLOAD_URL, getDownloadListener());


// Okhttp/Retofit 上传监听
ProgressManager.getInstance().addRequestListener(UPLOAD_URL, getUploadListener());

ProGuard

 -keep class me.jessyan.progressmanager.** { *; }
-keep interface me.jessyan.progressmanager.** { *; }


代码下载:ProgressManager-master 2.zip

原文链接:https://github.com/JessYanCoding/ProgressManager/blob/master/README-zh.md#feature

收起阅读 »

iOS -- malloc分析(2)

2.10 segregated_band_grow分析boolean_t segregated_band_grow(nanozone_t *nanozone, nano_meta_admin_t pMeta, size_t slot_bytes, u...
继续阅读 »

2.10 segregated_band_grow分析


boolean_t
segregated_band_grow(nanozone_t *nanozone, nano_meta_admin_t pMeta, size_t slot_bytes, unsigned int mag_index)
{
用来计算slot_current_base_addr 的联合体
nano_blk_addr_t u; // the compiler holds this in a register
uintptr_t p, s;
size_t watermark, hiwater;

if (0 == pMeta->slot_current_base_addr) { // First encounter?
//利用nano_blk_addr_t 来计算slot_current_base_addr。
u.fields.nano_signature = NANOZONE_SIGNATURE;
u.fields.nano_mag_index = mag_index;
u.fields.nano_band = 0;
u.fields.nano_slot = (slot_bytes >> SHIFT_NANO_QUANTUM) - 1;
u.fields.nano_offset = 0;

//根据设置的属性计算 slot_current_base_addr
p = u.addr;
pMeta->slot_bytes = (unsigned int)slot_bytes;
pMeta->slot_objects = SLOT_IN_BAND_SIZE / slot_bytes;
} else {
p = pMeta->slot_current_base_addr + BAND_SIZE; // Growing, so stride ahead by BAND_SIZE

u.addr = (uint64_t)p;
if (0 == u.fields.nano_band) { // Did the band index wrap?
return FALSE;
}

assert(slot_bytes == pMeta->slot_bytes);
}
pMeta->slot_current_base_addr = p;
//BAND_SIZE = 1 << 21 = 2097152 = 256kb
mach_vm_address_t vm_addr = p & ~((uintptr_t)(BAND_SIZE - 1)); // Address of the (2MB) band covering this (128KB) slot
if (nanozone->band_max_mapped_baseaddr[mag_index] < vm_addr) {
//如果最大能存储的地址 仍然小于目标地址,则小开辟新的band
#if !NANO_PREALLOCATE_BAND_VM
// Obtain the next band to cover this slot
//// mac 和模拟器 或重新使用
// Obtain the next band to cover this slot
//重新申请新的 band,调用mach_vm_map 从pmap 转换。
kern_return_t kr = mach_vm_map(mach_task_self(), &vm_addr, BAND_SIZE, 0, VM_MAKE_TAG(VM_MEMORY_MALLOC_NANO),
MEMORY_OBJECT_NULL, 0, FALSE, VM_PROT_DEFAULT, VM_PROT_ALL, VM_INHERIT_DEFAULT);

void *q = (void *)vm_addr;
if (kr || q != (void *)(p & ~((uintptr_t)(BAND_SIZE - 1)))) { // Must get exactly what we asked for
if (!kr) {
mach_vm_deallocate(mach_task_self(), vm_addr, BAND_SIZE);
}
return FALSE;
}
#endif
nanozone->band_max_mapped_baseaddr[mag_index] = vm_addr;
}

// Randomize the starting allocation from this slot (introduces 11 to 14 bits of entropy)
if (0 == pMeta->slot_objects_mapped) { // First encounter?
pMeta->slot_objects_skipped = (malloc_entropy[1] % (SLOT_IN_BAND_SIZE / slot_bytes));
pMeta->slot_bump_addr = p + (pMeta->slot_objects_skipped * slot_bytes);
} else {
pMeta->slot_bump_addr = p;
}

pMeta->slot_limit_addr = p + (SLOT_IN_BAND_SIZE / slot_bytes) * slot_bytes;
pMeta->slot_objects_mapped += (SLOT_IN_BAND_SIZE / slot_bytes);

u.fields.nano_signature = NANOZONE_SIGNATURE;
u.fields.nano_mag_index = mag_index;
u.fields.nano_band = 0;
u.fields.nano_slot = 0;
u.fields.nano_offset = 0;
s = u.addr; // Base for this core.

// Set the high water mark for this CPU's entire magazine, if this resupply raised it.
watermark = nanozone->core_mapped_size[mag_index];
hiwater = MAX(watermark, p - s + SLOT_IN_BAND_SIZE);
nanozone->core_mapped_size[mag_index] = hiwater;

return TRUE;
}
  • nano_blk_addr_t u 用来计算 slot_current_base_addr 的联合体

  • 利用 nano_blk_addr_t 来计算 slot_current_base_addr

  • 根据设置的属性计算 slot_current_base_addr

  • 如果最大能存储的地址 仍然小于目标地址,则小开辟新的band

  • mac 和模拟器 或重新使用

  • 重新申请新的 band,调用 mach_vm_map 从 pmap 转换。

当进入 segregated_band_grow 时,如果当前的 band 不够用,则使用 mach_vm_map 经由 pmap 重新映射物理内存到虚拟内存。

关于通过 nano_blk_addr_t 的联合体结构如下,其每个成员所占的 bit位数 已经写出。


struct nano_blk_addr_s {
uint64_t
nano_offset:NANO_OFFSET_BITS, //17 locates the block
nano_slot:NANO_SLOT_BITS, //4 bucket of homogenous quanta-multiple blocks
nano_band:NANO_BAND_BITS, //17
nano_mag_index:NANO_MAG_BITS, //6 the core that allocated this block
nano_signature:NANOZONE_SIGNATURE_BITS; // the address range devoted to us.
};

#endif
// clang-format on

typedef union {
uint64_t addr;
struct nano_blk_addr_s fields;
} nano_blk_addr_t;

下面通过 LLDB 分析



在 free 的阶段,也是使用如上的方式获取 对应的 slot,mag_index

下面来梳理下 nana_zone 分配过程:

  • 确定当前 cpu 对应的 mag 和通过 size参数 计算出来的 slot ,去对应 chained_block_s 的链表中取已经被释放过的内存区块缓存,如果取到检查指针地址是否有问题,没有问题就直接返回;
  • 初次进行 nano malloc时,nano zon并没有缓存,会直接在 nano zone范围的地址空间上直接分配连续地址内存;
  • 如当前 Band 中当前 Slot 耗尽则向系统申请新的 Band(每个 Band固定大小 2M,容纳了16个128k的槽),连续地址分配内存的基地址、limit地址以及当前分配到的地址由 meta data 结构维护起来,而这些 meta data 则以 MagSlot 为维度(Mag个数是处理器个数,Slot是16个)的二维数组形式,放在 nanozone_t 的 meta_data字段中。
    流程如下


2.11 scalable zone(helper_zone) 分析

在 szone 上分配的内存包括 tiny、small和large 三大类,其中 tiny 和 small 的分配、释放过程大致相同,larg类型有自己的方式管理。同样会通过create_scalable_zone来构造zone。 这里不在复述create_scalable_zone`,直接看内存的分配策略

2.12 szone_malloc_should_clear 分析


MALLOC_NOINLINE void *
szone_malloc_should_clear(szone_t *szone, size_t size, boolean_t cleared_requested)
{
void *ptr;
msize_t msize;
//64位 <= 1008B 32位<= 496B
if (size <= SMALL_THRESHOLD) {
// tiny size: <=1008 bytes (64-bit), <=496 bytes (32-bit)
// think tiny
msize = TINY_MSIZE_FOR_BYTES(size + TINY_QUANTUM - 1);
if (!msize) {
msize = 1;
}
ptr = tiny_malloc_should_clear(&szone->tiny_rack, msize, cleared_requested);
} else if (size <= szone->large_threshold) {
//64位 <= 128KB 32位 <= 128KB
// small size: <=15k (iOS), <=64k (large iOS), <=128k (macOS)
// think small
msize = SMALL_MSIZE_FOR_BYTES(size + SMALL_QUANTUM - 1);
if (!msize) {
msize = 1;
}
ptr = small_malloc_should_clear(&szone->small_rack, msize, cleared_requested);
} else {
// large: all other allocations
size_t num_kernel_pages = round_page_quanta(size) >> vm_page_quanta_shift;
if (num_kernel_pages == 0) { /* Overflowed */
ptr = 0;
} else {
ptr = large_malloc(szone, num_kernel_pages, 0, cleared_requested);
}
}
#if DEBUG_MALLOC
if (LOG(szone, ptr)) {
malloc_report(ASL_LEVEL_INFO, "szone_malloc returned %p\n", ptr);
}
#endif
/*
* If requested, scribble on allocated memory.
*/

if ((szone->debug_flags & MALLOC_DO_SCRIBBLE) && ptr && !cleared_requested && size) {
memset(ptr, SCRIBBLE_BYTE, szone_size(szone, ptr));
}
return ptr;
}

这里以看出在 szone 上分配的内存包括 tinysmall 和large 三大类,我们以 tiny为例 开始下面的分析

2.12 tiny_malloc_should_clear 分析

void *
tiny_malloc_should_clear(rack_t *rack, msize_t msize, boolean_t cleared_requested)
{
void *ptr;
mag_index_t mag_index = tiny_mag_get_thread_index() % rack->num_magazines;
//获取magazine. magazines 是一个由64个magazine_t组成的数组
magazine_t *tiny_mag_ptr = &(rack->magazines[mag_index]);

MALLOC_TRACE(TRACE_tiny_malloc, (uintptr_t)rack, TINY_BYTES_FOR_MSIZE(msize), (uintptr_t)tiny_mag_ptr, cleared_requested);

#if DEBUG_MALLOC
if (DEPOT_MAGAZINE_INDEX == mag_index) {
malloc_zone_error(rack->debug_flags, true, "malloc called for magazine index -1\n");
return (NULL);
}

if (!msize) {
malloc_zone_error(rack->debug_flags, true, "invariant broken (!msize) in allocation (region)\n");
return (NULL);
}
#endif

SZONE_MAGAZINE_PTR_LOCK(tiny_mag_ptr);

#if CONFIG_TINY_CACHE
ptr = tiny_mag_ptr->mag_last_free;
//如果开启了tiny 的缓存。
if (tiny_mag_ptr->mag_last_free_msize == msize) {
// we have a winner
//优先查看上次最后释放的区块是否和此次请求的大小刚好相等(都是对齐之后的slot大小),如果是则直接返回。
tiny_mag_ptr->mag_last_free = NULL;
tiny_mag_ptr->mag_last_free_msize = 0;
tiny_mag_ptr->mag_last_free_rgn = NULL;
SZONE_MAGAZINE_PTR_UNLOCK(tiny_mag_ptr);
CHECK(szone, __PRETTY_FUNCTION__);
if (cleared_requested) {
memset(ptr, 0, TINY_BYTES_FOR_MSIZE(msize));
}
#if DEBUG_MALLOC
if (LOG(szone, ptr)) {
malloc_report(ASL_LEVEL_INFO, "in tiny_malloc_should_clear(), tiny cache ptr=%p, msize=%d\n", ptr, msize);
}
#endif
return ptr;
}
#endif /* CONFIG_TINY_CACHE */

while (1) {
//先从freelist 查找
ptr = tiny_malloc_from_free_list(rack, tiny_mag_ptr, mag_index, msize);
if (ptr) {
SZONE_MAGAZINE_PTR_UNLOCK(tiny_mag_ptr);
CHECK(szone, __PRETTY_FUNCTION__);
if (cleared_requested) {
memset(ptr, 0, TINY_BYTES_FOR_MSIZE(msize));
}
return ptr;
}
//从一个后备magazine中取出一个可用region,完整地拿过来放到当前magazine,再走一遍上面的步骤。
if (tiny_get_region_from_depot(rack, tiny_mag_ptr, mag_index, msize)) {
//再次尝试从freelist 中获取
ptr = tiny_malloc_from_free_list(rack, tiny_mag_ptr, mag_index, msize);
if (ptr) {
SZONE_MAGAZINE_PTR_UNLOCK(tiny_mag_ptr);
CHECK(szone, __PRETTY_FUNCTION__);
if (cleared_requested) {
memset(ptr, 0, TINY_BYTES_FOR_MSIZE(msize));
}
return ptr;
}
}

// The magazine is exhausted. A new region (heap) must be allocated to satisfy this call to malloc().
// The allocation, an mmap() system call, will be performed outside the magazine spin locks by the first
// thread that suffers the exhaustion. That thread sets "alloc_underway" and enters a critical section.
// Threads arriving here later are excluded from the critical section, yield the CPU, and then retry the
// allocation. After some time the magazine is resupplied, the original thread leaves with its allocation,
// and retry-ing threads succeed in the code just above.
if (!tiny_mag_ptr->alloc_underway) {
//如果没有正在申请新的的 regin 操作,则进行申请操作
void *fresh_region;

// time to create a new region (do this outside the magazine lock)
//设置当前正在申请新的 堆
tiny_mag_ptr->alloc_underway = TRUE;
OSMemoryBarrier();
SZONE_MAGAZINE_PTR_UNLOCK(tiny_mag_ptr);
//申请新的堆 1m
fresh_region = mvm_allocate_pages_securely(TINY_REGION_SIZE, TINY_BLOCKS_ALIGN, VM_MEMORY_MALLOC_TINY, rack->debug_flags);
SZONE_MAGAZINE_PTR_LOCK(tiny_mag_ptr);

// DTrace USDT Probe
MAGMALLOC_ALLOCREGION(TINY_SZONE_FROM_RACK(rack), (int)mag_index, fresh_region, TINY_REGION_SIZE);

if (!fresh_region) { // out of memory!
tiny_mag_ptr->alloc_underway = FALSE;
OSMemoryBarrier();
SZONE_MAGAZINE_PTR_UNLOCK(tiny_mag_ptr);
return NULL;
}
//从最近的一个 region 或者新申请的 region中malloc
ptr = tiny_malloc_from_region_no_lock(rack, tiny_mag_ptr, mag_index, msize, fresh_region);

// we don't clear because this freshly allocated space is pristine
tiny_mag_ptr->alloc_underway = FALSE;
OSMemoryBarrier();
SZONE_MAGAZINE_PTR_UNLOCK(tiny_mag_ptr);
CHECK(szone, __PRETTY_FUNCTION__);
return ptr;
} else {
SZONE_MAGAZINE_PTR_UNLOCK(tiny_mag_ptr);
yield();
SZONE_MAGAZINE_PTR_LOCK(tiny_mag_ptr);
}
}
/* NOTREACHED */
}

  • 获取 magazine.

  • magazines 是一个由 64个magazine_t 组成的数组

  • 如果开启了 tiny 的缓存

  • 优先查看上次最后释放的区块是否和此次请求的大小刚好相等(都是对齐之后的 slot大小),如果是则直接返回。

  • ptr = tiny_malloc_from_free_list(rack, tiny_mag_ptr, mag_index, msize); 先从 freelist 查找

  • 从一个后备 magazine 中取出一个可用 region,完整地拿过来放到当前 magazine,再走一遍上面的步骤。

  • void *fresh_region; 如果没有正在申请新的的 regin 操作,则进行申请操作

  • tiny_mag_ptr->alloc_underway = TRUE; 设置当前正在申请新的 堆

  • fresh_region = mvm_allocate_pages_securely(TINY_REGION_SIZE, TINY_BLOCKS_ALIGN, VM_MEMORY_MALLOC_TINY, rack->debug_flags); 申请新的堆 --- 1M

  • ptr = tiny_malloc_from_region_no_lock(rack, tiny_mag_ptr, mag_index, msize, fresh_region); 从最近的一个 region 或者新申请的 region 中 malloc

每次调用 free 函数,会直接把要释放的内存优先放到mag_last_free 指针上,在下次 alloc 时,也会优先检查mag_last_free 是否存在大小相等的内存,如果存在就直接返回。

2.14 tiny_malloc_from_free_list & tiny_get_region_from_depot 分析

  • tiny_malloc_from_free_list函数的作用是从 free_list 中不断进行各种策略尝试。

  • 从上面的流程可以看出,在查找已经释放的内存缓存,会采用2步缓存查找(策略1,2),及两步备用内存的开辟(策略3,4)。

  • 当 free_list 流程仍然找不到可以使用内存,就会使用tiny_get_region_from_depot

每一个类型的 rack 指向的 magazines ,都会在下标为-1 , magazine_t 当做备用:depot,该方法的作用是从备用的 depot查找出是否有满足条件的 region 如果存在,更新 depot 和 region 的关联关系,然后在关联当前的magazine_t 和 region。之后在再次重复 free_list 过程

2.15 mvm_allocate_pages_securely 的分析

  • 走到这一步,就需要申请新的 heap 了,这里需要理解虚拟内存和物理内存的映射关系。

  • 你其实只要记住两点:vm_map 代表就是一个进程运行时候涉及的虚拟内存,pmap 代表的就是和具体硬件架构相关的物理内存。

  • 重新申请的核心函数为 mach_vm_map ,其概念如图



2.16  tiny_malloc_from_region_no_lock 的分析

重新申请了新的内存 (region) 之后,挂载到当前的 magazine下并分配内存。

这个方法的主要作用是把新申请的内存地址,转换为region,并进行相关的关联。及更新对应的 magazine。整个 scalable_zone 的结构体关系,及流程如下



2.17 nano_zone 总结

malloc 库会检查指针地址,如果没有问题,则以链表的形式将这些区块按大小存储起来。这些链表的头部放在 meta_data数组 中对应的 [mag][slot]元素中。

其实从缓存获取空余内存和释放内存时都会对指向这篇内存区域的指针进行检查,如果有类似地址不对齐、未释放/多次释放、所属地址与预期的 mag、slot 不匹配等情况都会以报错结束。

2.18 scalable_zone 分析

  • 首先检查指针指向地址是否有问题。
    如果 last free指针 上没有挂载内存区块,则放到 last free上。

  • 如果有 last free ,置换内存,并把 last free 原有内存区块挂载到 free list上(在挂载的 free list前,会先根据 region 位图检查前后区块是否能合并成更大区块,如果能会合并成一个)。

  • 合并后所在的 region 如果空闲字节超过一定条件,则将把此 region 放到后备的 magazine 中(-1)。

  • 如果整个 region 都是空的,则直接还给系统内核。


三、流程总结





四、拓展补充

  • malloc_zone_t 提供了一个模板类,或者理解为malloc_zone_t 提供一类接口(高度抽象了alloc一个对象所需要的特征),freecalloc等。

  • 由所有拓展的结构体来实现真正的目标函数。

  • 同上对于上层 Objc,提供了抽象接口(依赖倒置),这样就降低了调用者 (Objc) 与实现模块间的耦合。



作者:Cooci
链接:https://www.jianshu.com/p/ff4e55c9c332






收起阅读 »

iOS —— malloc分析(1)

一、malloc_zone_t 分析这个家伙是一个非常重要的家伙,我们先来看看 malloc_zone_t 的结构typedef struct _malloc_zone_t { void *reserved1; /* RESER...
继续阅读 »

一、malloc_zone_t 分析

这个家伙是一个非常重要的家伙,我们先来看看 malloc_zone_t 的结构

typedef struct _malloc_zone_t {
void *reserved1; /* RESERVED FOR CFAllocator DO NOT USE */
void *reserved2; /* RESERVED FOR CFAllocator DO NOT USE */
size_t (* MALLOC_ZONE_FN_PTR(size))(struct _malloc_zone_t *zone, const void *ptr); /* returns the size of a block or 0 if not in this zone; must be fast, especially for negative answers */
void *(* MALLOC_ZONE_FN_PTR(malloc))(struct _malloc_zone_t *zone, size_t size);
void *(* MALLOC_ZONE_FN_PTR(calloc))(struct _malloc_zone_t *zone, size_t num_items, size_t size); /* same as malloc, but block returned is set to zero */
void *(* MALLOC_ZONE_FN_PTR(valloc))(struct _malloc_zone_t *zone, size_t size); /* same as malloc, but block returned is set to zero and is guaranteed to be page aligned */
void (* MALLOC_ZONE_FN_PTR(free))(struct _malloc_zone_t *zone, void *ptr);
void *(* MALLOC_ZONE_FN_PTR(realloc))(struct _malloc_zone_t *zone, void *ptr, size_t size);
void (* MALLOC_ZONE_FN_PTR(destroy))(struct _malloc_zone_t *zone);
const char *zone_name;

unsigned (* MALLOC_ZONE_FN_PTR(batch_malloc))(struct _malloc_zone_t *zone, size_t size, void **results, unsigned num_requested);

struct malloc_introspection_t * MALLOC_INTROSPECT_TBL_PTR(introspect);
unsigned version;

void *(* MALLOC_ZONE_FN_PTR(memalign))(struct _malloc_zone_t *zone, size_t alignment, size_t size);

void (* MALLOC_ZONE_FN_PTR(free_definite_size))(struct _malloc_zone_t *zone, void *ptr, size_t size);

size_t (* MALLOC_ZONE_FN_PTR(pressure_relief))(struct _malloc_zone_t *zone, size_t goal);

boolean_t (* MALLOC_ZONE_FN_PTR(claimed_address))(struct _malloc_zone_t *zone, void *ptr);

} malloc_zone_t;


malloc_zone_t 是一个非常基础结构,里面包含一堆函数指针,用来存储一堆相关的处理函数的具体实现的地址,例如mallocfreerealloc等函数的具体实现。后续会基于malloc_zone_t进行扩展。

二、calloc 的流程

2.1  calloc -> malloc_zone_calloc 的流程


void * calloc(size_t num_items, size_t size)
{
void *retval;
retval = malloc_zone_calloc(default_zone, num_items, size);
if (retval == NULL) {
errno = ENOMEM;
}
return retval;
}
  • 这个 default_zone 其实是一个“假的”zone,同时它也是malloc_zone_t类型。它存在的目的就是要引导程序进入一个创建真正的 zone 的流程。
  • 下面来看一下 default_zone 的引导流程。

  • 2.2 default_zone 引导

    void * malloc_zone_calloc(malloc_zone_t *zone, size_t num_items, size_t size)
    {
    MALLOC_TRACE(TRACE_calloc | DBG_FUNC_START, (uintptr_t)zone, num_items, size, 0);

    void *ptr;
    if (malloc_check_start && (malloc_check_counter++ >= malloc_check_start)) {
    internal_check();
    }

    ptr = zone->calloc(zone, num_items, size);

    if (malloc_logger) {
    malloc_logger(MALLOC_LOG_TYPE_ALLOCATE | MALLOC_LOG_TYPE_HAS_ZONE | MALLOC_LOG_TYPE_CLEARED, (uintptr_t)zone,
    (uintptr_t)(num_items * size), 0, (uintptr_t)ptr, 0);
    }

    MALLOC_TRACE(TRACE_calloc | DBG_FUNC_END, (uintptr_t)zone, num_items, size, (uintptr_t)ptr);
    return ptr;
    }
  • ptr = zone->calloc(zone, num_items, size)
  • 此时传进来的 zone 的类型是 上面 calloc 传入的 defaultzone,所以 zone->calloc的调用实现要看defaultzone 的定义。

  • 2.3 defaultzone 的定义

    static virtual_default_zone_t virtual_default_zone
    __attribute__((section("__DATA,__v_zone")))
    __attribute__((aligned(PAGE_MAX_SIZE))) = {
    NULL,
    NULL,
    default_zone_size,
    default_zone_malloc,
    default_zone_calloc,
    default_zone_valloc,
    default_zone_free,
    default_zone_realloc,
    default_zone_destroy,
    DEFAULT_MALLOC_ZONE_STRING,
    default_zone_batch_malloc,
    default_zone_batch_free,
    &default_zone_introspect,
    10,
    default_zone_memalign,
    default_zone_free_definite_size,
    default_zone_pressure_relief,
    default_zone_malloc_claimed_address,
    };
    • 从上面的结构可以看出 defaultzone->calloc 实际的函数实现为 default_zone_calloc
    static void *
    default_zone_calloc(malloc_zone_t *zone, size_t num_items, size_t size)
    {
    zone = runtime_default_zone();

    return zone->calloc(zone, num_items, size);
    }
    • 引导创建真正的 zone
    • 使用真正的 zone 进行 calloc

    2.4 zone分析

    在创建正在的 zone时,其实系统是有对应的一套创建策略的。在跟踪 runtime_default_zone 方法后,最终会进入如下调用



    static void
    _malloc_initialize(void *context __unused)
    {
    ...... - 省略多余代码
    //创建helper_zone,
    malloc_zone_t *helper_zone = create_scalable_zone(0, malloc_debug_flags);
    //创建 nano zone
    if (_malloc_engaged_nano == NANO_V2) {
    zone = nanov2_create_zone(helper_zone, malloc_debug_flags);
    } else if (_malloc_engaged_nano == NANO_V1) {
    zone = nano_create_zone(helper_zone, malloc_debug_flags);
    }
    //如果上面的if else if 成立,这进入 nonazone
    if (zone) {
    malloc_zone_register_while_locked(zone);
    malloc_zone_register_while_locked(helper_zone);

    // Must call malloc_set_zone_name() *after* helper and nano are hooked together.
    malloc_set_zone_name(zone, DEFAULT_MALLOC_ZONE_STRING);
    malloc_set_zone_name(helper_zone, MALLOC_HELPER_ZONE_STRING);
    } else {
    //使用helper_zone分配内存
    zone = helper_zone;
    malloc_zone_register_while_locked(zone);
    malloc_set_zone_name(zone, DEFAULT_MALLOC_ZONE_STRING);
    }
    //缓存default_zone
    initial_default_zone = zone;
    .....
    }
    • 创建 helper_zone
    • 创建 nano zone
    • 如果上面的 if else if 成立,这进入 nonazone
    • 使用 helper_zone 分配内存
    • 缓存 default_zone

    在这里 会存在两种 zone

      1. nanozone_t
      1. scalable_zone

    2.5 nanozone_t 分析


    typedef struct nano_meta_s {
    OSQueueHead slot_LIFO MALLOC_NANO_CACHE_ALIGN;
    unsigned int slot_madvised_log_page_count;
    volatile uintptr_t slot_current_base_addr;
    volatile uintptr_t slot_limit_addr;
    volatile size_t slot_objects_mapped;
    volatile size_t slot_objects_skipped;
    bitarray_t slot_madvised_pages;
    // position on cache line distinct from that of slot_LIFO
    volatile uintptr_t slot_bump_addr MALLOC_NANO_CACHE_ALIGN;
    volatile boolean_t slot_exhausted;
    unsigned int slot_bytes;
    unsigned int slot_objects;
    } *nano_meta_admin_t;

    // vm_allocate()'d, so page-aligned to begin with.
    typedef struct nanozone_s {
    // first page will be given read-only protection
    malloc_zone_t basic_zone;
    uint8_t pad[PAGE_MAX_SIZE - sizeof(malloc_zone_t)];

    // remainder of structure is R/W (contains no function pointers)
    // page-aligned
    // max: NANO_MAG_SIZE cores x NANO_SLOT_SIZE slots for nano blocks {16 .. 256}
    //以Mag、Slot为维度,维护申请的band内存部分 slot 的范围为 1~16
    struct nano_meta_s meta_data[NANO_MAG_SIZE][NANO_SLOT_SIZE];//
    _malloc_lock_s band_resupply_lock[NANO_MAG_SIZE];
    uintptr_t band_max_mapped_baseaddr[NANO_MAG_SIZE];
    size_t core_mapped_size[NANO_MAG_SIZE];
    unsigned debug_flags;
    uintptr_t cookie;
    malloc_zone_t *helper_zone;
    } nanozone_t;
    • nanozone_t 同样是 malloc_zone_t 类型。在nano_create_zone 函数内部会完成对 calloc等函数的重新赋值。

    2.6  nano_create_zone 分析

    malloc_zone_t *
    nano_create_zone(malloc_zone_t *helper_zone, unsigned debug_flags)
    {
    nanozone_t *nanozone;
    int i, j;
    //构造nano zone
    /* Note: It is important that nano_create_zone resets _malloc_engaged_nano
    * if it is unable to enable the nanozone (and chooses not to abort). As
    * several functions rely on _malloc_engaged_nano to determine if they
    * should manipulate the nanozone, and these should not run if we failed
    * to create the zone.
    */

    // MALLOC_ASSERT(_malloc_engaged_nano == NANO_V1);

    /* get memory for the zone. */
    nanozone = nano_common_allocate_based_pages(NANOZONE_PAGED_SIZE, 0, 0, VM_MEMORY_MALLOC, 0);
    if (!nanozone) {
    _malloc_engaged_nano = NANO_NONE;
    return NULL;
    }
    //构造对zone 的一些函数进行重新赋值
    /* set up the basic_zone portion of the nanozone structure */
    nanozone->basic_zone.version = 10;
    nanozone->basic_zone.size = (void *)nano_size;
    nanozone->basic_zone.malloc = (debug_flags & MALLOC_DO_SCRIBBLE) ? (void *)nano_malloc_scribble : (void *)nano_malloc;
    nanozone->basic_zone.calloc = (void *)nano_calloc;
    nanozone->basic_zone.valloc = (void *)nano_valloc;
    nanozone->basic_zone.free = (debug_flags & MALLOC_DO_SCRIBBLE) ? (void *)nano_free_scribble : (void *)nano_free;
    nanozone->basic_zone.realloc = (void *)nano_realloc;
    nanozone->basic_zone.destroy = (void *)nano_destroy;
    nanozone->basic_zone.batch_malloc = (void *)nano_batch_malloc;
    nanozone->basic_zone.batch_free = (void *)nano_batch_free;
    nanozone->basic_zone.introspect = (struct malloc_introspection_t *)&nano_introspect;
    nanozone->basic_zone.memalign = (void *)nano_memalign;
    nanozone->basic_zone.free_definite_size = (debug_flags & MALLOC_DO_SCRIBBLE) ? (void *)nano_free_definite_size_scribble
    : (void *)nano_free_definite_size;

    nanozone->basic_zone.pressure_relief = (void *)nano_pressure_relief;
    nanozone->basic_zone.claimed_address = (void *)nano_claimed_address;

    nanozone->basic_zone.reserved1 = 0; /* Set to zero once and for all as required by CFAllocator. */
    nanozone->basic_zone.reserved2 = 0; /* Set to zero once and for all as required by CFAllocator. */

    mprotect(nanozone, sizeof(nanozone->basic_zone), PROT_READ); /* Prevent overwriting the function pointers in basic_zone. */

    /* Nano zone does not support MALLOC_ADD_GUARD_PAGES. */
    if (debug_flags & MALLOC_ADD_GUARD_PAGES) {
    malloc_report(ASL_LEVEL_INFO, "nano zone does not support guard pages\n");
    debug_flags &= ~MALLOC_ADD_GUARD_PAGES;
    }

    /* set up the remainder of the nanozone structure */
    nanozone->debug_flags = debug_flags;

    if (phys_ncpus > sizeof(nanozone->core_mapped_size) /
    sizeof(nanozone->core_mapped_size[0])) {
    MALLOC_REPORT_FATAL_ERROR(phys_ncpus,
    "nanozone abandoned because NCPUS > max magazines.\n");
    }

    /* Initialize slot queue heads and resupply locks. */
    OSQueueHead q0 = OS_ATOMIC_QUEUE_INIT;
    for (i = 0; i < nano_common_max_magazines; ++i) {
    _malloc_lock_init(&nanozone->band_resupply_lock[i]);

    for (j = 0; j < NANO_SLOT_SIZE; ++j) {
    nanozone->meta_data[i][j].slot_LIFO = q0;
    }
    }

    /* Initialize the security token. */
    nanozone->cookie = (uintptr_t)malloc_entropy[0] & 0x0000ffffffff0000ULL; // scramble central 32bits with this cookie

    nanozone->helper_zone = helper_zone;

    return (malloc_zone_t *)nanozone;
    }
    • 构造 nano zone
    • 构造对 zone 的一些函数进行重新赋值
    • Nano zone 不支持 MALLOC_ADD_GUARD_PAGES
    • 建立其余的 nanozone 结构
    • 初始化插槽队列头并重新供应锁
    • 初始化安全令牌。

    2.7 nano_calloc 分析

    过程参考 defaultzone 。回到上面 default_zone_calloc 函数内。下一步就是使用 nanozone_t 调用 calloc

    下面是 nano_calloc 的实现

    static void *
    nano_calloc(nanozone_t *nanozone, size_t num_items, size_t size)
    {
    size_t total_bytes;

    if (calloc_get_size(num_items, size, 0, &total_bytes)) {
    return NULL;
    }
    // 如果要开辟的空间小于 NANO_MAX_SIZE 则进行nanozone_t的malloc。
    if (total_bytes <= NANO_MAX_SIZE) {
    void *p = _nano_malloc_check_clear(nanozone, total_bytes, 1);
    if (p) {
    return p;
    } else {
    /* FALLTHROUGH to helper zone */
    }
    }
    //否则就进行helper_zone的流程
    malloc_zone_t *zone = (malloc_zone_t *)(nanozone->helper_zone);
    return zone->calloc(zone, 1, total_bytes);
    }
    • 如果要开辟的空间小于 NANO_MAX_SIZE 则进行
    • 否则就进行 helper_zone 的流程

    2.8 _nano_malloc_check_clear分析

    这里我们也可以看出使用 nanozone_t 的限制为不超过256B。继续看 _nano_malloc_check_clear



    static void *
    _nano_malloc_check_clear(nanozone_t *nanozone, size_t size, boolean_t cleared_requested)
    {
    MALLOC_TRACE(TRACE_nano_malloc, (uintptr_t)nanozone, size, cleared_requested, 0);

    void *ptr;
    size_t slot_key;
    // 获取16字节对齐之后的大小,slot_key非常关键,为slot_bytes/16的值,也是数组的二维下下标
    size_t slot_bytes = segregated_size_to_fit(nanozone, size, &slot_key); // Note slot_key is set here
    //根据_os_cpu_number经过运算获取 mag_index(meta_data的一维索引)
    mag_index_t mag_index = nano_mag_index(nanozone);
    //确定当前cpu对应的mag和通过size参数计算出来的slot,去对应metadata的链表中取已经被释放过的内存区块缓存
    nano_meta_admin_t pMeta = &(nanozone->meta_data[mag_index][slot_key]);
    //检测是否存在已经释放过,可以直接拿来用的内存,已经被释放的内存会缓存在 chained_block_s 链表
    //每一次free。同样会根据 index 和slot 的值回去 pMeta,然后把slot_LIFO的指针指向释放的内存。
    ptr = OSAtomicDequeue(&(pMeta->slot_LIFO), offsetof(struct chained_block_s, next));
    if (ptr) {

    ...省略无关代码

    //如果缓存的内存存在,这进行指针地址检查等异常检测,最后返回
    //第一次调用malloc时,不会执行这一块代码。
    } else {
    //没有释放过的内存,所以调用函数 获取内存
    ptr = segregated_next_block(nanozone, pMeta, slot_bytes, mag_index);
    }

    if (cleared_requested && ptr) {
    memset(ptr, 0, slot_bytes); // TODO: Needs a memory barrier after memset to ensure zeroes land first?
    }
    return ptr;
    }
    • 获取16字节对齐之后的大小, slot_key 非常关键,为slot_bytes/16 的值,也是数组的二维下下标

    • 根据 _os_cpu_number 经过运算获取 mag_index ( meta_data 的一维索引)

    • 确定当前 cpu 对应的 mag 和通过 size 参数计算出来的 slot,去对应 metadata 的链表中取已经被释放过的内存区块缓存

    • 检测是否存在已经释放过,可以直接拿来用的内存,已经被释放的内存会缓存在chained_block_s链表

    • 每一次 free。同样会根据  index 和 slot 的值回去 pMeta,然后把 slot_LIFO 的指针指向释放的内存。

    • 如果缓存的内存存在,这进行指针地址检查等异常检测,最后返回

    • 没有释放过的内存,所以调用函数 获取内存

    该方法主要是通过 cpu 与 slot 确定 index,从chained_block_s 链表中找出是否存在已经释放过的缓存。如果存在则进行指针检查之后返回,否则进入查询 meta data 或者开辟 band

    2.9 segregated_next_block 分析


    static MALLOC_INLINE void *
    segregated_next_block(nanozone_t *nanozone, nano_meta_admin_t pMeta, size_t slot_bytes, unsigned int mag_index)
    {
    while (1) {
    //当前这块pMeta可用内存的结束地址
    uintptr_t theLimit = pMeta->slot_limit_addr; // Capture the slot limit that bounds slot_bump_addr right now
    //原子的为pMeta->slot_bump_addr添加slot_bytes的长度,偏移到下一个地址
    uintptr_t b = OSAtomicAdd64Barrier(slot_bytes, (volatile int64_t *)&(pMeta->slot_bump_addr));
    //减去添加的偏移量,获取当前可以获取的地址
    b -= slot_bytes; // Atomic op returned addr of *next* free block. Subtract to get addr for *this* allocation.

    if (b < theLimit) { // Did we stay within the bound of the present slot allocation?
    //如果地址还在范围之内,则返回地址
    return (void *)b; // Yep, so the slot_bump_addr this thread incremented is good to go
    } else {
    //已经用尽了
    if (pMeta->slot_exhausted) { // exhausted all the bands availble for this slot?
    pMeta->slot_bump_addr = theLimit;
    return 0; // We're toast
    } else {
    // One thread will grow the heap, others will see its been grown and retry allocation
    _malloc_lock_lock(&nanozone->band_resupply_lock[mag_index]);
    // re-check state now that we've taken the lock
    //多线程的缘故,重新检查是否用尽
    if (pMeta->slot_exhausted) {
    _malloc_lock_unlock(&nanozone->band_resupply_lock[mag_index]);
    return 0; // Toast
    } else if (b < pMeta->slot_limit_addr) {
    //如果小于最大限制地址,当重新申请一个新的band后,重新尝试while
    _malloc_lock_unlock(&nanozone->band_resupply_lock[mag_index]);
    continue; // ... the slot was successfully grown by first-taker (not us). Now try again.
    } else if (segregated_band_grow(nanozone, pMeta, slot_bytes, mag_index)) {
    //申请新的band成功,重新尝试while
    _malloc_lock_unlock(&nanozone->band_resupply_lock[mag_index]);
    continue; // ... the slot has been successfully grown by us. Now try again.
    } else {
    pMeta->slot_exhausted = TRUE;
    pMeta->slot_bump_addr = theLimit;
    _malloc_lock_unlock(&nanozone->band_resupply_lock[mag_index]);
    return 0;
    }
    }
    }
    }
    }
    • 当前这块 pMeta 可用内存的结束地址

    • 原子的为 pMeta->slot_bump_addr 添加 slot_bytes 的长度,偏移到下一个地址

    • b -= slot_bytes 减去添加的偏移量,获取当前可以获取的地址

    • 如果地址还在范围之内,则返回地址 return (void *)b

    • pMeta->slot_exhausted 多线程的缘故,重新检查是否用尽

    • _malloc_lock_unlock(&nanozone->band_resupply_lock[mag_index]); 如果小于最大限制地址,当重新申请一个新的 band 后,重新尝试 while

    • _malloc_lock_unlock(&nanozone->band_resupply_lock[mag_index]);申请新的 band成功,重新尝试 while

    如果是第一次调用 segregated_next_block 函数,band 不存在,缓存也不会存在,所以会调用segregated_band_grow。来开辟新的 band




    收起阅读 »

    OpenGL绘制正方形并让其移动

    一.main函数里面的基本设置 在我们集成OpenGl之后,我们开始绘制正方形,首先我们倒入我们需要的东西:并且定义;main函数里面:     //设置当前工作目录,针对MAC OS X    /*...
    继续阅读 »

    一.main函数里面的基本设置

     在我们集成OpenGl之后,我们开始绘制正方形,首先我们倒入我们需要的东西:




    并且定义;



    main函数里面:

         //设置当前工作目录,针对MAC OS X

        /*

         `GLTools`函数`glSetWorkingDrectory`用来设置当前工作目录。实际上在Windows中是不必要的,因为工作目录默认就是与程序可执行执行程序相同的目录。但是在Mac OS X中,这个程序将当前工作文件夹改为应用程序捆绑包中的`/Resource`文件夹。`GLUT`的优先设定自动进行了这个中设置,但是这样中方法更加安全。

         */

        gltSetWorkingDirectory(argv[0]);

        //初始化GLUT库,这个函数只是传说命令参数并且初始化glut库

        glutInit(&argc, argv);

        /*

         初始化双缓冲窗口,其中标志GLUT_DOUBLE、GLUT_RGBA、GLUT_DEPTH、GLUT_STENCIL分别指

         双缓冲窗口、RGBA颜色模式、深度测试、模板缓冲区

      --GLUT_DOUBLE`:双缓存窗口,是指绘图命令实际上是离屏缓存区执行的,然后迅速转换成窗口视图,这种方式,经常用来生成动画效果;

         --GLUT_DEPTH`:标志将一个深度缓存区分配为显示的一部分,因此我们能够执行深度测试;

         --GLUT_STENCIL`:确保我们也会有一个可用的模板缓存区。

         深度、模板测试后面会细致讲到

         */

        glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH|GLUT_STENCIL);


        //GLUT窗口大小、窗口标题

        //glutInitWindowSize(600, 800);

        glutInitWindowSize(500, 500);

        glutCreateWindow("Triangle");


        /*

         GLUT 内部运行一个本地消息循环,拦截适当的消息。然后调用我们不同时间注册的回调函数。我们一共注册2个回调函数:

         1)为窗口改变大小而设置的一个回调函数

         2)包含OpenGL 渲染的回调函数

         */

        //注册重塑函数

        glutReshapeFunc(changeSize);

        //注册显示函数

        glutDisplayFunc(RenderScene);

        //注册特殊函数

       glutSpecialFunc(SpecialKeys);

    /*

         初始化一个GLEW库,确保OpenGL API对程序完全可用。

         在试图做任何渲染之前,要检查确定驱动程序的初始化过程中没有任何问题

         */

        GLenumstatus =glewInit();

        if(GLEW_OK!= status) {

            printf("GLEW Error:%s\n",glewGetErrorString(status));

            return1;

        }

        //设置我们的渲染环境

        setupRC();

        glutMainLoop();

    特别说明:

                        (1) //注册重塑函数glutReshapeFunc(changeSize)为初始化窗口大小,上一篇文章我们提到OpenGl没有窗口的支持,我们要创建一个窗口,这个函数会在窗口大小改变时,接收新的宽度&高度的时候重新调用



      (2)//注册显示函数glutDisplayFunc(RenderScene)为屏幕显示图形的时候调用,清除一个或者一组特定的缓存区,设置一组浮点数来表示红色(GLfloatvRed[] = {1.0,0.0,0.0,1.0f};其中表示为(r,g,b,alpha),也可以理解为OC当中的colorWithRed:<#(CGFloat)#> green:<#(CGFloat)#> blue:<#(CGFloat)#> alpha:<#(CGFloat)#>),传递到存储着色器,提交着色器,因为在屏幕渲染的时候是双缓冲区,我们还要交换缓冲区进行渲染glutSwapBuffers()


    (3)注册特殊函数 glutSpecialFunc(SpecialKeys);在iphone上,我们事件的交互是通过用户点击的,在mac上,我们只通过键盘实现用户操作,这里注册的键位以达到交互效果,


      其中GLfloatstepSize =0.025f;表示移动的快慢,可以修改,超过1.0f,已经超过屏幕界限,在OpenGL中,坐标范围是(-1,1)

                            GLfloatblockX =vVerts[0]和GLfloatblockY =vVerts[10];表示记录正方形四个顶点的某一顶点的x和y初始位置,你可以选择任何一个顶点,在移动过程中,其他顶点都是相对于这个顶点在移动并且做超出窗口的判断,类似于贪吃蛇只能在该窗口下吃,不能超出界限,在我们更新好四个顶点的位置之后,提交复制顶点数组triangleBatch.CopyVertexData3f(vVerts);重新绘制glutPostRedisplay();,这个时候就会调用 void RenderScene(void),然后在这里大家肯定很好奇为什么数组下标是01,34,67,9 10以及为什么是blockSize * 2,下面我们继续讲解

                        我们在定义顶点数组坐标:



    对应的数组下标是0,1,2,3,4,5,6,7,8,9,10,11,对应的是{x,y,z}表示一个顶点,我们移动的时候是在只是x,y轴上的坐标发生变化,而z轴上的值不会变化,所以我们的数组下标2,5,8,11不会变化,所以你看到的变换数组下标是01,34,67,9 10


    在OpenGL中,我们定义的四个顶位置如上图,以逆时针绘制,当然你也可以改为顺时针绘制,我们在设置边长的时候blockSize是相对原点坐标(0,0,0)设置的

       特别说明一下,我这里选择的相对点是A点的X和D点的Y,(你也可以选择A点的X,Y进行平移相对点的设置)

     当往上移动的时候:

                  if(key ==GLUT_KEY_UP) {,

                    blockY += stepSize;

        }


    变化的是Y轴上的值,因为我们是以D点Y坐标为相对移动的点,所以D点的Y新坐标为vVerts[10] = blockY;D点的x不变vVerts[9] = blockX;,A点的X坐标不变vVerts[0] = blockX;那此时A点的Y坐标是不是D点的新Y坐标的值减去blockSize*2(宽度*2),就是vVerts[1] = blockY -blockSize*2;是不是一下子明朗了。。。。。。。。BC点的XY坐标以此类推就会明白为什么是blockSize*2








    收起阅读 »

    iOS Block浅谈

    一.Block的本质 block本质是一个OC对象,它里面有个isa指针,封装了函数调用环境的OC对象,封装了函数调用上下文的OC对象。 Block底层结构图查看Block源码: struct __block_impl { void*isa; int...
    继续阅读 »

    一.Block的本质


        block本质是一个OC对象,它里面有个isa指针,封装了函数调用环境的OC对象,封装了函数调用上下文的OC对象。

    Block底层结构图
    查看Block源码:

    struct __block_impl {


    void*isa;

    int Flags;

    int Reserved;

    void *FuncPtr;

    };


    struct __main_block_impl_0 {


    struct __block_impl impl;


    struct__main_block_desc_0* Desc;


    // 构造函数(类似于OC的init方法),返回结构体对象


    main_block_impl_0(void*fp,structmain_block_desc_0 *desc,intflags=0) {


    impl.isa = &_NSConcreteStackBlock;

    impl.Flags = flags;

    impl.FuncPtr = fp;

    Desc = desc;

    }


    };


    // 封装了block执行逻辑的函数


    static void main_block_func_0(struct main_block_impl_0 *__cself) {


            NSLog((NSString *)&__NSConstantStringImpl__var_folders_2r__m13fp2x2n9dvlr8d68yry500000gn_T_main_c60393_mi_0);

    }

    static struct __main_block_desc_0 {


    size_treserved;


    size_tBlock_size;


    } main_block_desc_0_DATA = { 0, sizeof(struct main_block_impl_0)};


    int main(intargc,constchar* argv[]) {


    /* @autoreleasepool */{__AtAutoreleasePool__autoreleasepool;

    // 定义block变量

    void(*block)(void) = &__main_block_impl_0(

    __main_block_func_0,

    &__main_block_desc_0_DATA

    );

    // 执行block内部的代码

    block->FuncPtr(block);

    }

    return0;

    }


    说明:FuncPtr:指向调用函数的地址,__main_block_desc_0 :block描述信息,Block_size:block的大小


    二.Block变量的捕获


    2.1局部变量的捕获


        对于 block 外的变量引用,block 默认是将其复制到其数据结构中来实现访问的。也就是说block的自动变量截获只针对block内部使用的自动变量, 不使用则不截获, 因为截获的自动变量会存储于block的结构体内部, 会导致block体积变大。特别要注意的是默认情况下block只能访问不能修改局部变量的值。

    int age=10;


    void(^Block)(void)=^{


    NSLog(@”age:%d”,age);


    };


    age=20;


    Block();


    2.2__block 修饰的外部变量


        对于用 __block 修饰的外部变量引用,block 是复制其引用地址来实现访问的。block可以修改__block 修饰的外部变量的值

    __block int age=10;


    myBlock block=^{


    NSLog(@”age = %d”,age);


    };


    age=18;


    block();


    输出:18;


    auto int age=10;


    static int num=25;


    void(^Block)(void)=^{


    NSLog(@”age:%d,num:%d”,age,num);


    };


    age=20;


    num=11;


    Block();


        输出结果为:age:10,num:11,auto变量block访问方式是值传递,也就是当block定义的时候,值已经传到block里面了,static变量block访问方式是指针传递,auto自动变量可能会销毁的,内存可能会消失,不采用指针访问;static变量一直保存在内存中,指针访问即可,block不需要对全局变量捕获,都是直接采用取值的,局部变量的捕获是因为考虑作用域的问题,需要跨函数访问,就需要捕获,当出了作用域,局部变量已经被销毁,这时候如果block访问,就会出问题。

    2.2.block变量捕获机制


    block变量捕获机制
    block里访问self,self是当调用block函数的参数,参数是局部变量,self指向调用者,所以它也会捕获self,block里访问成员,成员变量的访问其实是self->xx,先捕获self,再通过self访问里面的成员变量。

    3.3Block的类型


        block的类型,取决于isa指针,可以通过调用class方法或者isa指针查看具体类型,最终都是继承自NSBlock类型

    NSGlobalBlock ( _NSConcreteGlobalBlock )全局block即数据区


    NSStackBlock ( _NSConcreteStackBlock )堆区block


    NSMallocBlock ( _NSConcreteMallocBlock )栈区block


        说明:堆区,程序员自己控制,程序员自己管理,栈区,系统自动控制,一般我们使用最多的是堆区Block,判断类型的根据是没有访问auto变量的block是__NSGlobalBlock __ ,放在数据段访问了auto变量的block是__NSStackBlock __;[__NSStackBlock __ copy]操作就变成了__NSMallocBlock __,__NSGlobalBlock __ 调用copy操作后,什么也不做__NSStackBlock __ 调用copy操作后,复制效果是:从栈复制到堆;副本存储位置是堆__NSMallocBlock __ 调用copy操作后,复制效果是:引用计数增加;副本存储位置是堆,在ARC环境下,编译器会根据情况自动将栈上的block复制到堆上的几种情况是:

    1.block作为函数返回值时

    2.将block赋值给__strong指针时

    3.block作为Cocoa API中方法名含有usingBlock的方法参数时

    4.block作为GCD API的方法参数时

    三.对象类型的auto变量


    typedefvoid(^XBTBlock)(void);


    XBTBlock block;


    {


    Person*p=[[Person alloc]init];


    p.age=10;


    block=^{


    NSLog(@”======= %d”,p.age);


    };}


    Person.m


    -(void)dealloc{


    NSLog(@”Person - dealloc”);


    }


        说明:block为堆block,block里面有一个Person指针,Person指针指向Person对象。只要block还在,Person就还在。block强引用了Person对象。在MRC下,就会打印,因为堆空间的block会对Person对象retain操作,拥有一次Person对象。无论MRC还是ARC,栈空间上的block,不会持有对象;堆空间的block,会持有对象。

    特别说明:block内部访问了对象类型的auto变量时,是否会强引用?


    栈block


    a) 如果block是在栈上,将不会对auto变量产生强引用


    b) 栈上的block随时会被销毁,也没必要去强引用其他对象


    堆block


    1.如果block被拷贝到堆上:


    a) 会调用block内部的copy函数


    b) copy函数内部会调用_Block_object_assign函数


    c) _Block_object_assign函数会根据auto变量的修饰符(strong、weak、__unsafe_unretained)做出相应的操作,形成强引用(retain)或者弱引用


    2.如果block从堆上移除


    a) 会调用block内部的dispose函数


    b) dispose函数内部会调用_Block_object_dispose函数


    c) _Block_object_dispose函数会自动释放引用的auto变量(release)


    正确答案:


    如果block在栈空间,不管外部变量是强引用还是弱引用,block都会弱引用访问对象


    如果block在堆空间,如果外部强引用,block内部也是强引用;如果外部弱引用,block内部也是弱引用


    3.2gcd的block中引用 Person对象什么时候销毁?


    eg:-(void)touchesBegan:(NSSet )toucheswithEvent:(UIEvent)event{


    Person*person = [[Personalloc]init];

    person.age=10;

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

    NSLog(@"age:%d",person.age);

    });

    NSLog(@"touchesBegan");

    }


    输出:touchesBegan


            age:10

    Person-dealloc

    说明:gcd的block默认会做copy操作,即dispatch_after的block是堆block,block会对Person强引用,block销毁时候Person才会被释放,如果上诉Person用__weak。即添加代码为__weak Person*weakPerson=person;,在Block中变成NSLog(@"age:%p",weakPerson);,它就不输出age,使用__weak修饰过后的对象,堆block会采用弱引用,无法延时Person的寿命,所以在touchesBegan函数结束后,Person就会被释放,gcd就无法捕捉到Person,gcd内部只要有强引用Person,Person就会等待执行完再销毁!如果gcd内部先强引用后弱引用,Person会等待强引用执行完毕后释放,只要强引用执行完,就不会等待后执行的弱引用,会直接释放的

    eg:-(void)touchesBegan:(NSSet )toucheswithEvent:(UIEvent)event{


    Person*person = [[Personalloc]init];

    person.age=10;

    __weakPerson*weakPerson = person;

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(4.0 * NSEC_PER_SEC)),

    dispatch_get_main_queue(), ^{

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

    NSLog(@"2-----age:%p",weakPerson);

    });

    NSLog(@"1-----age:%p",person);

    });

    NSLog(@"touchesBegan");

    }


    四.Block的修饰符


        block在修改NSMutableArray,不需要加__block,auto修饰变量,block无法修改,因为block使用的时候是内部创建了变量来保存外部的变量的值,block只有修改内部自己变量的权限,无法修改外部变量的权限。

    static修饰变量,block可以修改,因为block把外部static修饰变量的指针存入,block直接修改指针指向变量值,即可修改外部变量值。全局变量值,全局变量无论哪里都可以修改,当然block内部也可以修改。

    eg:block int age = 10,系统做了哪些—-》编译器会将block变量包装成一个对象


    __block 修饰符作用:


        __block可以用于解决block内部无法修改auto变量值的问题

    __block不能修饰全局变量、静态变量(static)

    编译器会将__block变量包装成一个对象

    __block修改变量:age->__forwarding->age

    __Block_byref_age_0结构体内部地址和外部变量age是同一地址

    __block的内存管理---->当block在栈上时,并不会对__block变量产生强引用

    block的属性修饰词为什么是copy?


        block一旦没有进行copy操作,就不会在堆上

    block在堆上,程序员就可以对block做内存管理等操作,可以控制block的生命周期,会调用block内部的copy函数

    copy函数内部会调用_Block_object_assign函数

    _Block_object_assign函数会对__block变量形成强引用(retain)

    对于__block 修饰的变量 assign函数对其强引用;对于外部对象 assign函数根据外部如何引用而引用,当block从堆中移除时,会调用block内部的dispose函数dispose函数内部会调用_Block_object_dispose函数_Block_object_dispose函数会自动释放引用的__block变量(release),当block在栈上时,对它们都不会产生强引用,当block拷贝到堆上时,都会通过copy函数来处理它们,对于__block 修饰的变量 assign函数对其强引用;对于外部对象 assign函数根据外部如何引用而引用

    block的forwarding指针说明:


        栈上__block的__forwarding指向本身

    栈上__block复制到堆上后,栈上block的__forwarding指向堆上的block,堆上block的__forwarding指向本身

    五. block循环引用


        1.ARC下如何解决block循环引用的问题?

    三种方式:__weak、__unsafe_unretained、__block

    1)第一种方式:__weak

    Person*person=[[Person alloc]init];

    // __weak Person *weakPerson = person;

    __weaktypeof(person)weakPerson=person;

    person.block=^{

    NSLog(@"age is %d",weakPerson.age);

    };

    2)第二种方式:__unsafe_unretained

    __unsafe_unretained Person*person=[[Person alloc]init];

    person.block=^{

    NSLog(@"age is %d",weakPerson.age);

    };

    3)第三种方式:__block

    __block Person*person=[[Person alloc]init];

    person.block=^{

    NSLog(@"age is %d",person.age);

    person=nil;

    };

    person.block();

    三种方法比较:weak:不会产生强引用,指向的对象销毁时,会自动让指针置为nil,unsafe_unretained:不会产生强引用,不安全,指向的对象销毁时,指针存储的地址值不变,__block:必须把引用对象置位nil,并且要调用该block


    作者:枫紫_6174
    链接:https://www.jianshu.com/p/4bde3936b154


    收起阅读 »

    OutOfMemoryError 可以被 try catch 吗?

    目录 OutOfMemoryError 可以被 try catch 吗? 捕获 OutOfMemoryError 有什么意义? JVM 中哪一块内存不会发生 OOM ? OutOfMemoryError 可以被 try catch 吗? 群里小伙伴碰到的一...
    继续阅读 »

    目录



    • OutOfMemoryError 可以被 try catch 吗?

    • 捕获 OutOfMemoryError 有什么意义?

    • JVM 中哪一块内存不会发生 OOM ?


    OutOfMemoryError 可以被 try catch 吗?


    群里小伙伴碰到的一道比较经典的面试题,但我相信很多第一次碰到这个问题的同学应该无法立刻给出答案,最好的办法肯定还是动手测一测。


    注意看下面的 Gif,每点击一次 Allocate 20MB ,都会给数组容量增加 20*1024*1024,当然应该并不是 20 MB。如下面代码所示:


    binding.allocate.setOnClickListener {
    try {
    bytes = ByteArray(bytes.size + 1024 * 1024 * 20)
    refreshMemory()
    } catch (e: OutOfMemoryError) {
    binding.oomError.text = "Catch OOM : \n ${e.message}"
    }
    }
    复制代码


    当点击第 7 次时,发生了 OutOfMemoryError ,并且 catch 代码块执行了。



    Catch OOM : Failed to allocate a 146801680 byte allocation with 25165824 free bytes and 133MB until OOM, target footprint 153948888, growth limit 268435456



    所以,OutOfMemoryError 是可以 try catch 的。


    顺道画了一个思维导图回顾一下 Java 的异常体系。



    上面的图片没有罗列出所有的异常类型,但也基本概括了 Java 异常的继承体系。所有的异常类都继承自 ThrowableThrowable 有两个直接子类 ErrorException


    Exception 一般指可以/应该捕获和处理的异常。它的两个直接子类 IOExceptionRuntimeException 及其子类都是我们在代码中经常遇到的一些错误。RuntimeException 是在程序运行中可能发生的异常,我们可以不捕获它,但可能带来 Crash 的代价,但是过多的捕获异常又不利于暴露和调试异常情况。在开发过程中,我们更多的应该及时暴露问题。除了 RuntimeException 以外,其他异常可以统称为 非运行时异常 或者 受检异常,这些异常必须被捕获,否则编译期就会报错。


    Error 一般指非正常状态的,比较严重的,不应该被捕获的系统错误。


    再回头看看 OutOfMemoryError 的父类们,



    OutOfMemoryError <- VirtualMachineError <- Error



    OutOfMemoryError 是一个 Error ,Error 不应该被捕获。那么,捕获 OutOfMemoryError 有什么意义呢?


    捕获 OutOfMemoryError 有什么意义?


    一般情况下并没有什么太大意义,相信你在开发中也几乎没有写过 catch OOM 的代码。


    如果你把捕获 OOM 当做处理 OOM 的一种手段,无疑是不合适的。你无法保证你 catch 的代码就是导致 OOM 的原因,可能它只是压死骆驼的最后一根稻草,甚至你也无法保证你的 catch 代码块中不会再次触发 OOM 。


    我也从来没有写过捕获 OOM 的代码,但无意中在 Android 源码中发现了这样的操作。在 View.javabuildDrawingCacheImpl() 方法中有这么一段代码:


    try {
    bitmap = Bitmap.createBitmap(mResources.getDisplayMetrics(),
    width, height, quality);
    bitmap.setDensity(getResources().getDisplayMetrics().densityDpi);
    if (autoScale) {
    mDrawingCache = bitmap;
    } else {
    mUnscaledDrawingCache = bitmap;
    }
    if (opaque && use32BitCache) bitmap.setHasAlpha(false);
    } catch (OutOfMemoryError e) {
    // If there is not enough memory to create the bitmap cache, just
    // ignore the issue as bitmap caches are not required to draw the
    // view hierarchy
    if (autoScale) {
    mDrawingCache = null;
    } else {
    mUnscaledDrawingCache = null;
    }
    mCachingFailed = true;
    ......
    复制代码

    buildDrawingCacheImpl() 方法的大致作用是为当前 View 生成一个 Bitmap 缓存。在构建 Bitmap 对象的时候,如果捕捉到了 OOM ,就放弃生成 Bitmap 缓存,因为在 View 的绘制过程中 Bitmap Cache 并不是必须存在的。所以在这里没有必要抛出 OOM ,而是自己捕获就可以了。


    在你自己明确知道可能发生 OOM 的情况下设置一个兜底策略,这可能是捕获 OOM 的唯一意义了。如果你有其他奇淫技巧,欢迎在评论区补充。


    JVM 中哪一块内存不会发生 OOM ?


    最后补充一道我曾经遇到过的面试题,JVM 中哪一块内存不会发生 OOM ?


    当时面试的时候一下没反应过来,回来之后翻了翻 《深入理解Java虚拟机》 。但凡是 JVM 的相关问题,基本上都可以在这本书上找到答案。以下内容均总结摘抄自这本书,也可以查看我的相关读书笔记:第2章:Java内存区域与内存移溢出异常


    Java 虚拟机在执行 Java 程序的过程中会把它所管理的内存划分为若干个不同的数据区域,如下图所示:



    Java 虚拟机栈 。每个方法被执行的时候,Java 虚拟机栈都会同步创建一个栈帧用于存储局部变量表、操作数栈、动态连接、方法出口等信息。每个方法被调用直到执行完毕的过程,就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。


    如果线程请求的栈深度大于虚拟机所允许的深度,将抛出 StackOverflowError 异常。 如果 Java 虚拟机栈支持动态扩展,当栈扩展时无法申请到足够的内存会排抛出 OutOfMemoryError 异常。


    本地方法栈。为虚拟机使用到的 Native 方法服务。《Java 虚拟机规范》对本地方法栈中方法使用的语言、使用方式和数据结构并没有任何强制规定,因此具体的虚拟机可以根据需要自由实现它。Hotspot 将本地方法栈和虚拟机栈合二为一。


    本地方法栈也会在栈深度溢出和栈扩展失败时分别抛出 StackOverflowError 和 OutOfMemoryError 。


    Java 堆。所有线程共享的一块内存区域,在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例,Java 世界里 “几乎” 所有的对象实例都在这里分配内存。在 《Java 虚拟机规范》中对 Java 堆的描述是:“所有的对象实例以及数组都应当在堆上分配”。


    Java 堆以处于物理上不连续的内存空间,但在逻辑上它应该被视为连续的。但对于大对象(典型的如数组对象),多数虚拟机实现出于实现简单、存储高效的考虑,很可能会要求连续的内存空间。


    Java 堆既可以被实现成固定大小,也可以是扩展的。如果在 Java 堆中没有内存完成实例分配,并且堆无法再扩展时,Java 虚拟机将会抛出 OutOfMemoryError 。


    方法区。方法区是各个线程共享的内存区域,它用于存储已被虚拟机加载的类型信息、常量、静态变量、即时编译器编译后的代码缓存等数据。


    虽然《Java 虚拟机规范》中把方法区描述为堆的一个逻辑部分,但是它却有一个别名叫做“非堆”,目的是与 Java 堆分开来。


    Hotspot 设计之初选择把垃圾收集器的分代设计扩展至方法区,或者说使用永久代来实现方法区而已,使得 HotSpot 的 GC 能够像管理 Java 堆一样管理这部分内存,但导致 Java 应用更容易遇到内存溢出的问题。在 JDK 8 中,彻底废弃了永久代的概念。


    如果方法区无法满足新的内存分配的需求时,将抛出 OutOfMemoryError 。


    运行时常量池。方法区的一部分。Class 文件的常量池表,用于存放编译期生成的各种字面量与符号引用,这部分内容将在类加载后方法方法去的运行时常量池。


    运行时常量池具有动态性,运行期间也可以将新的常量放入池中,如 String.intern() 。


    常量池受到方法区的限制,当无法再申请到内存时,会抛出 OutOfMemoryError 。


    唯一一个在《Java虚拟机规范》中没有规定任何 OutOfMemoryError 情况的区域是 程序计数器。程序计数器(Program Counter Register)是一块较小的内存空间,它可以看作是当前线程所执行的字节码的行号指示器。如果线程正在执行的是一个Java方法,这个计数器记录的是正在执行的虚拟机字节码指令的地址;如果正在执行的是本地(Native)方法,这个计数器值则应为空(Undefined)。


    最后


    这是专栏第五篇文章了,写作素材大多来自于身边的小伙伴。我也维护了一份 面试题文档,但考虑到共享文档比较容易造成混乱,后面也可能通过其他方式进行分享。


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

    那你讲一下LeakCanary的原理

    今天来写一波内存泄漏工具LeakCanary的分析,也整理一下之前的笔记,废话不多说,源码整起来。 我用的1.5.1版本。 LeakCanary核心源码解析 看源码还是那句话,先找入口,顺着入口看主流程。 LeakCanary监听Activity的onDes...
    继续阅读 »

    今天来写一波内存泄漏工具LeakCanary的分析,也整理一下之前的笔记,废话不多说,源码整起来。


    我用的1.5.1版本。


    LeakCanary核心源码解析


    看源码还是那句话,先找入口,顺着入口看主流程



    LeakCanary监听Activity的onDestory方法,然后介入,所以从这里开始



    发现入口在RefWatcher.watch方法里,这个RefWatcher是核心类,跟进去watch方法。



    可以看出这里开始搞事情了,先解释一下这些变量的意义



    这样就可以解释,上图watch方法里面的操作了


    使用randomUUID生成一个随机数key,并加到了一个set中,这个key跟当前监控的activity是一一对应的,这个很关键,watchedReference就是当前关闭的activity对象,然后包装成KeyedWeakReference对象,KeyedWeakReference继承了WeakReference。



    后续就是就操作这个KeyedWeakReference这个弱引用。


    到了这里就不得不提一下,强软弱虚这四个东西,如果还有不懂的小伙伴,还是要去看一下的,这里只提一下弱引用,简单来说就是。


    弱引用持有的对象被回收了,那么弱引用就会放到与之关联的引用队列中。


    ???


    讲人话!那举个栗子


    就是上面watch方法的watchedReference(就是那个被监测的activity)被KeyedWeakReference弱引用持有了,当activity被回收了,RefWatcher#queue里面就会有这个KeyedWeakReference。


    反之如果一顿操作之后queue都没有这个KeyedWeakReference,说明activity没有被回收,那么就判定为内存泄漏。


    这也是LeakCanary的核心思想。



    好,接着watch方法往下走,ensureGoneAsync方法跟进去到一个ensureGone的核心方法里



    红框这里是核心中的核心。看起来很短,但浓缩才是精华。



    removeWeaklyReachableReferences方法里就是遍历把引用队列queue里的对象,在retainsKeys这个set里面移除掉。


    讲了半天,还记得开头这个retainsKeys放的什么吗?是那个UUID生成的与每个activity一一对应的key,可以理解为activity对应的一个值。当队列有一个弱引用了,说明有一个对应activity被回收了。


    gone方法里判断retainsKeys集合里还有没有这个activity对应的值,没有说明正常回收了。


    ensureGone的整个流程基本就清楚了,理一下ensureGone的流程。


    首先根据队列的对象,移除对应set里对应的key值,gone判断是否移除成功,成功返回DONE,没有泄露结束流程,gone判断还存在,原谅ta再给一次机会,调用runGc触发回收,再次移除key值,gone判断还存在,不好意思,没有机会了,使用heapDumper.dumpHeap出调用链,showNotification展示到通知栏,最后展示到DisplayLeakActivity页面上。


    最后还是弱引用基础知识的应用,所以说为什么大厂喜欢问基础知识,其实很多东西都是构建在基础知识之上。


    关于gc的补充点


    这里补充一点东西,也是之前被某厂问到了,当时没答出来的,主要是之前没看那么细,后面又翻了一下源码。



    当时问的是上面gc的时候,是怎么gc的?第二次removeWeaklyReachableReferences是什么时候触发的?


    当时想的是gc不都是System.gc嘛,还能有什么骚操作?回来打开一下源码,咦,发现还真有。。


    那从GCTrigger入手了。



    发现runGc里面不是直接调用System.gc的,用了一个Runtime.getRuntime().gc(),这是啥?



    然后看见上面一堆注释还贴了源码url,觉得事情很重要,静下心来用我多年修炼来的四级的英语阅读能力扫了一遍。


    简单来说就是,作者从AOSP那里Ctrl+c来了一段代码,因为System.gc()不能保证每次gc而Runtime.gc()会相对更可靠。


    然后调用了enqueuReferences方法,里面就直接sleep了100ms,简单粗暴。。作者对于此的解释是没有很好能够获取到对象真正加入到队列的时机,所以直接等100ms让回收,100ms后执行runFinalization,然后就可以去第二次remove。


    好家伙一个类就解答了两个问题,核心流程写完了,这次先写到这里,第一次用掘金,不知道掘金文章支不支持后续编辑,后续再补充一波


    谢谢,朋友们


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

    【android每日一问】怎么检测UI卡顿?(线上及线下)

    什么是UI卡顿? 在Android系统中,我们知道UI线程负责我们所有视图的布局,渲染工作,UI在更新期间,如果UI线程的执行时间超过16ms,则会产生丢帧的现象,而大量的丢帧就会造成卡顿,影响用户体验。 UI卡顿产生的原因? 在UI线程中做了大量的耗时操作...
    继续阅读 »

    什么是UI卡顿?


    在Android系统中,我们知道UI线程负责我们所有视图的布局,渲染工作,UI在更新期间,如果UI线程的执行时间超过16ms,则会产生丢帧的现象,而大量的丢帧就会造成卡顿,影响用户体验。


    UI卡顿产生的原因?



    • 在UI线程中做了大量的耗时操作,导致了UI刷新工作的阻塞。

    • 系统CPU资源紧张,APP所能分配的时间片减少。

    • Ardroid虚拟机频繁的执行GC操作,导致占用了大量的系统资源,同时也会导致UI线程的短暂停顿,从而产生卡顿。

    • 代码编写不当,产生了过度绘制,导致CPU执行时间变长,早场卡顿。


    从上可知,大部分的卡顿原因都产生于代码编写不当导致,而这类问题都可以通过各种优化方案进行优化,所以我们需要做的就是尽可能准确的找到卡顿的原因,定位到准确的代码模块,最好是能定位到哪个方法导致卡顿,这样我们APP的性能就能得到很大的提升。


    UI卡顿方案



    • 开发阶段


    在开发阶段我们可以借助开发工具为我们提供的各种便利来有效的识别卡顿,如下:


    System Trace


    具体使用可以看blog.csdn.net/u011578734/…
    写的文章。


    Android CPU Profiler



    • Android Studio CPU 性能剖析器可实时检查应用的 CPU 使用率和线程活动。你还可以检查方法跟踪记录、函数跟踪记录和系统跟踪记录中的详细信息。

    • 使用CPU profiler可以查看主线程中,每个方法的耗时情况,以及每个方法的调用栈,可以很方便的分析卡顿产生的原因,以及定位到具体的代码方法。


    具体使用方法可以参考
    blog.csdn.net/u011578734/…


    线上UI卡顿检测方案


    线上检测方案比较流行的是BlockCanary和WatchDog,下面我们就看看它们是怎么做到检测UI卡顿的并反馈给开发人员。


    BlockCanary



    • BlockCanary能检测到主线程的卡顿, 并将结果记录下来, 以友好的方式展示,很类似于LeakCanary的展示。


    BlockCanary的使用很简单,只要在Application中进行设置一下就可以如下:


    BlockCanary.install(this, new AppBlockCanaryContext()).start();
    复制代码


    • AppBlockCanaryContext继承自BlockCanaryContext是对BlockCanary中各个参数进行配置的类


    可配置参数如下:


    //卡顿阀值
    int getConfigBlockThreshold();
    boolean isNeedDisplay();
    String getQualifier();
    String getUid();
    String getNetworkType();
    Context getContext();
    String getLogPath();
    boolean zipLogFile(File[] src, File dest);
    //可将卡顿日志上传到自己的服务
    void uploadLogFile(File zippedFile);
    String getStackFoldPrefix();
    int getConfigDumpIntervalMillis();
    复制代码


    • 在某个消息执行时间超过设定的标准时会弹出通知进行提醒,或者上传。


    原理


    熟悉Android的Handler机制的同学一定知道,Handler中重要的组成部分,looper,并且应用的主线程只有一个Looper存在,不管有多少handler,最后都会回到这里。
    我们注意到Looper.loop()中有这么一段代码:


    public static void loop() {
    ...

    for (;;) {
    ...

    // This must be in a local variable, in case a UI event sets the logger
    Printer logging = me.mLogging;
    if (logging != null) {
    logging.println(">>>>> Dispatching to " + msg.target + " " +
    msg.callback + ": " + msg.what);
    }

    msg.target.dispatchMessage(msg);

    if (logging != null) {
    logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
    }

    ...
    }
    }
    复制代码

    注意到两个很关键的地方是logging.println(">>>>> Dispatching to " + msg.target + " " + msg.callback + ": " + msg.what);logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);这两行代码,它调用的时机正好在dispatchMessage(msg)的前后,而主线程卡也就是在dispatchMessage(msg)卡住了。


    BlockCanary的流程图


    (图片来自网络)


    blockcanary_flow.png


    BlockCanary就是通过替换系统的Printer来增加了一些我们想要的堆栈信息,从而满足我们的需求。


    替换原有的Printer是通过以下方法:


    Looper.getMainLooper().setMessageLogging(mainLooperPrinter);
    复制代码

    并在mainLooperPrinter中判断start和end,来获取主线程dispatch该message的开始和结束时间,并判定该时间超过阈值(如2000毫秒)为主线程卡慢发生,并dump出各种信息,提供开发者分析性能瓶颈。如下所示:


    @Override
    public void println(String x) {
    if (!mStartedPrinting) {
    mStartTimeMillis = System.currentTimeMillis();
    mStartThreadTimeMillis = SystemClock.currentThreadTimeMillis();
    mStartedPrinting = true;
    startDump();
    } else {
    final long endTime = System.currentTimeMillis();
    mStartedPrinting = false;
    if (isBlock(endTime)) {
    notifyBlockEvent(endTime);
    }
    stopDump();
    }
    }

    private boolean isBlock(long endTime) {
    return endTime - mStartTimeMillis > mBlockThresholdMillis;
    }
    复制代码


    • BlockCanary dump的信息包括如下:


    基本信息:安装包标示、机型、api等级、uid、CPU内核数、进程名、内存、版本号等
    耗时信息:实际耗时、主线程时钟耗时、卡顿开始时间和结束时间
    CPU信息:时间段内CPU是否忙,时间段内的系统CPU/应用CPU占比,I/O占CPU使用率
    堆栈信息:发生卡慢前的最近堆栈,可以用来帮助定位卡慢发生的地方和重现路径
    复制代码


    • 获取系统状态信息是通过如下代码实现:


    threadStackSampler = new ThreadStackSampler(Looper.getMainLooper().getThread(),
    sBlockCanaryContext.getConfigDumpIntervalMillis());
    cpuSampler = new CpuSampler(sBlockCanaryContext.getConfigDumpIntervalMillis());
    复制代码

    下面看一下ThreadStackSampler是怎么工作的?


    protected void doSample() {
    // Log.d("BlockCanary", "sample thread stack: [" + mThreadStackEntries.size() + ", " + mMaxEntryCount + "]");
    StringBuilder stringBuilder = new StringBuilder();

    // Fetch thread stack info
    for (StackTraceElement stackTraceElement : mThread.getStackTrace()) {
    stringBuilder.append(stackTraceElement.toString())
    .append(Block.SEPARATOR);
    }
    // Eliminate obsolete entry
    synchronized (mThreadStackEntries) {
    if (mThreadStackEntries.size() == mMaxEntryCount && mMaxEntryCount > 0) {
    mThreadStackEntries.remove(mThreadStackEntries.keySet().iterator().next());
    }
    mThreadStackEntries.put(System.currentTimeMillis(), stringBuilder.toString());
    }
    }
    复制代码

    直接去拿主线程的栈信息, 每半秒去拿一次, 记录下来, 如果发生卡顿就显之显示出来
    拿CPU的信息较麻烦, 从/proc/stat下面拿实时的CPU状态, 再从/proc/" + mPid + "/stat中读取进程时间, 再计算各CPU时间占比和CPU的工作状态.


    基于系统WatchDog原理来实现



    • 启动一个卡顿检测线程,该线程定期的向UI线程发送一条延迟消息,执行一个标志位加1的操作,如果规定时间内,标志位没有变化,则表示产生了卡顿。如果发生了变化,则代表没有长时间卡顿,我们重新执行延迟消息即可。


    public class WatchDog {
    private final static String TAG = "budaye";
    //一个标志
    private static final int TICK_INIT_VALUE = 0;
    private volatile int mTick = TICK_INIT_VALUE;
    //任务执行间隔
    public final int DELAY_TIME = 4000;
    //UI线程Handler对象
    private Handler mHandler = new Handler(Looper.getMainLooper());
    //性能监控线程
    private HandlerThread mWatchDogThread = new HandlerThread("WatchDogThread");
    //性能监控线程Handler对象
    private Handler mWatchDogHandler;

    //定期执行的任务
    private Runnable mDogRunnable = new Runnable() {
    @Override
    public void run() {
    if (null == mHandler) {
    Log.e(TAG, "handler is null");
    return;
    }
    mHandler.post(new Runnable() {
    @Override
    public void run() {//UI线程中执行
    mTick++;
    }
    });
    try {
    //线程休眠时间为检测任务的时间间隔
    Thread.sleep(DELAY_TIME);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    //当mTick没有自增时,表示产生了卡顿,这时打印UI线程的堆栈
    if (TICK_INIT_VALUE == mTick) {
    StringBuilder sb = new StringBuilder();
    //打印堆栈信息
    StackTraceElement[] stackTrace = Looper.getMainLooper().getThread().getStackTrace();
    for (StackTraceElement s : stackTrace) {
    sb.append(s.toString() + "\n");
    }
    Log.d(TAG, sb.toString());
    } else {
    mTick = TICK_INIT_VALUE;
    }
    mWatchDogHandler.postDelayed(mDogRunnable, DELAY_TIME);
    }
    };

    /**
    * 卡顿监控工作start方法
    */
    public void startWork(){
    mWatchDogThread.start();
    mWatchDogHandler = new Handler(mWatchDogThread.getLooper());
    mWatchDogHandler.postDelayed(mDogRunnable, DELAY_TIME);
    }
    }

    复制代码


    • 调用startWork即可开启卡顿检测。

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

    Android逆向之https

    介绍HTTP协议发展史、状态码、方法,整理了几乎所有常见的头部,讲述TLS的单向认证流程,Android中HTTPS抓包方法、防抓包策略以及绕过防抓包策略思路。 HTTP协议 超文本传输协议,是一个基于请求与响应,无状态的,应用层的协议,常基于TCP/IP协...
    继续阅读 »

    介绍HTTP协议发展史、状态码、方法,整理了几乎所有常见的头部,讲述TLS的单向认证流程,Android中HTTPS抓包方法、防抓包策略以及绕过防抓包策略思路。



    HTTP协议


    超文本传输协议,是一个基于请求与响应,无状态的,应用层的协议,常基于TCP/IP协议传输数据,互联网上应用层最为广泛的一种网络协议。


    发展史















































    协议发展说明
    HTTP/0.91991年定稿最早的HTTP协议,没有作为正式标准只有GET命令;没有请求头、请求体、返回头;服务器只能读取HTML文件以ASCII字符流返回给客户端;默认80端口
    HTTP/1.01996年发布,正式作为标准引入了POST、HEAD等命令、请求头、响应头、状态码;提供了缓存、多字符集支持、multi-part、authorization、内容编码等;默认不是持久连接
    HTTP/1.11997年发布,2015年前使用最广默认持久连接不必声明keep-alive;引入pipelining管道机制,同一TCP连接里同时发送多个请求,但服务器需按照请求顺序串行返回响应;请求头新增Host,使同一台物理服务器可以同时部署多个web服务
    HTTPS互联网巨头大力推行在传统HTTP协议的TCP与HTTP之间加入一层SSL/TLS;通过混合加密、摘要算法、数字证书来保证安全性;使用443端口
    SPDY2009年由Google公开,不是标准已逐渐被HTTP/2取代基于TLS,在HTTPS的SSL层与HTTP层之间增加一层SPDY层;支持多路复用,可在同一TCP连接并发处理多个HTTP请求;可以赋予请求的优先级顺序;支持请求头和响应头压缩;支持服务器向客户端主动推送、提示
    HTTP/22015年发布,逐步覆盖市场基于SPDY的标准化协议,可在TCP上使用不是必须在TLS上;HTTPS连接时使用了NPN的规范版ALPN;消息头的压缩算法采用新算法HPACK,而SPDY采用DEFLATE;依然没有解决TCP对头阻塞问题
    QUIC/HTTP32012由Google提出,2015年提交给IETF,下一代互联网标准传输协议不再是基于TCP而是通过UDP;使用 stream 进一步扩展了 HTTP/2 的多路复用;引入 Connection ID,使得 HTTP/3 支持连接迁移以及 NAT 的重绑定;含有一个包括验证、加密、数据及负载的 built-in 的TLS安全机制;将拥塞控制移出了内核,通过用户空间来实现;头部压缩更换成了兼容 HPACK的QPACK压缩方案

    状态码


    状态码由三个十进制数字组成,第一个十进制数字定义了状态码的类型,共分为5种类型:































    分类说明
    1**表示请求已被接受,需要继续处理的临时响应
    2**成功,操作被成功接收并处理
    3**重定向,需要进一步的操作以完成请求
    4**客户端错误,请求包含语法错误或无法完成请求
    5**服务器错误,服务器在处理请求的过程中发生了错误

    方法


    方法的名称区分大小写,并且通常是一个简短的单词,由英文大写字母组成。


    接收请求时,服务器尝试确定请求的方法,如果失败,则返回带有代码 501 和短语的响应消息 Not Implemented






























































    方法说明1.0、1.1中支持的协议版本
    GET获取资源1.0、1.1
    POST传输实体主体1.0、1.1
    PUT传输文件1.0、1.1
    HEAD获得报文首部1.0、1.1
    DELETE删除资源1.0、1.1
    OPTIONS删除资源1.0、1.1
    TRACE追踪路径1.1
    CONNECT将服务器作为代理,让服务器代替用户去访问1.1
    LINK建立和资源之间的联系1.0
    UNLINK断开连接关系1.0

    首部


    http首部主要分为五大部分:



    1. 通用首部:各种类型的报文(请求、响应报文)都可以使用,提供有关报文最基本的信息。

    2. 请求首部:专用于请求报文的首部,用于给服务器提供相关信息,告诉服务器客户端的期望和能力。

    3. 响应首部:专用于响应报文的首部,用于告诉客户端是谁在响应以及响应者的能力。

    4. 实体首部:用于描述http报文的负荷(主体),提供了有关实体及其内容的相关信息。

    5. 扩展首部:非标准首部,由应用开发者定义的首部。


    (以下整理的首部并非完全按照这五类划分,部分扩展首部也按照功能划入了请求首部、响应首部等部分)


    通用首部

























































    字段名说明示例
    Cache-Control控制缓存的行为Cache-Control: no-cache
    Connection逐跳首部、连接的管理(HTTP/1.1默认持久连接)Connection: close
    Date创建报文的日期时间Date: Tue, 15 Nov 2010 08:12:31 GMT
    PragmaHTTP/1.1之前版本的历史遗留字段,用来包含实现特定的指令Pragma: no-cache
    Trailer说明传输中分块编码的编码信息Trailer: Max-Forwards
    Transfer-Encoding逐跳首部,指定传输报文主体时使用的编码方式Transfer-Encoding: chunked
    Upgrade升级为其他协议Upgrade: HTTP/2.0, SHTTP/1.3, IRC/6.9, RTA/x11
    Via代理服务器的相关信息Via: 1.0 fred, 1.1 nowhere.com (Apache/1.1)
    Warning错误通知Warning: 199 Miscellaneous warning

    请求首部





























































































































































    字段说明示例
    Accept客户端能够接收的内容类型Accept: text/plain, text/html
    Accept-Charset客户端可以接受的字符编码集Accept-Charset: iso-8859-5
    Accept-Encoding端到端首部,告知服务器客户端能够处理的编码方式和相对优先级Accept-Encoding: compress, gzip
    Accept-Language客户端可接受的自然语言Accept-Language: en,zh
    AuthorizationWeb认证信息Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==
    DNT指示该用户的跟踪的偏好:0用户更喜欢在目标站点上进行跟踪;1用户不希望在目标站点上跟踪DNT: 1
    Expect客户端要求的特殊服务器行为。若服务器不能理解或者满足,则须返回417状态,或者如果请求有其他问题,返回4xx状态Expect: 100-continue
    Forwarded代理服务器的客户端的信息,此标头标准版本是X-Forwarded-For,X-Forwarded-Host与X-Forwarded-ProtoForwarded: for=192.0.2.60; proto=http; by=203.0.113.43
    From用户的电子邮箱地址From: user@email.com
    Host指定请求的服务器的域名和端口号Host: www.zcmhi.com
    If-Match当客户端If-Match的值若与服务端的ETag一致,才会执行请求,否则会拒绝412If-Match: W/"67ab43", "54ed21", "7892dd"
    If-Modified-Since若If-Modifed-Since字段值早于资源的更新时间,则希望服务端能处理该请求f-Modified-Since: Sat, 29 Oct 2010 19:43:31 GMT
    If-None-Match如果内容未改变返回304代码,参数为服务器先前发送的Etag,与服务器回应的Etag比较判断是否改变If-None-Match: “737060cd8c284d8af7ad3082f209582d”
    If-Range告知服务器若指定的If-Range字段值和请求资源的ETag值一致时,则作为范围请求处理,否则返回全部资源If-Range: “737060cd8c284d8af7ad3082f209582d”
    If-Unmodified-Since比较资源的更新时间,与If-Modified-Since相反If-Unmodified-Since: Sat, 29 Oct 2010 19:43:31 GMT
    Max-Forwards该字段以十进制整数形式指定可经过的服务器最大数目。服务器在往下一个服务器转发请求之前,会将Max-Forwards的值减1后重新赋值,当服务器接收到Max-Forwards值为0的请求时,则不再进行转发,而是直接返回响应Max-Forwards: 10
    Proxy-Authorization代理服务器要求客户端的认证信息Proxy-Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==
    Public-Key-Pins将特定的加密公钥与特定的Web务器相关联,以降低伪造证书对MITM攻击的风险Public-Key-Pins: pin-sha256=""; pin-sha256=""; max-age=5184000; includeSubDomains; report-uri=""
    Public-Key-Pins-Report-Only将针对违规的报告发送到头中report-uri指定的报告,但是,Public-Key-Pins如果违反了钉住规则,仍然允许浏览器连接到服务器Public-Key-Pins-Report-Only: pin-sha256="; pin-sha256=""; includeSubDomains; report-uri=""
    Range实体的节点范围请求Range: bytes=5001-10000
    Referer指定该请求是从哪个页面跳转页来的,常被用于分析用户来源等信息Referer: www.example.com/index.html
    Referrer-Policy用于过滤Referrer报头的策略Referrer-Policy: origin-when-cross-origin
    CookieHTTP请求发送时,会把保存在该请求域名下的所有cookie值一起发送给web服务器Cookie: $Version=1; Skin=new;
    TE逐跳首部,告知服务器客户端能够处理的编码方式和相对优先级TE: gzip, deflate; q=0.5
    Upgrade-Insecure-Requests向服务器发送一个信号,表示客户对加密和认证响应的偏好,Upgrade-Insecure-Requests: 1
    User-AgentHTTP 客户端程序的信息User-Agent: Mozilla/5.0 (Linux; X11)
    X-Forwarded-For来表示 HTTP 请求端真实 IPX-Forwarded-For: IP0, IP1, IP2
    X-Forwarded-Host可用于确定最初使用哪个主机X-Forwarded-Host: id42.example-cdn.com
    X-Forwarded-Proto确定客户端和负载平衡器之间使用的协议确定客户端和负载平衡器之间使用的协议

    响应首部






































































































    字段说明示例
    Accept-Ranges是否接受字节范围请求Accept-Ranges: bytes
    Age从原始服务器到代理缓存形成的估算时间(以秒计,非负)Age: 12
    ETag资源的匹配信息ETag: “737060cd8c284d8af7ad3082f209582d”
    Expires响应过期的日期和时间Expires: Thu, 01 Dec 2010 16:00:00 GMT
    Location配合 3xx : Redirection 的响应,提供重定向的 URILocation: www.example.com
    Proxy-Authenticate代理服务器对客户端的认证方式Proxy-Authenticate: Basic
    Retry-After如果实体暂时不可取,通知客户端在指定时间之后再次尝试Retry-After: 120
    Set-CookieHttp CookieSet-Cookie: status-enable; expires=Tue, 05 Jul 2018 02:01:22 GMT; path=/; domain=.example.com;
    Serverweb服务器信息Server: Apache/1.3.27 (Unix) (Red-Hat/Linux)
    SourceMap响应报头链接生成的代码到一个源映射,使浏览器来重构原始源并在调试器呈现重构原始SourceMap: /path/to/file.js.map
    Strict-Transport-Security通常缩写为HSTS,告诉客户端它应该只使用HTTPS,而不是使用HTTP进行通信Strict-Transport-Security: max-age=31536000; includeSubDomains
    Tk显示了对相应请求的跟踪情况Tk: ! (under construction) Tk: ? (dynamic) Tk: G (gateway or multiple parties)
    Vary告知下游的代理服务器,应当如何对以后的请求协议头进行匹配,以决定是否可使用已缓存的响应内容而不是重新从原服务器请求新的内容Vary: Accept-Encoding,User-Agent
    WWW-Authenticate表明客户端请求实体应该使用的授权方案WWW-Authenticate: Basic
    X-Content-Type-Options如果服务器发送响应头 "X-Content-Type-Options: nosniff",则script和styleSheet元素会拒绝包含错误的 MIME 类型的响应。这是一种安全功能,有助于防止基于 MIME 类型混淆的攻击X-Content-Type-Options: nosniff
    X-DNS-Prefetch-Control控制浏览器的DNS预读取功能X-DNS-Prefetch-Control: on
    X-Frame-Options给浏览器指示允许一个页面可否在 , 或者 中展现的标记,网站可以使用此功能,来确保自己网站的内容没有被嵌套到别人的网站中去,也从而避免了点击劫持的攻击X-Frame-Options: ALLOW-FROM example.com/
    X-XSS-Protection是 IE,Chrome 和 Safari 的一个特性,当检测到跨站脚本攻击 (XSS)时,浏览器将停止加载页面X-XSS-Protection: 1; mode=block

    实体首部



































































    字段说明示例
    Allow服务器支持的HTTP请求方法Allow: GET, HEAD
    Content-Disposition指示回复的内容是以内联的形式还是以附件的形式下载并保存到本地;也可在multipart/form-data 类型的应答消息体中,用来给出其对应字段的相关信息Content-Disposition: attachment; filename="filename.jpg"
    Content-Encoding告知客户端服务器对实体的主体选用的内容编码方式Content-Encoding: gzip
    Content-Language实体主体使用的自然语言Content-Language: zh-CN
    Content-Length实体部分大小Content-Length: 15000
    Content-Location返回报文主体返回资源对应的URIContent-Location: httpo://www.example.com/index.html
    Content-MD5检查报文主体在传输过程中是否保持完整,对报文主体执行 MD5 算法获得218位二进制数,再通过 Base64 编码后将结果写入Content-MD5: ZTEwYWRjMzk0OWJhNTlhYmJlNTZlMDU3ZjIwZjg4M2U=
    Content-Range针对范围请求,表示当前发送部分及整个实体大小Content-Range: bytes 5001-10000/10000
    Content-type实体主体内对象的媒体类型Content-Type: text/html; charset=utf-8
    Expires将资源失效日期告知客户端Expires: Wed, 04 Jul 2012 08:26:05 GMT
    Last-Modified资源最终修改时间Last-Modified: wed, 25 May 2018 09:11:40 GMT

    跨域资源共享首部


    跨域资源共享标准新增了一组HTTP头部字段,属于扩展首部,允许服务器声明哪些源站通过浏览器有权限访问哪些资源。另外,对那些可能对服务器产生副作用的HTTP请求方法,浏览器必须先使用OPTIONS方法发起一个预检请求,从而获知服务器是否允许该跨域请求。服务器允许后才发起实际的HTTP请求。预检请求的返回中,服务器也可以通知客户端是否需要携带身份凭证。




















































    字段说明示例
    Access-Control-Allow-Credentials指示的请求的响应是否可以暴露于该页面,当true值返回时它可以被暴露,凭证是 Cookie ,授权标头或 TLS 客户端证书Access-Control-Allow-Credentials: true
    Access-Control-Allow-Headers用于预检请求中,列出了将会在正式请求的Access-Control-Request-Headers字段中出现的首部信息Access-Control-Allow-Headers: X-Custom-Header
    Access-Control-Allow-Methods在对预检请求的应答中明确了客户端所要访问的资源允许使用的方法或方法列表Access-Control-Allow-Methods: POST, GET, OPTIONS
    Access-Control-Allow-Origin指定了该响应的资源是否被允许与给定的origin共享Access-Control-Allow-Origin: developer.mozilla.org
    Access-Control-Expose-Headers出了哪些首部可以作为响应的一部分暴露给外部Access-Control-Expose-Headers: Content-Length, X-Kuma-Revision
    Access-Control-Max-Age表示预检请求的返回结果(即 Access-Control-Allow-Methods 和Access-Control-Allow-Headers 提供的信息)可以被缓存多久Access-Control-Max-Age: 600
    Access-Control-Request-Headers出现于预检请求中,用于通知服务器在真正的请求中会采用哪些请求头Access-Control-Request-Headers: X-PINGOTHER, Content-Type
    Access-Control-Request-Method出现于预检请求中,用于通知服务器在真正的请求中会采用哪种HTTP方法Access-Control-Request-Method: POST

    安全性的不足



    1. 通信使用明文,内容可能会被窃听(可窃听)。

    2. 无法证明报文的完整性,内容有可能已遭篡改(可篡改)。

    3. 不验证通信方的身份,因此有可能遭遇伪装(可冒充)。


    HTTPS协议


    可以理解为HTTP+SSL/TLS, 即 HTTP 下加入 SSL/TLS 层,用于安全的 HTTP 数据传输,简单来说HTTP + 加密 + 认证 + 完整性保护 = HTTPS,用来解决HTTP协议安全性的不足。


    HTTPS


    SSL/TLS历史


    HTTPS相比HTTP多出了SSL/TLS 层,SSL 协议原本由网景公司开发,后来被 IETF 标准化,正式名称叫做 TLS,TLS 1.0通常被标示为SSL 3.1,TLS 1.1为SSL 3.2,TLS 1.2为SSL 3.3,TLS1.1和TLS1.0不支持HTTP2,目前应用最广泛的应该还是 TLS 1.2,SSL协议发展历史如下:















































    协议发布时间状态
    SSL 1.0未公布未公布
    SSL 2.01995年已于2011年弃用 RFC6176
    SSL 3.01996年已于2015年弃用 RFC7568
    TLS 1.01999年RFC2246
    TLS 1.12006年RFC4346
    TLS 1.22008年RFC5246,目前最广泛应用
    TLS 1.32018年RFC8446

    TLS1.2单向认证流程


    以目前使用最广泛的TLS1.2说明下认证流程即握手流程,认证分为单向和双向两种模式,单向认证客户端验证服务端证书合法即可访问,一般Web应用都是采用SSL单向认证的;双向认证需要客户端和服务器都需要持有证书,两者证书验证均合法才可以继续访问。


    使用wireshark抓包TLS1.2,单向认证流程如下:
    wireshark抓包TLS1.2




    1. 客户端发送Client Hello。将一个Unix时间戳、TLS版本、支持的所有加密套件、支持的签名算法、生成的随机数Random_C等发送给服务器。




    2. 服务器发送Server Hello。将服务器Unix时间戳、生成的随机数Random_S、协商的加密算法套件等发送给客户端。




    3. 服务器发送Certificate、Server Key Exchange、Server Hello Done。Certificate是数字证书,Server Key Exchange为公钥参数(有时也可不需要),Server Hello Done表明服务器已经将所有预计的握手消息发送完毕。




    4. 客户端发送Client Key Exchange、Change Cipher Spec、Encrypted Handshake Message。客户端首先需要校验证书,证书向上按照证书链逐级校验,每一级证书校验过程是通过拿到证书签发者(Issuer)的证书中的公钥(证书 = 使用者公钥 + 主体信息如公司名称等 + CA对信息的确认签名 + 指纹)对本级证书(Subject)的签名进行数学验证,并校验证书是否被吊销,是否在有效期,是否与域名匹配等,验证成功即证书有效,整个一级一级验证上去,形成信任链,如果校验不通过则中断连接,浏览器弹出警告,校验正确后解析得到服务器公钥,并发送Client Key Exchange、Change Cipher Spec、Encrypted Handshake Message。Client Key Exchange:生成一个随机数 Pre-master,并用证书公钥加密,通过Fuc(random_C, random_S, Pre-Master)生成一个协商密钥;Change Cipher Spec:通知服务器协商完成,以后就使用上面生成的协商密钥进行对称加密;Encrypted Handshake Message:结合之前所有通信参数的 hash 值与其它相关信息生成一段数据,采用协商密钥与算法进行加密。




    5. 服务器发送Change Cipher Spec、Encrypted Handshake Message。服务器使用私钥解密得到 Pre-master数值,基于之前交换的两个明文随机数 random_C 和 random_S,同样通过Fuc(random_C, random_S, Pre-Master)得到协商密钥,计算之前所有接收信息的 hash 值,然后解密客户端发送的 encrypted_handshake_message,验证数据和密钥正确性,验证通过之后,服务器同样发送 change_cipher_spec 以告知客户端后续的通信都采用协商的密钥与算法进行加密通信;encrypted_handshake_message:服务器也结合所有当前的通信参数信息生成一段数据并采用协商密钥与算法加密并发送到客户端。




    6. 客户端计算所有接收信息的hash值,并采用协商密钥解密encrypted_handshake_message,验证服务器发送的数据和密钥,验证通过则握手完成。




    7. 开始使用协商密钥与算法进行加密通信。(Encrypted Alert是由客户端或服务器发送,意味着加密通信因为某些原因需要中断,警告对方不要再发送敏感的数据)。




    Android抓包HTTPS


    HTTP/HTTPS抓包工具有不少,常见的电脑端抓包工具有fiddlerCharlesBurp SuitewhistleAnyProxy,Android端抓包APP也有HttpCanary,wireshark也可以抓包但是不可以解密HTTPS内容。


    使用Charles抓包安卓HTTP很简单,将手机WIFI设置代理为Charles,步骤如下:



    1. 为方便设置代理,使手机与电脑处于同一局域网(连接同一个WIFI,或者电脑连到同一个路由器的LAN端口)。

    2. 电脑使用ipconfig查看局域网ip,并打开Charles。

    3. 手机连接的WIFI--高级设置--代理服务器,代理服务器填写电脑的局域网ip,Charles的代理端口默认8888。

    4. 电脑端Charles允许连接即可。

    5. Charles--Proxy--SSL Proxying Setting,Enable SSL Proxying打勾,add添加抓包的Host和Port,一般Port都是443,Host和Port都填*则抓包所有。


    打开APP就能在Charles上看到抓包的HTTP,但是HTTPS都会显示为Unknown,因为还没有安装Charles的证书。手机设置代理以后,浏览器访问chls.pro/ssl下载Charles证书并安装。Android 7.0以下直接安装即可,但是Android 7.0及以上默认不信任用户自己安装的证书,而只信任系统预设的证书,解决方法有:




    • 手动制作Charles证书,按照Android系统预设的格式,并推到/system/etc/security/cacerts目录下,从而让系统把Charles证书当作系统证书




    • 如果使用Magisk实现的root,Magisk安装MagiskTrustUserCerts模块,模块原理同上,可以把自定义的用户证书当作系统证书




    • 反编译apk,资源文件中添加network_security_config.xml,修改AndroidManifest.xml(修改APP的网络安全配置,信任用户证书)


      AndroidManifest.xml修改:




      ...


      复制代码

      network_security_config.xml内容:











      复制代码



    • frida或者xposed hook实现证书信任


      在JSSE中证书信任管理器类实现了X509TrustManager接口,我们可以自己实现一个X509TrustManager,通过hook修改掉网络请求库的X509TrustManager配置。


      比如自定义X509TrustManager实现信任所有服务端的证书(无论是否过期、是否经过认证):


      public class TrustAllManager implements X509TrustManager {
      @Override
      public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType)
      throws java.security.cert.CertificateException {
      }

      @Override
      public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType)
      throws java.security.cert.CertificateException {
      }

      @Override
      public java.security.cert.X509Certificate[] getAcceptedIssuers() {
      return new java.security.cert.X509Certificate[0];
      }
      }
      复制代码

      okhttp的X509TrustManager设置为:


      OkHttpClient.Builder builder = new OkHttpClient.Builder();
      builder.sslSocketFactory(createAllSSLSocketFactory(), new TrustAllManager());
      复制代码

      我们可以通过hook OkHttpClient.Builder类的sslSocketFactory方法,实现修改X509TrustManager配置,从而实现用户证书的信任。




    HTTPS抓包原理


    代理原理


    Charles、fiddler、HttpCanary抓包都是基于代理实现的,对HTTPS的抓包原理其实也都差不多,类似于中间人攻击,原理如下(图片来源于谈移动端抓包方式和原理及如何防犯中间人攻击):


    Charles抓包原理



    • TLS握手时拦截服务器证书,得到服务器公钥,并将Charles自己的证书发送给客户端,客户端原本校验Charles证书不通过,但我们可以手动使客户端信任Charles证书。

    • Charles拦截请求得到Random_S和Random_C等未加密信息,其他加密部分比如Pre-Master由于是使用Charles的证书公钥加密的,Charles可以使用自己的私钥解密得到内容,再使用服务器证书公钥重新加密后发送给服务器,从而与服务器完成TLS认证,并获取到密钥。

    • 每次发送HTTPS请求报文经过Charles,Charles再使用得到的对称密钥进行解密。


    Android防抓包策略及绕过思路


    Android上HTTPS抓包成本并不算高,使系统信任第三方证书就能够实现抓包,Android 7.0 (API 24)及以上虽默认不再信任用户CA,提高了安全性但抓包成本也不算高,还可添加其他防抓包策略进一步提高安全性。


    设置无代理模式


    由于Charles、fiddler这些抓包工具是基于代理实现的(wireshark不是基于代理,而是网卡抓包),所以可以将APP所用的HTTP客户端设置为无代理,设置之后HTTP客户端不会连接到代理服务器,这样的话Charles就无法直接抓包了,比如OkHttp配置无代理:


    OkHttpClient.Builder()
    .proxy(Proxy.NO_PROXY)
    .build()
    复制代码

    绕过方案:



    1. 手动修改DNS。由上面的代理原理图可知,若请求不走代理,就要通过DNS解析获取ip地址再发送请求,我们可以直接修改Android的DNS配置,将请求域名解析到Charles代理服务器上,从而实现抓包。

    2. VPN流量转发。使用drony之类的APP先将手机请求导到VPN,再对VPN的网络进行Charles的代理。

    3. 使用frida或者xposed hookOkHttpClient.Builderproxy方法,使无代理配置不起作用。


    增强本地证书校验


    APP本地做证书校验时不仅仅校验公钥,并且设置更为严格的校验模式,直接安装的Charles证书将因为格式问题不能验证通过,可以通过实现X509TrustManager 接口实现。这种方式其实适用于Android 7.0以下,Android 7.0以上通过MagiskTrustUserCerts等方式安装的证书由于已经被当作系统内置证书,这种方式应该不再起作用。


    SSL Pinning证书锁定


    应用中只信任固定证书或是公钥,将可信 CA 限制在一个很小的 CA 集范围内,应用的服务器将使用这个集合,这样可以防止因泄露系统中其他 100 多个 CA 中的某个 CA 而破坏应用安全通道。


    通常有两种锁定方式证书固定公钥固定。证书固定:将证书的某些字节码硬编码在用程序中,证书校验时检查证书中是否存在相同的字节码;公钥固定:网站会提供已授权公钥的哈希列表,指示客户端在后续通讯中只接受列表上的公钥。


    OkHttp配置实现证书锁定,对特定的host做证书公钥验证,公钥经过Sha1算法hash一下,然后Base64加密一次,然后在结果前面加上字符串"sha256/"或者"sha1/":


    CertificatePinner certificatePinner = new CertificatePinner.Builder()
    .add(example.com, "sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=")
    .build();

    OkHttpClient client = new OkHttpClient();
    client.setCertificatePinner(certificatePinner);
    复制代码

    Android 7.0及以上实现证书锁定:





    example.com

    7HIpactkIAq2Y49orFOOQKurWxmmSFZhBCoQYcRhJ3Y=

    fwza0LRMXouZHRC8Ei+4PyuldPDcf3UKgO/04cDM1oE=



    复制代码

    绕过方案:



    1. 可以尝试Xposed+JustTrustMe模块或者JustTrustMePlus模块或者TrustMeAlready模块

    2. Frida+DroidSSLUnpinning脚本

    3. hook,需要反编译分析源码


    TLS双向认证


    TLS认证有单向认证和双向认证模式,双向认证除了客户端去验证服务器端的证书外,服务器也同时需要验证客户端的证书,如果没有通过验证,则会拒绝连接,如果通过验证,服务器获得用户的公钥。


    绕过方案:双向认证需要客户端证书,所以APP内是要有证书的并且有操作证书的地方,hook这部分代码获取证书及密钥,再将证书格式转换一下,导入到Burp Suite或者Charles这些抓包软件中,实现抓包。


    此外,APP内肯定有传输内容SSL解密的实现,针对这部分代码进行hook,也可直接拿到数据,这也是更为通用的获取请求内容的办法,实现方式可以参考Frida的脚本frida_ssl_logger


    Android网络安全方面配置可以查看developer android,此外还可通过HTTPS请求的报文密、重要请求走Socket通信,APP加固防止hook等手段提高安全性。


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

    zygote启动流程

    对zygote的理解 在Android系统中,zygote是一个native进程,是所有应用进程的父进程。而zygote则是Linux系统用户空间的第一个进程——init进程,通过fork的方式创建并启动的。 作用 zygote进程在启动时,会创建一个Dalv...
    继续阅读 »

    对zygote的理解


    在Android系统中,zygote是一个native进程,是所有应用进程的父进程。而zygote则是Linux系统用户空间的第一个进程——init进程,通过fork的方式创建并启动的。


    作用


    zygote进程在启动时,会创建一个Dalvik虚拟机实例,每次孵化新的应用进程时,都会将这个Dalvik虚拟机实例复制到新的应用程序进程里面,从而使得每个应用程序进程都有一个独立的Dalvik虚拟机实例。


    zygote进程的主要作用有两个:



    • 启动SystemServer。

    • 孵化应用进程。


    启动流程


    启动入口

    Zygote进程在init进程中,通过解析init.zygote.rc配置文件,以service(服务)的方式启动并创建的。


    以init.zygote32.rc为例来看下:


    脚本讲解

    //    system\core\rootdir\init.zygote32.rc
    service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
    class main
    priority -20
    user root
    group root readproc reserved_disk
    socket zygote stream 660 root system
    socket usap_pool_primary stream 660 root system
    onrestart write /sys/power/state on
    onrestart restart audioserver
    onrestart restart cameraserver
    onrestart restart media
    onrestart restart netd
    onrestart restart wificond
    writepid /dev/cpuset/foreground/tasks
    复制代码


    这段脚本要求 init 进程创建一个名为 zygote 的进程,该进程要执行的程序是“/system/bin/app_process”。并且为 zygote 进程创建一个 socket 资源 (用于进程间通信,ActivityManagerService 就是通过该 socket 请求 zygote 进程 fork 一个应用程序进程)。


    后面的**--zygote**是参数,表示启动的是zygote进程。在app_process的main函数中会依据该参数决定执行ZygoteInit还是Java类。


    启动过程

    zygote要执行的程序便是system/bin/app_process,它的源代码在frameworks/base/cmds/app_process/app_main.cpp


    App_main::main

    int main(int argc, char* const argv[])
    {
    ...
    while (i < argc) {
    const char* arg = argv[i++];
    if (strcmp(arg, "--zygote") == 0) {//是否有--zygote参数。这个是启动zygote进程的时候的参数
    zygote = true;
    //进程名称,设置为zygote
    niceName = ZYGOTE_NICE_NAME;
    } else if (strcmp(arg, "--start-system-server") == 0) {//是否有--start-system-server
    startSystemServer = true;
    ....
    if (zygote) {
    //最最重要方法。。。如果是zygote进程,则启动ZygoteInit。
    runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
    } else if (className) {
    runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
    } else {
    fprintf(stderr, "Error: no class name or --zygote supplied.\n");
    app_usage();
    LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
    }
    }
    复制代码

    AndroidRuntime::start

    void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
    {
    ...
    JNIEnv* env;
    //重点方法 创建VM虚拟机,参数是指针,可以用于获取返回的值,可以使用env来和Java层来做交互
    if (startVm(&mJavaVM, &env, zygote) != 0) {
    return;
    }
    onVmCreated(env);
    //重点方法 给虚拟机注册一些JNI函数,(系统so库、用户自定义so库 、加载函数等。)
    if (startReg(env) < 0) {
    ALOGE("Unable to register all android natives\n");
    return;
    }

    //找到类的main方法,并调用。如果是zygote的话,这里就会启动ZygoteInit类的main方法
    jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
    "([Ljava/lang/String;)V");
    if (startMeth == NULL) {
    ALOGE("JavaVM unable to find main() in '%s'\n", className);
    /* keep going */
    } else {
    //调用main方法。这里通过JNI调用Java方法之后,Zygote(Native层)就进入了Java的世界,从而开启了Android中Java的世界。
    env->CallStaticVoidMethod(startClass, startMeth, strArray);
    }
    复制代码

    App_main.main
    AndroidRuntime.start
    startVm//创建虚拟机
    startReg//注册JNI函数
    ZygoteInit.main//这里就进入到了Java层了
    registerZygoteSocket//建立IPC的通讯机制
    preload//预加载类和资源
    startSystemServer//启动system_server
    runSelectLoop//等待进程创建的请求
    复制代码


    对应的源码地址:
    /frameworks/base/cmds/app_process/App_main.cpp (内含AppRuntime类)
    /frameworks/base/core/jni/AndroidRuntime.cpp
    /frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    /frameworks/base/core/java/com/android/internal/os/Zygote.java
    /frameworks/base/core/java/android/net/LocalServerSocket.java



    Zygote进程的启动过程中,除了会创建一个Dalvik虚拟机实例之外,还会将Java运行时库加载到进程中,以及注册一些Android核心类的JNI方法到创建的Dalvik虚拟机实例中。


    zygote进程初始化时启动虚拟,并加载一些系统资源。这样zygote fork出子进程之后,子进程也会继承能正常工作的虚拟机和各种系统资源,剩下的只需要装载APK文件的字节码就可以运行程序,。


    Java应用程序不能以本地进程的形态运行,必须在一个独立的虚拟机中运行。如果每次都重新启动虚拟机,肯定就会拖慢应用程序的启动速度。


    注意:APK应用程序进程被zygote进程孵化出来以后,不仅会获得Dalvik虚拟机实例拷贝,还会与Zygote一起共享Java运行时库。


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

    Android 开发也要懂得数据结构 - SparseArray源码

    在之前分析 HashMap 就知道当容量达到 75% 时就需要扩容,那也就意味着 25% 的内存空间啥也不放,浪费掉了,为了解决这个问题,就有了 SparseArray。 本文章使用的是 JDK1.8 ,不同版本源码有差异。 可先食用 Android 开发也要...
    继续阅读 »
    • 在之前分析 HashMap 就知道当容量达到 75% 时就需要扩容,那也就意味着 25% 的内存空间啥也不放,浪费掉了,为了解决这个问题,就有了 SparseArray

    • 本文章使用的是 JDK1.8 ,不同版本源码有差异。

    • 可先食用 Android 开发也要懂得数据结构 - HashMap源码


    1.SparseArray特点



    • SparseArray的结构是 双数组 ,就是key和value都是数组,下标一一对应。

    • SparseArray虽然是 key-valye 结构,但是key只能是 int 类型,用于代替 HashMap<Integer,Object>,这也是缺点,还有 LongSparseArray

    • HashMap 处理 int 类型的key,是需要 装箱成Integer类型 ,消耗一些资源,而 SparseArray 就不需要装箱操作,更快一些。

    • HashMap 保存数据是以 Entry对象保存,还要计算hashCode,在内存方面是要大于 SparseArray。

    • SparseArray 的查找速度比较快,利用的是二分法查找,二分查找的要求就是key是有序排列的。

    • 二分查找虽然挺快的,数据量大的时候跟HashMap比就没有什么优势了,千级以下使用。


    2.SparseArray常用的方法


    2.1 基本参数



    • DELETED 是删除的位置放的东西,SparseArray 删除相当于是打上标记,就不需要移动数组,减少数组移动的耗时。

    • mGarbage 标志是如果有删除,就为true,用于后面的 gc() 方法的标记。

    • 可以看到 SparseArray 的 key 和 value 都是数组。

    • 还有一个长度mSize,与List,Map一样样,这个是实际数据的长度,不是容量的大小。


        private static final Object DELETED = new Object();
    private boolean mGarbage = false;

    @UnsupportedAppUsage(maxTargetSdk = 28) // Use keyAt(int)
    private int[] mKeys;
    @UnsupportedAppUsage(maxTargetSdk = 28) // Use valueAt(int), setValueAt(int, E)
    private Object[] mValues;
    @UnsupportedAppUsage(maxTargetSdk = 28) // Use size()
    private int mSize;
    复制代码

    2.2 构造方法



    • 构造方法两种,可以选填容量大小或者不填,不填容量,容量默认就为10。

    • 如果填写的容量为0,那就会创建一个非常轻量的数组。


        /**
    * Creates a new SparseArray containing no mappings.
    */
    public SparseArray() {
    this(10);
    }

    /**
    * Creates a new SparseArray containing no mappings that will not
    * require any additional memory allocation to store the specified
    * number of mappings. If you supply an initial capacity of 0, the
    * sparse array will be initialized with a light-weight representation
    * not requiring any additional array allocations.
    */
    public SparseArray(int initialCapacity) {
    if (initialCapacity == 0) {
    mKeys = EmptyArray.INT;
    mValues = EmptyArray.OBJECT;
    } else {
    mValues = ArrayUtils.newUnpaddedObjectArray(initialCapacity);
    mKeys = new int[mValues.length];
    }
    //还没有放入数据,所以mSize为0。
    mSize = 0;
    }
    复制代码

    2.3 二分查找 ContainerHelpers.binarySearch(mKeys, mSize, key)



    • 显示利用二分法,找出要放入元素的 key 对应的下标,如果找不到就返回二分范围小值的取反。


        //比较简单的二分法查找
    // This is Arrays.binarySearch(), but doesn't do any argument validation.
    static int binarySearch(int[] array, int size, int value) {
    int lo = 0;
    int hi = size - 1;

    while (lo <= hi) {
    final int mid = (lo + hi) >>> 1;
    final int midVal = array[mid];
    //如果中间这个数小于目标值
    if (midVal < value) {
    //检索的范围最小就为中间+1
    lo = mid + 1;
    } else if (midVal > value) {
    //如果大于,范围的最大就为中间-1
    hi = mid - 1;
    } else {
    //找到就返回下标位置
    return mid; // value found
    }
    }
    //找不到就返回lo取反
    return ~lo; // value not present
    }
    复制代码

    2.4 放入元素 put(int key, E value)



    • 如果 key 位置已存在,直接覆盖。

    • 如果找不到 key 对应下标,且在范围内,有删除过闲置的位置,就把当前数据放在这个位置。

    • 如果这都不满足条件,就调用 gc() 方法整理一遍数据,把标记过删除的位置,干掉,再插入数据。

    • 插入元素如果容量不够,就扩容,如果原始容量小于4的,扩容成8,否则就以2倍的大小扩容。

    • 数组的插入需要移动后面位置的元素。


        /**
    * Adds a mapping from the specified key to the specified value,
    * replacing the previous mapping from the specified key if there
    * was one.
    */
    public void put(int key, E value) {
    int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

    if (i >= 0) {
    mValues[i] = value;
    } else {
    //取反
    i = ~i;

    //如果i小于长度,且i位置没东西,就放在i位置。
    if (i < mSize && mValues[i] == DELETED) {
    mKeys[i] = key;
    mValues[i] = value;
    return;
    }

    //如果有垃圾(删除过东西),且数据容量长度大于等于key数组时
    if (mGarbage && mSize >= mKeys.length) {
    //整理一下数据
    gc();

    //整理后再次查找索引位置
    // Search again because indices may have changed.
    i = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
    }

    //插入数据
    mKeys = GrowingArrayUtils.insert(mKeys, mSize, i, key);
    mValues = GrowingArrayUtils.insert(mValues, mSize, i, value);
    mSize++;
    }
    }

    //GrowingArrayUtils.insert
    /**
    * Primitive int version of {@link #insert(Object[], int, int, Object)}.
    */
    public static int[] insert(int[] array, int currentSize, int index, int element) {
    assert currentSize <= array.length;

    if (currentSize + 1 <= array.length) {
    System.arraycopy(array, index, array, index + 1, currentSize - index);
    array[index] = element;
    return array;
    }

    int[] newArray = new int[growSize(currentSize)];
    System.arraycopy(array, 0, newArray, 0, index);
    newArray[index] = element;
    System.arraycopy(array, index, newArray, index + 1, array.length - index);
    return newArray;
    }

    //GrowingArrayUtils.growSize
    //扩容,如果容量小于4的,扩容成8,否则就以2倍的大小扩容。
    /**
    * Given the current size of an array, returns an ideal size to which the array should grow.
    * This is typically double the given size, but should not be relied upon to do so in the
    * future.
    */
    public static int growSize(int currentSize) {
    return currentSize <= 4 ? 8 : currentSize * 2;
    }
    复制代码

    2.5 整理数据 gc()



    • 把非 DELETED 位置的数据,一个个往前移动。

    • mGarbage 设置为 false


        private void gc() {
    // Log.e("SparseArray", "gc start with " + mSize);

    int n = mSize;
    int o = 0;
    int[] keys = mKeys;
    Object[] values = mValues;

    for (int i = 0; i < n; i++) {
    Object val = values[i];

    if (val != DELETED) {
    if (i != o) {
    keys[o] = keys[i];
    values[o] = val;
    values[i] = null;
    }

    o++;
    }
    }

    mGarbage = false;
    mSize = o;

    // Log.e("SparseArray", "gc end with " + mSize);
    }
    复制代码

    2.6 删除元素 remove(int key)或者delete(int key)



    • 我们知道真正数组的删除,是要以移动后面的元素的,每次会造成大量的操作,所以改为标记清除,先打上标记,可以在放入元素时重新利用上空闲的位置,或者后面gc时再一次性清除掉。


        /**
    * Alias for {@link #delete(int)}.
    */
    public void remove(int key) {
    delete(key);
    }

    /**
    * Removes the mapping from the specified key, if there was any.
    */
    public void delete(int key) {
    //用二分法,找到要删除数据对应的下标
    int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

    if (i >= 0) {
    if (mValues[i] != DELETED) {
    mValues[i] = DELETED;
    mGarbage = true;
    }
    }
    }
    复制代码

    2.7 查找元素 get(int key)



    • 利用二分查找找出 key 对应的下标,然后返回同样下标位置的值。

    • 两个参数的方法,也可设置找不到放回的默认值,如果找不到就返回默认值,否则是null。


        /**
    * Gets the Object mapped from the specified key, or <code>null</code>
    * if no such mapping has been made.
    */
    public E get(int key) {
    return get(key, null);
    }

    /**
    * Gets the Object mapped from the specified key, or the specified Object
    * if no such mapping has been made.
    */
    @SuppressWarnings("unchecked")
    public E get(int key, E valueIfKeyNotFound) {
    int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

    if (i < 0 || mValues[i] == DELETED) {
    return valueIfKeyNotFound;
    } else {
    return (E) mValues[i];
    }
    }
    复制代码

    2.8 查找key对应的下标 indexOfKey(int key)



    • 如果有标记垃圾,先整理一遍再放回 key 对应的下标。


        /**
    * Returns the index for which {@link #keyAt} would return the
    * specified key, or a negative number if the specified
    * key is not mapped.
    */
    public int indexOfKey(int key) {
    if (mGarbage) {
    gc();
    }

    return ContainerHelpers.binarySearch(mKeys, mSize, key);
    }
    复制代码

    2.9 查找value对应的下标 indexOfValue(E value)



    • 查找之前依然会整理一次数据,不同位置都可能保存着这个value,所以遍历后,返回第一个,如果找不到就返回-1。


        /**
    * Returns an index for which {@link #valueAt} would return the
    * specified value, or a negative number if no keys map to the
    * specified value.
    * <p>Beware that this is a linear search, unlike lookups by key,
    * and that multiple keys can map to the same value and this will
    * find only one of them.
    * <p>Note also that unlike most collections' {@code indexOf} methods,
    * this method compares values using {@code ==} rather than {@code equals}.
    */
    public int indexOfValue(E value) {
    if (mGarbage) {
    gc();
    }

    for (int i = 0; i < mSize; i++) {
    if (mValues[i] == value) {
    return i;
    }
    }

    return -1;
    }
    复制代码

    2.10 长度size()



    • 返回数据的长度。


        /**
    * Returns the number of key-value mappings that this SparseArray
    * currently stores.
    */
    public int size() {
    if (mGarbage) {
    gc();
    }

    return mSize;
    }

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

    View.post()为什么能准确拿到View的宽高?

    老生常谈之------View.post() 起因:之前一群里的哥们问 Handler.post() 为什么会在 Activity 的 onResume() 之后执行,我找了一遍之后并没有找到原因,后来从这个问题我想起其他的问题 view.post() 为什...
    继续阅读 »

    老生常谈之------View.post()


    起因:之前一群里的哥们问 Handler.post() 为什么会在 ActivityonResume() 之后执行,我找了一遍之后并没有找到原因,后来从这个问题我想起其他的问题 view.post() 为什么在 view.post() 之后为什么可以准确的获取到 view的宽高。


    疑问🤔️:View.post()为什么会准确的获取到View的宽高?


    public boolean post(Runnable action) {
    //注释1:判断attachInfo如果不为空 直接调用attachInfo内部Handler.post()方法
    //这样就有一个问题attachInfo在哪里赋值?这个问题先存疑。
    final AttachInfo attachInfo = mAttachInfo;
    if (attachInfo != null) {
    return attachInfo.mHandler.post(action);
    }
    //注释2:此时attachInfo是空的
    getRunQueue().post(action);
    return true;
    }
    复制代码

    存疑1:attachInfo在哪里赋值?


    我们点进去看一下 getRunQueue().post(action); 是何方神圣。


    private HandlerActionQueue getRunQueue() {
    if (mRunQueue == null) {
    mRunQueue = new HandlerActionQueue();
    }
    return mRunQueue;
    }
    复制代码

    上面代码很简单,那么接下来就需要看看 HandlerActionQueue() 是什么玩意了。


    public class HandlerActionQueue {
    private HandlerAction[] mActions;
    private int mCount;

    //注释1
    public void post(Runnable action) {
    postDelayed(action, 0);
    }
    //注释2
    public void postDelayed(Runnable action, long delayMillis) {
    final HandlerAction handlerAction = new HandlerAction(action, delayMillis);

    synchronized (this) {
    if (mActions == null) {
    mActions = new HandlerAction[4];
    }
    mActions = GrowingArrayUtils.append(mActions, mCount, handlerAction);
    mCount++;
    }
    }

    public void removeCallbacks(Runnable action) {}

    //假装不知道这个是执行方法
    public void executeActions(Handler handler) {}

    public int size() {}

    public Runnable getRunnable(int index) {}

    public long getDelay(int index) {}

    private static class HandlerAction {}
    }

    复制代码

    先看注释1 可以看到这个post()方法 其实就是getRunQueue().post(action); 它内部调用了注释2方法 也就是postDelayed()
    注释2简单看了里面的代码 发现大概逻辑只是对 我们postrunnable进行缓存起来,那么我们从哪里真正执行这个runnable呢?
    我发现 我们一路跟进来直到postDelayed()方法时并没有看到对应的执行方法那么我们就放大招了


    影·奥义!时光回溯。


    我们看看getRunQueue()时 返回的mRunQueue在哪里调用的就好了。


    	//不会上传图片...大小不懂得控制 所以用代码块 
    private HandlerActionQueue getRunQueue() {
    if (mRunQueue == null) {
    mRunQueue = new HandlerActionQueue();
    }
    return mRunQueue;
    }
    void dispatchAttachedToWindow(AttachInfo info, int visibility) {
    mAttachInfo = info;
    //忽略的一些代码
    if (mRunQueue != null) {
    mRunQueue.executeActions(info.mHandler);
    mRunQueue = null;
    }
    }
    复制代码

    通过检查对mRunQueue的引用 可以看到view代码内只有这两个方法有所使用,那么第一个方法我们以及看过了 所以我们重点看下第二个方法。


    从上面第二个方法 可以得知mAttachInfodispatchAttachedToWindow(AttachInfo info, int visibility)内的info赋值 那么 info又在哪里生成?先继续看下去。


    通过对dispatchAttachedToWindow() 的调用关系可以发现以下方法会调用


    private void performTraversals() {
    // cache mView since it is used so much below...
    final View host = mView;
    /.../
    //注释1
    host.dispatchAttachedToWindow(mAttachInfo, 0);
    /.../
    performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);//执行测量
    performLayout(lp, mWidth, mHeight);//执行布局
    performDraw();//执行绘制

    }
    复制代码

    可以看到 host内会调用这个方法,并且将mAttachInfo作为参数传入,而这个host是一个DecorView


    为什么是DecorView? 我们可以反推回去验证
    通过源码我们得知 hostViewRootImpl 中的mView的成员变量
    mView检查赋值的地方 可以看到以下代码:


     public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
    synchronized (this) {
    if (mView == null) {
    mView = view;//对mView 赋值
    /.../
    }
    }
    }
    复制代码

    那什么时候能调用到setView()呢?
    可以看到setView() 并不是静态方法,所以要调用并需要引用实例才可以。


    那么我们可以看看构造方法


    public ViewRootImpl(Context context, Display display) {
    mContext = context;
    /.../
    //注释1
    mAttachInfo = new View.AttachInfo(mWindowSession, mWindow, display, this, mHandler, this,context);
    }
    复制代码

    可以看到注释1处的代码我们能够得知 mAttachInfo是在ViewRootImpl构造器中创建出来的。


    我们再对构造器查看调用 可以发现再 WindowManagerGlobaladdView()方法 会创建ViewRootImpl


         public void addView(View view, ViewGroup.LayoutParams params,
    Display display, Window parentWindow) {
    /.../
    root = new ViewRootImpl(view.getContext(), display);
    }
    复制代码

    WindowManagerGlobaladdView()方法 又被WindowManagerImpladdView()调用


       @Override
    public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
    applyDefaultToken(params);
    mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
    }
    复制代码

    再对这个方法进行调用检查可以看到


    @Override
    public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
    String reason) {
    if (r.window == null && !a.mFinished && willBeVisible) {
    r.window = r.activity.getWindow();
    View decor = r.window.getDecorView(); //注释1
    decor.setVisibility(View.INVISIBLE);
    ViewManager wm = a.getWindowManager();
    WindowManager.LayoutParams l = r.window.getAttributes();
    a.mDecor = decor;
    l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
    l.softInputMode |= forwardBit;
    if (r.mPreserveWindow) {
    a.mWindowAdded = true;
    r.mPreserveWindow = false;
    ViewRootImpl impl = decor.getViewRootImpl();
    if (impl != null) {
    impl.notifyChildRebuilt();
    }
    }
    if (a.mVisibleFromClient) {
    if (!a.mWindowAdded) {
    a.mWindowAdded = true;
    wm.addView(decor, l); //注释2
    } else {
    a.onWindowAttributesChanged(l);
    }
    }
    } else if (!willBeVisible) {
    if (localLOGV) Slog.v(TAG, "Launch " + r + " mStartedActivity set");
    r.hideForNow = true;
    }
    }
    复制代码

    可以在注释1处:会返回一个DecorView 并且在注释2处添加进入。
    至此 我们可以得知ViewRootImpl处的mView就是 DecorView


    知识点:
    并且我们可以从上面代码看出在onResumeview 才会被添加在window内并且执行view的测量布局绘制 这就是为什么在onCreate()时获取到view宽高会是0的原因,因为那时view都没有添加进window呢!!!


    时间再次穿梭 回到ViewRootImplperformTraversals()


    既然已知mView就是DecorView 那么这个DecorView是一个继承于FrameLayoutViewGroup
    我们在DecorViewFrameLayout内没有找到对dispatchAttachedToWindow()方法的处理,就自然而然的来到了ViewGroup处。


     @Override
    void dispatchAttachedToWindow(AttachInfo info, int visibility) {
    final int count = mChildrenCount;
    final View[] children = mChildren;
    for (int i = 0; i < count; i++) {
    final View child = children[i];
    //遍历调用 这样最终会回到View的dispatchAttachedToWindow()
    child.dispatchAttachedToWindow(info,
    combineVisibility(visibility, child.getVisibility()));
    }
    }
    复制代码

    这时候我们又回到了ViewdispatchAttachedToWindow()方法内的mRunQueue.executeActions(info.mHandler);并点击去看源码


      public void executeActions(Handler handler) {
    synchronized (this) {
    final HandlerAction[] actions = mActions;//注释1
    for (int i = 0, count = mCount; i < count; i++) {
    final HandlerAction handlerAction = actions[i];
    handler.postDelayed(handlerAction.action, handlerAction.delay);//注释2
    }
    mActions = null;
    mCount = 0;
    }
    }
    复制代码

    注释1处 我们可以看到mActions其实是我们用view.post方法时 传入的runnable的存储数组。
    注释2处 就会将runnable 交给handler.post()方法并且添加进这个Handler所持有的Looper内部的MessageQueue中。


    至此我们可以大概的进行一次总结了。


    总结:


    1:View内部的mAttachInfo 会在ViewdispatchAttachedToWindow()方法内赋值
    dispatchDetachedFromWindow()赋值为null,并且mAttachInfo的根本是在 ViewRootImpl的构造器内创建的,所以我们就可以知道当viewattchInfo不为空时 这个 view是已经被添加进窗口内的,如果为null就说明view没有在window内。


    2: 我们能通过view.post()正确的获取View的宽高主要得益于Android内的生命周期是被Handler所驱动的,所以当ViewRootImplActivityonResume()生命周期内被创建时,其实主线程的Handler 是在执行处理一个Message的流程中,虽然我们从上面ViewRootImpl内的performTraversals()源码中看到 view缓存的runnable会在performMeasure(), performLayout(),performDraw()这些方法前先被post出去并且添加到MessageQueue链表中,但是这些runnable是属于下一个Message的,而performMeasure(), performLayout(),performDraw()这三个方法是属于本次Message的逻辑,只有本次消息处理完成Handler内部的Looper才会进行下一次消息的处理,最终保证了 View.post()能够正确的拿到View的宽高。



    作者:FeanCheng
    链接:https://juejin.cn/post/6916024212696236040
    来源:掘金
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。  

    收起阅读 »

    ARouter原理与缺陷解析

    前言 本文主要包括以下内容 1.为什么需要ARouter及ARouter的基本原理 2.什么是APT及ARoutr注解是如何生效的? 3.ARouter有什么缺陷? 4.什么是字节码插桩,及如何利用字节码插桩优化ARouter? 为什么需要ARouter 我们...
    继续阅读 »

    前言


    本文主要包括以下内容

    1.为什么需要ARouterARouter的基本原理

    2.什么是APTARoutr注解是如何生效的?

    3.ARouter有什么缺陷?

    4.什么是字节码插桩,及如何利用字节码插桩优化ARouter?


    为什么需要ARouter


    我们知道,传统的Activity之间通信,通过startActivity(intent),而在组件化的项目中,上层的module没有依赖关系(即便两个module有依赖关系,也只能是单向的依赖)

    那么如何实现在没有依赖的情况下进行界面跳转呢?

    ARoutr帮我们实现了这点


    使用ARouter的原因就是为了解耦,即没有依赖时可以彼此跳转


    什么是APT


    APTAnnotation Processing Tool的简称,即注解处理工具。

    它是在编译期对代码中指定的注解进行解析,然后做一些其他处理(如通过javapoet生成新的Java文件)。

    我们常用的ButterKnife,其原理就是通过注解处理器在编译期扫描代码中加入的@BindView@OnClick等注解进行扫描处理,然后生成XXX_ViewBinding类,实现了view的绑定。


    ARouter中使用的注解处理器就是javapoet

    (1)JavaPoet是square推出的开源java代码生成框架

    (2)简洁易懂的API,上手快

    (3)让繁杂、重复的Java文件,自动化生成,提高工作效率,简化流程

    (4) 相比原始APT方法,JavaPoet是OOP的


    ARoutr的注解是如何生效的?


    我们在使用ARouter时都会在Activity上添加注解


    @Route(path = "/kotlin/test")
    class KotlinTestActivity : Activity() {
    ...
    }

    @Route(path = "/kotlin/java")
    public class TestNormalActivity extends AppCompatActivity {
    ...
    }
    复制代码

    这些注解在编译时会被arouter-compiler处理,使用JavaPoet在编译期生成类文件

    生成的文件如下所示:


    public class ARouter$$Group$$kotlin implements IRouteGroup {
    @Override
    public void loadInto(Map<String, RouteMeta> atlas) {
    atlas.put("/kotlin/java", RouteMeta.build(RouteType.ACTIVITY, TestNormalActivity.class, "/kotlin/java", "kotlin", null, -1, -2147483648));
    atlas.put("/kotlin/test", RouteMeta.build(RouteType.ACTIVITY, KotlinTestActivity.class, "/kotlin/test", "kotlin", new java.util.HashMap<String, Integer>(){{put("name", 8); put("age", 3); }}, -1, -2147483648));
    }
    }

    public class ARouter$$Root$$modulekotlin implements IRouteRoot {
    @Override
    public void loadInto(Map<String, Class<? extends IRouteGroup>> routes) {
    routes.put("kotlin", ARouter$$Group$$kotlin.class);
    }
    }
    复制代码

    如上所示,将注解的key与类的路径通过一个Map关联起来了

    只要我们拿到这个Map,即可在运行时通过注解的key拿到类的路径,实现在不依赖的情况下跳转


    如何拿到这个Map呢?


    ARouter缺陷


    ARouter的缺陷就在于拿到这个Map的过程

    我们在使用ARouter时都需要初始化,ARouter所做的即是在初始化时利用反射扫描指定包名下面的所有className,然后再添加map

    源码如下


    public synchronized static void init(Context context, ThreadPoolExecutor tpe) throws HandlerException {
    //load by plugin first
    loadRouterMap();
    if (registerByPlugin) {
    logger.info(TAG, "Load router map by arouter-auto-register plugin.");
    } else {
    Set<String> routerMap;

    // It will rebuild router map every times when debuggable.
    if (ARouter.debuggable() || PackageUtils.isNewVersion(context)) {
    logger.info(TAG, "Run with debug mode or new install, rebuild router map.");
    // These class was generated by arouter-compiler.
    //反射扫描对应包
    routerMap = ClassUtils.getFileNameByPackageName(mContext, ROUTE_ROOT_PAKCAGE);
    if (!routerMap.isEmpty()) {
    //
    context.getSharedPreferences(AROUTER_SP_CACHE_KEY, Context.MODE_PRIVATE).edit().putStringSet(AROUTER_SP_KEY_MAP, routerMap).apply();
    }

    PackageUtils.updateVersion(context); // Save new version name when router map update finishes.
    } else {
    logger.info(TAG, "Load router map from cache.");
    routerMap = new HashSet<>(context.getSharedPreferences(AROUTER_SP_CACHE_KEY, Context.MODE_PRIVATE).getStringSet(AROUTER_SP_KEY_MAP, new HashSet<String>()));
    }
    ....
    }
    }
    复制代码

    如上所示:

    1.初次打开时会利用ClassUtils.getFileNameByPackageName来扫描对应包下的所有className

    2.在初次扫描后会存储在SharedPreferences中,这样后续就不需要再扫描了,这也是一个优化

    3.以上两个过程都是耗时操作,即是ARouter初次打开时可能会造成慢的原因

    4.那有没有办法优化这个过程,让第一次打开也不需要扫描呢?


    利用字节码插桩优化ARouter首次启动耗时


    我们再看看上面的代码


    public synchronized static void init(Context context, ThreadPoolExecutor tpe) throws HandlerException {
    //load by plugin first
    loadRouterMap();
    if (registerByPlugin) {
    logger.info(TAG, "Load router map by arouter-auto-register plugin.");
    } else {
    ....
    }
    }

    private static void loadRouterMap() {
    //registerByPlugin一直被置为false
    registerByPlugin = false;
    }
    复制代码

    在初始化时,会在扫描之前,判断registerByPlugin,如果我们需要的map已经被插件注册了,那也就不需要进行下面的耗时操作了

    但是我们可以看到在loadRouterMap中,registerByPlugin一直被设为false

    registerByPlugin是不是一直没有生效?

    这里面其实用到了字节码插桩来在loadRouterMap方法中插入代码


    什么是编译插桩?


    顾名思义,所谓编译插桩就是在代码编译期间修改已有的代码或者生成新代码。实际上,我们项目中经常用到的 Dagger、ButterKnife 甚至是 Kotlin 语言,它们都用到了编译插桩的技术。

    理解编译插桩之前,需要先回顾一下Android项目中.java文件的编译过程:

    image.png

    从上图可以看出,我们可以在 1、2 两处对代码进行改造。

    1.在.java文件编译成.class文件时,APTAndroidAnnotation 等就是在此处触发代码生成。

    2.在.class文件进一步优化成.dex文件时,也就是直接操作字节码文件,这就是字码码插桩


    ARouter注解生成用了第一种方法,而启动优化则用了第二种方法



    ASM是一个十分强大的字节码处理框架,基本上可以实现任何对字节码的操作,也就是自由度和开发的掌控度很高.

    但是其相对来说比AspectJ上手难度要高,需要对Java字节码有一定了解.

    不过ASM为我们提供了访问者模式来访问字节码文件,这种模式下可以比较简单的做一些字节码操作,实现一些功能。

    同时ASM可以精确的只注入我们想要注入的代码,不会额外生成一些包装代码,所以性能上影响比较微小。


    关于ASM使用的具体细节可以参见:深入探索编译插桩技术(四、ASM 探秘)


    字节码插桩对ARouter具体做了什么优化?


    //源码代码,插桩前
    private static void loadRouterMap() {
    //registerByPlugin一直被置为false
    registerByPlugin = false;
    }
    //插桩后反编译代码
    private static void loadRouterMap() {
    registerByPlugin = false;
    register("com.alibaba.android.arouter.routes.ARouter$$Root$$modulejava");
    register("com.alibaba.android.arouter.routes.ARouter$$Root$$modulekotlin");
    register("com.alibaba.android.arouter.routes.ARouter$$Root$$arouterapi");
    register("com.alibaba.android.arouter.routes.ARouter$$Interceptors$$modulejava");
    register("com.alibaba.android.arouter.routes.ARouter$$Providers$$modulejava");
    register("com.alibaba.android.arouter.routes.ARouter$$Providers$$modulekotlin");
    register("com.alibaba.android.arouter.routes.ARouter$$Providers$$arouterapi");
    }
    复制代码

    1.插桩前源码与插桩后反编译代码如上所示

    2.插桩后代码即在编译期在loadRouterMap中插入了register代码

    3.通过这种方式即可避免在运行时通过反射扫描className,优化了启动速度


    插件使用


    使用Gradle插件实现路由表的自动加载


    apply plugin: 'com.alibaba.arouter'

    buildscript {
    repositories {
    jcenter()
    }

    dependencies {
    classpath "com.alibaba:arouter-register:?"
    }
    }
    复制代码

    1.可选使用,通过ARouter提供的注册插件进行路由表的自动加载

    2.默认通过扫描dex的方式进行加载,通过gradle插件进行自动注册可以缩短初始化时间,同时解决应用加固导致无法直接访问dex文件,初始化失败的问题

    3.需要注意的是,该插件必须搭配api 1.3.0以上版本使用!

    4.ARouter插件基于AutoRegister进行开发,关于其原理的更多介绍可见:AutoRegister:一种更高效的组件自动注册方案


    总结


    本文主要讲述了

    1.使用ARouter的根本原因是为在互相不依赖的情况下进行页面跳转以实现解藕

    2.什么是APTARoutr注解生成的代码解析

    3.ARouter的缺陷在于首次初始化时会通过反射扫描dex,同时将结果存储在SP中,会拖慢首次启动速度

    4.ARouter提供了插件实现在编译期实现路由表的自动加载,从而避免启动耗时,其原理是字节码插桩


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

    浅谈Constraints,Layout,Display的点点滴滴

    浅谈Constraints,Layout,Display的点点滴滴神经骚栋关注赞赏支持前言这篇博客完全是因为 浅谈Masonry的使用技巧 才引出来的,如果不是内容太多,也不会单独写一篇博客来记录,在9102一整年中我基本与普通UI开发无缘,大部分工作是对La...
    继续阅读 »

    浅谈Constraints,Layout,Display的点点滴滴

    神经骚栋

    前言

    这篇博客完全是因为 浅谈Masonry的使用技巧 才引出来的,如果不是内容太多,也不会单独写一篇博客来记录,在9102一整年中我基本与普通UI开发无缘,大部分工作是对Layout进行操作绘制,以及使用CoreGraphics框架绘制各种图形,所以对Layout和Display的系统方法还是比较了解,近期又开始使用Masonry,所以对Constraints相关系统方法需要有所了解,而且在 浅谈Masonry的使用技巧 这篇博客中的优化部分不得不提出Constraints相关系统方法对其的影响。那么我们依照惯例,从基础的API开始进行吧。这里我基本上是从苹果的API抄录过来的,各位大佬可以自行去苹果API中心查看。

    基础API方法介绍

    Constraints 部分

    • needsUpdateConstraints 这个方法主要是用来判断当前View是否需要调用 updateConstraints 方法,如果在这个方法调用之前有约束发生了改变,调用这个方法返回值就是YES,但是它不会触发updateConstraints 方法的执行,只用用来判别当前控件是否需要调用更新约束方法。

    - (BOOL)needsUpdateConstraints;
    • setNeedsUpdateConstraints 这个方法主要是用来标记当前控件是否需要调用updateConstraints 方法,看好了,只是标记,而不是调用。 当给控件标记上需要刷新约束,如果程序没有直接强制刷新(调用updateConstraintsIfNeeded),那么会在系统RunLoop的下个周期开始时调用 updateConstraints 方法。

    - (void)setNeedsUpdateConstraints;
    • updateConstraints 这个方法是更新约束方法,在自定义控件中我们可以重写这个方法来添加我们自己的约束,对于updateConstraints 调用时机只能会有两种,一个是系统RunLoop的下个周期当发现需要更新布局(needsUpdateConstraints的值为YES)的时候,会自动调用该方法,或者是大佬们手动调用 updateConstraintsIfNeeded 来进行直接刷新。

    - (void)updateConstraints;
    • updateConstraintsIfNeeded 这个方法是直接强制立即调用 updateConstraints 方法,不需要等待Runloop下个周期,也不会管 needsUpdateConstraints 的返回值是否为YES,反正就是强制执行就对了。

    - (void)updateConstraintsIfNeeded;
    • updateViewConstraints 这个方法是在iOS6之后添加到UIViewController中的,具体作用和updateConstraints 方法类似。调用时机是 self.view 的 needsUpdateConstraints 值为YES 或 [self.view updateConstraintsIfNeeded]; 都可。这个方法极大的方便了控制器本身的View的布局调整。

    - (void)updateConstraintsIfNeeded;

    Layout 部分

    • layoutSubviews 这个方法是动态调整子视图的布局,这个方法的调用时机是当前控件或者子控件的bounds 发生改变的时候就会调用。

    - (void)layoutSubviews;
    • layoutIfNeeded 是立即强制执行layout操作的方法,但layoutSubviews 可能不会执行,因为如果控件或者子控件的bounds 没有发生改变时,layoutSubviews是不会执行的,所以说控件或者子控件的bounds 发生改变是 layoutIfNeeded 调起 layoutSubviews 的前提条件。

    - (void)layoutIfNeeded;
    • setNeedsLayout 这个方法和上面的setNeedsUpdateConstraints作用类似,但它不是用来标记的,而是让布局失效的(可以看做间接导致了bounds的改变),所以如果在其调用下方调用 layoutIfNeeded 会立即调起 layoutSubviews 方法,或者等待Runloop下一个周期由系统调起 layoutSubviews。

    - (void) setNeedsLayout;

    Display部分

    • drawRect 这个方法主要是当View控件需要自定义绘制内容的时候,一般会写在这个方法中。绘制上下文对象需要通过 UIGraphicsGetCurrentContext() 函数来获取,官方文档 中都写的明明白白的了(内容太多了,懒癌发作,大家自行去看吧)。这里就不过多叙述了。

    - (void)drawRect:(CGRect)rect;
    • drawInContext 这个方面主要是CALayer中自定义绘制内容的时候,一般都会写在这个方法中。ctx 这个参数是绘制上下文对象,不需要额外获取了。

    - (void)drawInContext:(CGContextRef)ctx;
    • setNeedsDisplay 这个方面主要是标记UIView或CALayer是否要刷新,看好了,是标记!而不是直接刷新,其作用和 setNeedsUpdateConstraints 非常的类似。

    - (void)setNeedsDisplay;
    • displayIfNeeded 这个方法主要让CALayer直接进行强制绘制,UIView中没有该方法。所以UIView的重新绘制只能先使用setNeedsDisplay来标记,等待系统RunLoop的下一个周期开始进行重绘。

    - (void)displayIfNeeded;
    • needsDisplay 这个方法判别CALayer是否需要刷新,只是用来判断,没有别的作用。UIView没有该方法。

    - (BOOL)needsDisplay;
    • display 官方建议不要直接调用这个方法,CALayer对象绘制适当的时机调用此方法来绘制CALayer对象其中的内容。

    - (void)display;

    Auto Layout Process 自动布局过程

    那么三种是如何关联起来的呢?主要是通过 Auto Layout Process 来关联在一起的,网上这个资料很多,苹果官方的我没有找到的在哪,所以我找到了最开始的版本 ,具体内容如下所示。

    与使用springs and struts(autoresizingMask)比较,Auto layout在view显示之前,多引入了两个步骤:updating constraints 和laying out views。每一个步骤都依赖于上一个。display依赖layout,而layout依赖updating constraints。 updating constraints→layout→display

    第一步:updating constraints,被称为测量阶段,其从下向上(from subview to super view),为下一步layout准备信息。可以通过调用方法setNeedUpdateConstraints去触发此步。constraints的改变也会自动的触发此步。但是,当你自定义view的时候,如果一些改变可能会影响到布局的时候,通常需要自己去通知Auto layout,updateConstraintsIfNeeded。

    自定义view的话,通常可以重写updateConstraints方法,在其中可以添加view需要的局部的contraints。

    第二步:layout,其从上向下(from super view to subview),此步主要应用上一步的信息去设置view的center和bounds。可以通过调用setNeedsLayout去触发此步骤,此方法不会立即应用layout。如果想要系统立即的更新layout,可以调用layoutIfNeeded。另外,自定义view可以重写方法layoutSubViews来在layout的工程中得到更多的定制化效果。

    第三步:display,此步时把view渲染到屏幕上,它与你是否使用Auto layout无关,其操作是从上向下(from super view to subview),通过调用setNeedsDisplay触发,

    因为每一步都依赖前一步,因此一个display可能会触发layout,当有任何layout没有被处理的时候,同理,layout可能会触发updating constraints,当constraint system更新改变的时候。

    需要注意的是,这三步不是单向的,constraint-based layout是一个迭代的过程,layout过程中,可能去改变constraints,有一次触发updating constraints,进行一轮layout过程。示意图如下所示。


    原作者也提到了另外的一个坑,那就是如果你每一次调用自定义layoutSubviews都会导致另一个布局传递,那么你将会陷入一个无限循环中。 这其中主要原因还是constraint-based layout是一个迭代的过程,在上图的 updating constraints 和 layout 中成了一个死循环了。

    视图渲染流程

    由上一个模块我们可以得知一个View视图的调用顺序为 updating constraints→layout→display,那么对应到具体方法就是 updateConstraints→layoutSubViews→drawRect:

    再详细的说一下,那就是,当我们修改View视图约束的时候,会触发 setNeedsUpdateConstraints 方法,然后触发 updateConstraints 方法,随后就紧接着触发 layoutSubViews,同时苹果官方已经为我们暴露了UIViewController中本身View视图的updateConstraints上层方法 updateViewConstraints,当UIViewController中本身View视图setNeedUpdate Constraints被调用的时候,这时候就会在合适的时机自动调用updateViewConstraints方法.

    反观UIViewController的生命周期流程,我们可以具体到如下表格顺序.


    触发时机分析

    这个模块我们就触发时机再总结一下,其实在上面的基础API的方法中都介绍了,但是比较杂乱,

    updateViewConstraints 与 updateConstraints
    这两个的触发时机是一致的,那么就是当 调用 needsUpdateConstraints 值为YES 的时候,就肯定会调用updateViewConstraints 或者 updateConstraints.那么在View内部的这个判别布尔值又是由什么决定呢?情况一是添加,修改,删除约束的时机,二是手动调用 setNeedsUpdateConstraints 的时机.这两种时机都会造成布尔值发生改变从而调起 updateViewConstraints 或 updateConstraints .

    layoutSubviews
    layoutSubviews的触发时机只有一种情况,那就是 自身或者子视图的 bounds 发生了改变. .这也解释了当我们创建一个视图的时候如果使用的CGRectZero的时候实际上不会调用 layoutSubviews 方法.

    drawRect 与 drawInContext
    这两个方法的调用时机又和 updateViewConstraints 与 updateConstraints 非常的相似,只有当 调用 setNeedsDisplay 才会触发调用.但两者又有很大的区别.drawRect是UIView中的方法,drawInContext是CALayer中方法,drawRect调用时机智能是RunLoop的下一个周期开始,不能立即调用,但是drawInContext却可以通过直接调用displayIfNeeded开直接调用,不用等待RunLoop的下一个周期开始.而且 needsDisplay 只是CALayer中的方法,UIView没有此方法.

    总结

    OK,写到这里基本上系统的各种约束,布局,绘制API大家都了解的差不多了,这对我们后期代码时机的把握有着很好的帮助,欢迎各位大佬自己手动试验,欢迎大家在评论区指导批评.

    转自:https://www.jianshu.com/p/983f2237cfa7

    收起阅读 »

    iOS 多线程之performSelector、死锁

    1. performSelector//在当前线程延迟1s执行,响应了OC语言的动态性:延迟到运行时才绑定方法[self performSelector:@selector(aaa) withObject:nil afterDelay:1];// 回到主线程,...
    继续阅读 »

    1. performSelector

    //在当前线程延迟1s执行,响应了OC语言的动态性:延迟到运行时才绑定方法
    [self performSelector:@selector(aaa) withObject:nil afterDelay:1];
    // 回到主线程,waitUntilDone:是否将该回调方法执行完再执行后面的代码
    // 如果为YES:就必须等回调方法执行完成之后才能执行后面的代码,说白了就是阻塞当前的线程
    // 如果是NO:就是不等回调方法结束,不会阻塞当前线程
    [self performSelectorOnMainThread:@selector(aaa) withObject:nil waitUntilDone:YES];
    // 开辟子线程
    [self performSelectorInBackground:@selector(aaa) withObject:nil];
    //在指定线程执行
    [self performSelector:@selector(aaa) onThread:[NSThread currentThread] withObject:nil waitUntilDone:YES];
    • 需要注意的是:如果是带afterDelay的延时函数,会在内部创建一个NSTimer,然后添加到当前线程的Runloop中。也就是如果当前线程没有开启runloop,该方法会失效。在子线程中,需要启动runloop(注意调用顺序)

    [self performSelector:@selector(aaa) withObject:nil afterDelay:1];
    [[NSRunLoop currentRunLoop] run];
    • performSelector:withObject:只是一个单纯的消息发送,和时间没有一点关系。所以不需要添加到子线程的Runloop中也能执行

    • 下面代码片段的test方法会去执行吗?

    dispatch_async(dispatch_get_global_queue(0, 0), ^{
    [self performSelector:@selector(test:) withObject:nil afterDelay:0];
    });

    这里的test方法是不会去执行的,原因在于- (void)performSelector: withObject: afterDelay:这个方法要创建提交任务到runloop上的,而gcd底层创建的线程是默认没有开启对应runloop的,所有这个方法就会失效。
    而如果将dispatch_get_global_queue改成主队列,由于主队列所在的主线程是默认开启了runloop的,就会去执行(将dispatch_async改成同步,因为同步是在当前线程执行,那么如果当前线程是主线程,test方法也是会去执行的)

    2. 死锁

    • 死锁就是队列引起的循环等待,一个比较常见的死锁例子:主队列同步

    - (void)viewDidLoad {
    [super viewDidLoad];
    dispatch_sync(dispatch_get_main_queue(), ^{
    NSLog(@"deallock");
    });
    }
    • 在主线程中运用主队列同步,也就是把任务放到了主线程的队列中。同步对于任务是立刻执行的,那么当把任务放进主队列时,它就会立马执行,只有执行完这个任务,viewDidLoad才会继续向下执行。而viewDidLoad和任务都是在主队列上的,由于队列的先进先出原则,任务又需等待viewDidLoad执行完毕后才能继续执行,viewDidLoad和这个任务就形成了相互循环等待,就造成了死锁。
      想避免这种死锁,可以将同步改成异步dispatch_async或者将dispatch_get_main_queue换成其他串行或并行队列,都可以解决

    • 同样,下边的代码也会造成死锁:

    dispatch_queue_t serialQueue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
    dispatch_async(serialQueue, ^{
    dispatch_sync(serialQueue, ^{
    NSLog(@"deadlock");
    });
    });

    外面的函数无论是同步还是异步都会造成死锁。这是因为里面的任务和外面的任务都在同一个serialQueue队列内,又是同步,这就和上边主队列同步的例子一样造成了死锁。
    解决方法也和上边一样,将里面的同步改成异步dispatch_async或者将serialQueue换成其他串行或并行队列,都可以解决

    转自:https://www.jianshu.com/p/ca19447a7003

    收起阅读 »

    ios设计模式之简单工厂模式

    最近一直在阅读OC编程之道(ios设计模式解析)一书(往期文章中我也将电子版的下载链接分享了出来)。其中包括23种设计模式和7种设计原则,如下图(此图为网络图片):在这里不过多的介绍设计模式和设计原则的问题了,感兴趣的同学可以自行去查阅资料,我在这里只介绍一种...
    继续阅读 »

    最近一直在阅读OC编程之道(ios设计模式解析)一书(往期文章中我也将电子版的下载链接分享了出来)。其中包括23种设计模式和7种设计原则,如下图(此图为网络图片):


    • 在这里不过多的介绍设计模式和设计原则的问题了,感兴趣的同学可以自行去查阅资料,我在这里只介绍一种设计模式及其代码,那就是简单工厂模式。

    • 何时使用工厂方法

         1、编译时无法准确预期要创建的对象的类;

         2、类想让其子类决定在运行时创建什么;

         3、类有若干辅助类为其子类,而你想将返回哪个子类这一信息局部化;

    • 在Cocoa Touch框架中应用的工厂方法

         工厂方法在Cocoa Touch框架中几乎随处可见,常见的两步对象创建法[[SomeClass alloc] init]。有时,我们已经注意到有一些便利方法返回类的实例。例如,NSNumber有很多numberWith *方法,其中两个是numberWithBool:和numberWithChar:。他们是类方法,也就是说我们向NSNumber发送[NSNumber numberWithBool:YES],以获得与传入参数同类型的各种NSNumber实例。与如何创建NSNumber的具体子类型的实例有关的所有细节,都由NSNumber的类工厂方法负责。[NSNumber numberWithBool:YES]的情况是,方法接受值YES,并把NSNumber的内部子类的一个实例初始化,让它能够反映传入的值YES。我们曾提到有个工厂方法模式的变体,抽象类用它生成具体子类。NSNumber中的这些numberWith *方法是这个变体的一个例子。它们不是用来被NSNumber的私有子类重载的,而是NSNumber创建合适对象的便利方式。

    • 简单的代码逻辑,提现一下工程方法的模式

         文章中我拿生活中日常饮用的饮料来做例子,我们首先会有一个父类,名字是:Drinks,代表饮料。还有三个继承Drinks的子类,名字分别为:可乐CocaCola芬达Fender矿泉水MineralWater。然后我们会有一个专门的工厂类DrinksFactory来管理生产何种饮料,DrinksFactory通过一个枚举和一个方法来生产。

    • 下面我将代码呈现给大家(gitHub工程地址:https://github.com/TianTeng6661/SimpleFactory.git,喜欢的给个星,谢谢)

         1、Drinks类

    import UIKit
    class Drinks: NSObject {
    func drinksColor(){
    NSLog("饮料颜色")
    }
    }

          2、CocaCola类

    import UIKit
    class CocaCola: Drinks {
    override func drinksColor(){
    NSLog("可口可乐是褐色")
    }
    }

         3、Fender类

    import UIKit
    class Fender: Drinks {
    override func drinksColor(){
    NSLog("芬达是橙色")
    }
    }

         4、MineralWater类

    import UIKit
    class MineralWater: Drinks {
    override func drinksColor(){
    NSLog("矿泉水是透明色")
    }
    }

         5、DrinksFactory类

    import UIKit

    enum DrinkType:Int {
    case DrinkCocaCola = 0 //可口可乐
    case DrinkFender = 1 //芬达
    case DrinkMineralWater = 3 //矿泉水
    }

    class DrinksFactory: NSObject {

    func createDrinksWithType(drinkstype:DrinkType) -> Drinks {
    switch drinkstype {
    case .DrinkCocaCola:do {
    let color = CocaCola()
    return color;
    }
    case .DrinkFender:do{
    let fender = Fender()
    return fender;
    }
    case .DrinkMineralWater:do{
    let mineralWater = MineralWater()
    return mineralWater;
    }
    }
    }
    }

    当我们在需要生产的时候我们调用方法为

    import UIKit

    class ViewController: UIViewController {

    override func viewDidLoad() {
    super.viewDidLoad()
    // Do any additional setup after loading the view.
    view.backgroundColor = UIColor.red

    let cocaCola:Drinks = DrinksFactory().createDrinksWithType(drinkstype: DrinkType.DrinkCocaCola)
    print(cocaCola .drinksColor()) //可口可乐是褐色
    let fender:Drinks = DrinksFactory().createDrinksWithType(drinkstype: DrinkType.DrinkFender)
    print(fender .drinksColor()) //芬达是橙色
    let mineralWater:Drinks = DrinksFactory().createDrinksWithType(drinkstype: DrinkType.DrinkMineralWater)
    print(mineralWater .drinksColor()) //矿泉水是透明色

    }
    }

    这样我们就简单实现了一个工厂方法,通过一个工厂类来管理所有饮料的生产,而且我们在需要多生产一种类型的饮料的时候,只需要创建此饮料的类,然后在工厂方法中实现就OK了。

    我在这里只是抛砖引玉,只是在讲解模式,这里面我们还有好多可以扩展的,比如不同的饮料有不同的口味,配方等等,共有的属性我们可以写在父类来实现,但是每个子类也可以有自己特有的属性。

    转自:https://www.jianshu.com/p/5c54c8ec0385

        

    收起阅读 »

    Cocoapods 1.8 版本改用 CDN 服务

    Cocoapods 1.7.2 版本开始增加 CDN 支持但默认没有启用,1.8 版本的发布舍弃了原始完整克隆的 Specs 仓库改用 CDN 服务。CDN 利用的是免费且强大的 jsDelivr CDN 服务,该 CDN 网络在国内是有备案因此速度和稳定性都...
    继续阅读 »


    Cocoapods 1.7.2 版本开始增加 CDN 支持但默认没有启用,
    1.8 版本的发布舍弃了原始完整克隆的 Specs 仓库改用 CDN 服务。

    CDN 利用的是免费且强大的 jsDelivr CDN 服务,该 CDN 网络在国内是有备案因此速度和稳定性都会有很好的保证。该提案其实在去年已经有人使用 Cocoapods Plugin 的方式实现并向社区贡献 PR。


    那么 CDN 支持相比之前的机制有啥优势呢?难道是把 Pods 的仓库和源码都托管到 CDN 网络了吗,其实并不是的。


    友情提醒:本文只重点分析 Pods 下载的机制,不展开其他方面,以下只是 pod install 执行顺序中的一部分,如果你想了解 Cocoapods 都干了什么可以前往这篇文章查阅。


    老的机制


    第一步先检查本地 ~/.cocoapods/repo/master 目录是否存在,没有直接克隆 https://github.com/Cocoapods/Specs.git 仓库,这步在国内来说特别费时间正常下载下来目录应该是 2G+,如果有其他 source 源(比如私有源)会重复刚才的操作。


    第二步安装 Podfile 每个 Pod 去在各个源中寻找对应的版本,从版本的 .podspec 文件解析获取组件的地址,这个可能是 http、git、svn、hg 中的任意一个,获取到之后开始下载(默认是在 ~/Library/Caches/CocoaPods 做缓存目录)


    新的机制


    第一步分析 Podfile 里面的 source ,如果没有走默认 Cocoapods 的配置(1.8 以上是 https://cdn.cocoapods.org ,之前的还是 Cocoapods/Spec), 如果本地不存在官方 cdn 的 repo 名字是 trunk 的保留字,自己无法创建。如果有自定义的 source 会追加上去 sources 列表。


    $httpHEAD0Cache-Control:public,max-age=0,must-revalidateConnection:keep-aliveContent-Length:924280Content-Type:text/plain;charset=UTF-8Date:Sat,09Nov201907:06:15GMTEtag:"acf0d284f3a8e82e0d66ba1a91cd30b9-ssl"Server:NetlifyStrict-Transport-Security:max-age=31536000X-NF-Request-ID:50b466cd-ce9e-4326-b5bb-0d29a193ae4b-7809449">https://cdn.cocoapods.org/all_pods.txtHTTP/1.1200OKAccept-Ranges:bytesAge:0Cache-Control:public,max-age=0,must-revalidateConnection:keep-aliveContent-Length:924280Content-Type:text/plain;charset=UTF-8Date:Sat,09Nov201907:06:15GMTEtag:”acf0d284f3a8e82e0d66ba1a91cd30b9-ssl”Server:NetlifyStrict-Transport-Security:max-age=31536000X-NF-Request-ID:50b466cd-ce9e-4326-b5bb-0d29a193ae4b-7809449

    第二步检查或下载每个 source,每个 source 会检查是否是 cdn 类型(使用 HEAD 请求检查是否包含 /all_pods.txt)文件:


    cdn 类型,下面详细解释


    其他类型,走原来的老的逻辑,不再赘述


    第三步,下载 Cocoapods-version.yml 并缓存 etag,下载 /Cocoapods-version.yml 并取 headers 的第一个 etag 的值存为 /Cocoapods-version.yml.etag,如果存在 etag 会比对一样就不需要下载, 链接支持根目录和其他目录,支持 301 跳转。


    Cocoapods-version.yml


    —-min:1.0.0last:1.8.4prefix_lengths:-1-1-1


    第四步,分析 Pod 并获取 pod 的版本信息,比如 Podfile 我增加了一个 pod “AFNetworking”,把 pod 名字做 MD5 后的值取 Cocoapods-version.yml 的 prefiexlength 数组长度的值单字母拆分用下划线分割按照规则拼成文件名 all_pods_versions({fragment}).txt (如果prefix_length 为 0 则只会去下载 /all_pods_versions.txt)


    比如:prefix_lengths 数组大小为 3,AFNetworking MD5 后 a75d452377f396bdc4b623a5df25820 则匹配前三位 a75 拆分后 a_7_5 后查找 cdn url 路径的 /all_pods_versions_a_7_5.txt 下载下来后的内容:


    Fuse/0.1.0/0.2.0/1.0.0/1.1.0/1.2.0


    GXFlowView/1.0.0


    JFCountryPicker/0.0.1/0.0.2


    JVEmptyElement/0.1.0


    第五步,下载 pod 的所有版本的 .podspec 文件,从上面的文件按照每行寻找第一段的名字,把后面的所有版本按照上面获取到的 prefix_lengths 的值(例如 AFNetworking 是 a, 7 , 5) /Specs/a/7/5/AFNetworking/{version}/AFNetworking.podspec.json 一次下载,并保存 etag 为 /Specs/a/7/5/AFNetworking/{version}/AFNetworking.podspec.json.etag,这个 etag 作用上面已经讲过,如果没有找到的话就会直接报错。


    AddingspecrepotrunkwithCDNhttps://cdn.cocoapods.org/ CDN:trunkRelativepathdownloaded:CocoaPods-version.yml,saveETag:”031c25b97a0aca21900087e355dcf663-ssl” CDN:trunkRelativepath:CocoaPods-version.ymlexists!Returninglocalbecausecheckingisonlyperfomedinrepoupdate CDN:trunkRelativepathdownloaded:all_pods_versions_a_7_5.txt,saveETag:”5b32718ecbe82b0ae71ab3c77120213f-ssl” CDN:trunkRedirectingfromhttps://cdn.cocoapods.org/Specs/a/7/5/AFNetworking/0.10.0/AFNetworking.podspec.jsontohttps://raw.githubusercontent.com/CocoaPods/Specs/master/Specs/a/7/5/AFNetworking/0.10.0/AFNetworking.podspec.json CDN:trunkRelativepathdownloaded:Specs/a/7/5/AFNetworking/0.10.0/AFNetworking.podspec.json,saveETag:W/“a5f00eb1fdfdcab00b89e96bb81d48c110f09220063fdcf0b269290bffc18cf5”

    Cocoapods trunk 源的目录结构:


    .cocoapods repo trunk .url#=> https://cdn.cocoapods.org/Cocoapods-version.yml# => 从 https://cdn.cocoapods.org/CocoaPods-version.yml 下载的文件Cocoapods-version.yml.etag# 上一个请求的第一个 etag 值存下来all_pods_versions_a_7_5.txt# 参考上面的备注all_pods_versions_a_7_5.txt.etag# 上一个请求的第一个 etag 值存下来


    第六步和老的机制第二步一样同样最终还是会寻找 podspec 里面下载地址去下载, 也就是说真正 CDN 缓存加速的只有原有 Specs 必要的 podspec 文件,而不会加速 Pod 真正源地址,改机制只是减轻了本地更新官方 Specs 源的麻烦以及维护一个巨大的本地文件存储,这也是中心化机制的一个心结。


    结语


    这个机制大大减少了本地需要占一个较大存储的问题,尤其是初次 pod install 时间长的情况,但 Pod 库本身还是各自的 地址本质上无法解决安装 Pod 消耗时间过长的问题。


    via icyleaf


    链接:https://www.jianshu.com/p/79c004614d06


    收起阅读 »

    uniapp你是真的坑!!

    最近要做一个锚点的效果,于是用到了这个方法,先获取节点信息,然后根据节点高度与页面滚动距离得到所需滑动的距离,但是这里有一个大坑,搞了两天,百思不得其解!就是h5端是正常的,app上不行,看了文档后也不存在兼容问题,于是,这里省下一百字骂人的话。。。uni.c...
    继续阅读 »

    最近要做一个锚点的效果,于是用到了这个方法,先获取节点信息,然后根据节点高度与页面滚动距离得到所需滑动的距离,但是这里有一个大坑,搞了两天,百思不得其解!就是h5端是正常的,app上不行,看了文档后也不存在兼容问题,于是,这里省下一百字骂人的话。。。

    uni.createSelectorQuery().in(this).select("#one").boundingClientRect(data => {
    uni.pageScrollTo({
    duration:200,
    scrollTop: that.scrollTop + data.top-44
    });
    }).exec();

    问题:h5上一切正常,app上只有初次事件触发—页面滚动是正常的,再次触发时,就报错,是这样的报错:

    //uniappnmsl
    h.push is not a function

    问题解决:

    //设置duration  这里是页面滚动时的滚动效果
    duration:200 => duration:0,

    然后
    就解决了,就解决了!

    uniapp 你该长大了,要学会自己更新bug了

    最后,祝uniapp长命百岁,新年快乐

    原文链接:https://segmentfault.com/a/1190000021222154
    收起阅读 »

    h5转uniapp项目技术总结

    h5项目转uniapp项目总结why先说一下为什么要用uniapp,主要是因为之前我们刚做完云闪付小程序(webview页面),老板又让我们做抖音小程序(后面还会做各种小程序),于是我们就想到了uniapp,之前也没做过想想也挺激动的项目目录├── READM...
    继续阅读 »

    h5项目转uniapp项目总结

    why

    先说一下为什么要用uniapp,主要是因为之前我们刚做完云闪付小程序(webview页面),老板又让我们做抖音小程序(后面还会做各种小程序),于是我们就想到了uniapp,之前也没做过想想也挺激动的

    项目目录

    ├── README.md

    ├── babel.config.js

    ├── dist

    ├── node_modules

    ├── package-lock.json

    ├── package.json

    ├── postcss.config.js
    ├── public

    ├── src


    ├── App.vue
    ├── api
    ├── assets
    ├── components
    ├── config
    ├── main.js
    ├── manifest.json
    ├── mixins
    ├── pages
    ├── pages.json
    ├── pagesub
    ├── services
    ├── static
    ├── store
    ├── uni.scss
    └── utils

    ├── tsconfig.json

    ├── vue.config.js

    ├── yarn-error.log

    └── yarn.lock

    条件编译

    /** #ifdef 平台名称 **/ 

    你的css或者js代码

    /** #endif **/

    样式

    scoped 样式穿透
    /deep/ 选择器 {}

    // vue.config 配置less全局变量引入
    let path = require('path');
    module.exports = {
    // 全局使用less变量
    pluginOptions: {
    'style-resources-loader': {
    preProcessor: 'less',
    patterns: [
    path.resolve(__dirname, 'src/assets/theme.less') // 我的主题变量文件地址
    ]
    }
    }
    }


    插件

    符合easycom命名规范可以省略引入组件的步骤

    vuex

    store数据改变页面未更新,我使用了一个mixin来解决,大概思路是混入需要更新的属性,在onShow钩子函数中执行
    // mixin
    export default {
    data() {
    return {
    userInfo: {}
    }
    },
    methods: {
    getUserInfo() {
    this.userInfo = this.$store.getters.userInfo
    }
    }
    }

    // 页面 重新赋值
    onShow() {
    this.getUserInfo()
    }


    路由

    • Vue的路由全写在pages里面
    • 路由跳转使用uniapp api
    • 页面title设置参考uniapp API

    原生组件层级过高

    页面的textarea层级过高盖住了popup弹窗

    • 使用cover-view提高popup组件层级(头条小程序不支持cover-view)
    • 使用hidden属性动态显示隐藏原生组件,popup组件弹出隐藏原生组件,反之亦然

    最后

    一开始写是愉悦的,改样式bug是痛苦的,结局是还算是好的。

    收起阅读 »

    ConstraintLayout 约束布局

    约束布局 约束布局概念 ConstraintLayout 可让您使用扁平视图层次结构(无嵌套视图组)创建复杂的大型布局。它与 RelativeLayout相似,其中所有的视图均根据同级视图与父布局之间的关系进行布局,但其灵活性要高于 RelativeLayou...
    继续阅读 »

    约束布局


    约束布局概念


    ConstraintLayout 可让您使用扁平视图层次结构(无嵌套视图组)创建复杂的大型布局。它与 RelativeLayout相似,其中所有的视图均根据同级视图与父布局之间的关系进行布局,但其灵活性要高于 RelativeLayout,并且更易于与 Android Studio 的布局编辑器配合使用。


    要在 ConstraintLayout 中定义某个视图的位置,您必须为该视图添加至少一个水平约束条件和一个垂直约束条件。每个约束条件均表示与其他视图、父布局或隐形引导线之间连接或对齐方式。每个约束条件均定义了视图在竖轴或者横轴上的位置;因此每个视图在每个轴上都必须至少有一个约束条件,但通常情况下会需要更多约束条件。


    当您将视图拖放到布局编辑器中时,即使没有任何约束条件,它也会停留在您放置的位置。不过,这只是为了便于修改;当您在设备上运行布局时,如果视图没有任何约束条件,则会在位置 [0,0](左上角)处进行绘制。


    从 Android Studio 2.3 起,官方的模板默认使用 ConstraintLayout


    ConstraintLayout 添加到项目中


    如需在项目中使用 ConstraintLayout,请按以下步骤操作:




    1. 确保您的 maven.google.com 代码库已在模块级 build.gradle 文件中声明


       repositories {
      google()
      }
      复制代码

      2将该库作为依赖项添加到同一个文件中,如以下示例所示。请注意,最新版本可能与示例中显示的不同:


      dependencies {
      implementation "androidx.constraintlayout:constraintlayout:2.0.4"
      }
      复制代码



    转换布局


    如需将现有布局转换为约束布局,请按以下步骤操作:




    1. Android Studio 中打开您的布局,然后点击编辑器窗口底部的 Design 标签页。




    2. ComponentTree 窗口中,右键点击该布局,然后点击 Convert layout to ConstraintLayout




    img


    Constraintlayout基本使用


    相对定位,基线



    • layout_constraintLeft_toLeftOf

    • layout_constraintLeft_toRightOf

    • layout_constraintRight_toLeftOf

    • layout_constraintRight_toRightOf

    • layout_constraintTop_toTopOf

    • layout_constraintTop_toBottomOf

    • layout_constraintBottom_toTopOf

    • layout_constraintBottom_toBottomOf

    • layout_constraintBaseline_toBaselineOf //基础线

    • layout_constraintStart_toEndOf

    • layout_constraintStart_toStartOf

    • layout_constraintEnd_toStartOf

    • layout_constraintEnd_toEndOf


    img


    居中




    • app:layout_constraintBottom_toBottomOf=parent




    • app:layout_constraintLeft_toLeftOf=parent




    • app:layout_constraintRight_toRightOf=parent




    • app:layout_constraintTop_toTopOf=parent


      img




    边距



    • android:layout_marginStart

    • android:layout_marginEnd

    • android:layout_marginLeft

    • android:layout_marginTop

    • android:layout_marginRight

    • android:layout_marginBottom


    img


    隐藏边距



    • layout_goneMarginStart

    • layout_goneMarginEnd

    • layout_goneMarginLeft

    • layout_goneMarginTop

    • layout_goneMarginRight

    • layout_goneMarginBottom


    偏移量(Bias)



    • layout_constraintHorizontal_bias

    • layout_constraintVertical_bias


    img


    img


    角度定位



    • layout_constraintCircle : 设置一个控件id

    • layout_constraintCircleRadius : 设置半径

    • layout_constraintCircleAngle :控件的角度 (in degrees, from 0 to 360)


    imgimg


    宽高约束Ratio


    Raito可以根据控件一个边尺寸比重生成另一个边的尺寸。Ration必须设置一个控件宽高尺寸为odp(MATCH_CONSTRAINT)


     //根据宽的边生成高的边按比重1:1
    <Button android:layout_width="wrap_content"
    android:layout_height="0dp"
    app:layout_constraintDimensionRatio="1:1" />
    复制代码

     //高比16:9
    <Button android:layout_width="0dp"
    android:layout_height="0dp"
    app:layout_constraintDimensionRatio="H,16:9"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintTop_toTopOf="parent"/>
    复制代码


    app:layout_constraintVertical_chainStyle="",app:layout_constraintHorizontal_chainStyle=""



    • CHAIN_SPREAD :有点像LinearLayout里面元素设置比重1:1:1 平均分布。

    • CHAIN_SPREAD_INSIDE:链的两边元素靠边,里面元素平均分配距离。

    • CHAIN_PACKED:链的元素挨到一起。


    img


    img


    辅助工具


    优化器Optimizer


    app:layout_optimizationLevel对使用约束布局公开的优化配置项



    • none : 不启动优化

    • standard : 仅优化直接约束和屏障约束(默认)

    • direct : 优化直接约束

    • barrier : 优化屏障约束

    • chain : 优化链约束 (experimental)

    • dimensions :优化尺寸测量(experimental), 减少测量匹配约束布局的节点


    障碍Barrier


    app:barrierDirection=""


    image-20210422184856292.png


    有点像弱化(轻量级)的基础线通过设置指向的方向在此方向位置最远处生成一个虚拟线做一个阻挡作用的线。


    <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">

    <androidx.constraintlayout.widget.Barrier
    android:id="@+id/barrier"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    app:barrierDirection="start"
    app:constraint_referenced_ids="button9,button10,button11" />

    <Button
    android:id="@+id/button9"
    android:layout_width="65dp"
    android:layout_height="50dp"
    android:text="Button"
    tools:layout_editor_absoluteX="108dp"
    tools:layout_editor_absoluteY="341dp" />

    <Button
    android:id="@+id/button10"
    android:layout_width="203dp"
    android:layout_height="49dp"
    android:text="Button"
    tools:layout_editor_absoluteX="84dp"
    tools:layout_editor_absoluteY="242dp" />

    <Button
    android:id="@+id/button11"
    android:layout_width="146dp"
    android:layout_height="49dp"
    android:text="Button"
    tools:layout_editor_absoluteX="71dp"
    tools:layout_editor_absoluteY="437dp" />


    </androidx.constraintlayout.widget.ConstraintLayout>
    复制代码

    image-20210422172658792.png


    Group


    Group可以同意控制引用的控件集合的visible状态。


    <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">


    <androidx.constraintlayout.widget.Group
    android:id="@+id/group"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    app:constraint_referenced_ids="button9,button10,button11" />

    <Button
    android:id="@+id/button9"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Button"
    tools:layout_editor_absoluteX="46dp"
    tools:layout_editor_absoluteY="241dp" />

    <Button
    android:id="@+id/button10"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Button"
    tools:layout_editor_absoluteX="171dp"
    tools:layout_editor_absoluteY="241dp" />

    <Button
    android:id="@+id/button11"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Button"
    tools:layout_editor_absoluteX="296dp"
    tools:layout_editor_absoluteY="237dp" />


    </androidx.constraintlayout.widget.ConstraintLayout>
    复制代码

    image-20210422160952772.png


    指示线Guideline


    //已parent start作为边开始计算


    app:layout_constraintGuide_begin=""


    //已parent end作为边开始计算


    app:layout_constraintGuide_end=""


    //百分比的位置


    app:layout_constraintGuide_percent=""


    <androidx.constraintlayout.widget.Guideline
    android:id="@+id/guideline"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:orientation="vertical"
    app:layout_constraintGuide_begin="196dp" />

    <androidx.constraintlayout.widget.Guideline
    android:id="@+id/guideline2"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:orientation="horizontal"
    app:layout_constraintGuide_begin="336dp" />
    复制代码

    image-20210422151939691.png


    占位符Placeholder


    <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">

    <androidx.constraintlayout.widget.Placeholder
    android:id="@+id/placeholder"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    app:content="@+id/textview"
    app:layout_constraintLeft_toLeftOf="parent"
    app:layout_constraintTop_toTopOf="parent" />

    <ImageView
    android:id="@+id/textview"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:src="@drawable/ic_launcher_background"
    app:layout_constraintRight_toRightOf="parent"
    app:layout_constraintTop_toTopOf="parent"
    android:onClick="toSetGoneWithPlaceHolder"
    />


    </androidx.constraintlayout.widget.ConstraintLayout>
    复制代码

    image-20210422160434685.png


    placehoder提供了一个虚拟(空的)控件,但是它可以成一个布局已经存在的控件


    使用setContent()方法在placehoder上设置一个其他控件的id,placehoder会成为设置控件id的内容,如果显示内容的控件存在屏幕内它会从隐藏


    通过PlaceHolder的参数来显示内容.


    设置约束布局


    可以通过代码的方式设置约束布局的属性


    //创建一个Constraint数据集合
    ConstraintSet c = new ConstraintSet();
    //Copy布局的配置
    c.clone(mContext, R.layout.mine_info_view);
    //新增或者替换行为参数
    c.setVerticalChainStyle(userNameView.getId(),chain);
    //执行
    c.applyTo(this.<ConstraintLayout>findViewById(R.id.constraintlayout));

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

    mpvue不维护了,已经成型的mpvue项目怎么办

    mpvue作为美团技术团队的一个KPI产品,莫名其妙突然就不维护了,随着node版本和项目依赖不断更新,你会发现你原先的项目可能突然跑不起来了,此时你需要mpvue的替代品,没错,我要说的就是uni-app。只需几步,你可以很轻松的把mpvue项目迁移到uni...
    继续阅读 »

    mpvue作为美团技术团队的一个KPI产品,莫名其妙突然就不维护了,随着node版本和项目依赖不断更新,你会发现你原先的项目可能突然跑不起来了,此时你需要mpvue的替代品,没错,我要说的就是uni-app。

    只需几步,你可以很轻松的把mpvue项目迁移到uni-app。

    先去官网按步骤建好项目

    https://uniapp.dcloud.io/quickstart

    1、 把mpvue项目里src目录的文件复制到uni-app项目里


    2、把main.js搬到uniapp的page.json里

    mpvue的main.js


    搬过来之后是这样的


    3、运行,看看css是否跟原版有偏差,重新调整。此外要把api改成uni-app的,例如发请求api的要换成这个

    https://uniapp.dcloud.io/api/request/request



    收起阅读 »

    Jetpack Compose TriStateCheckbox,Checkbox,Switch用法详解

    这篇文章我们会通过分析TriStateCheckbox,Checkbox,Switch 他们的代码,并且讲解他们每个属性的含义以及用法。 一:TriStateCheckbox 我们来看下TriStateCheckbox的代码 @Composable fun T...
    继续阅读 »

    这篇文章我们会通过分析TriStateCheckbox,Checkbox,Switch 他们的代码,并且讲解他们每个属性的含义以及用法。


    一:TriStateCheckbox


    我们来看下TriStateCheckbox的代码


    @Composable
    fun TriStateCheckbox(
    state: ToggleableState,
    onClick: (() -> Unit)?,
    modifier: Modifier = Modifier,
    enabled: Boolean = true,
    interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
    colors: CheckboxColors = CheckboxDefaults.colors()
    ){
    ...
    }
    复制代码


    • state 按钮的状态,有三种ToggleableState.On 中间打钩,ToggleableState.Off不选中,ToggleableState.Indeterminate 中间是横杠的。

    • onClick 点击回调

    • modifier 修饰符,我们在以前文章讲过Modifier用法详解

    • enabled 是否可用

    • interactionSource 处理状态的属性,比如按下的时候什么效果,正常时候什么效果,获取焦点时候什么效果等。类似之前再布局文件里写Selector。interactionSource.collectIsPressedAsState() 判断是否按下状态interactionSource.collectIsFocusedAsState() 判断是否获取焦点的状态interactionSource.collectIsDraggedAsState() 判断是否拖动

    • colors 设置颜色值CheckboxDefaults.colors(checkedColor,uncheckedColor,disabledColor,checkmarkColor,disabledIndeterminateColor) checkedColor表示选中时候的背景填充的颜色,uncheckedColor没有选中时候的背景颜色,disabledColor不可用时候的背景色,checkmarkColor这个指的是框里面的打钩,横杠图标的颜色。disabledIndeterminateColor当不可用时,且状态ToggleableState.Indeterminate的时候的颜色。


    比如我们举例:当是打钩选中的时候,再点击我们变成横杠,当是横杠的时候点击变成不选中,当是不选中的时候,点击变成选中。并且当属于按下状态的时候,我们的背景色改成红色,否则选中背景色是绿色。代码如下


    @Preview()
    @Composable
    fun triStateCheckboxTest(){
    val context = LocalContext.current
    val interactionSource = remember {
    MutableInteractionSource()
    }
    val pressState = interactionSource.collectIsPressedAsState()
    val borderColor = if (pressState.value) Color.Green else Color.Black
    var isCheck = remember {
    mutableStateOf(false)
    }

    var toggleState = remember {
    mutableStateOf(ToggleableState(false))
    }

    Column(modifier = Modifier.padding(10.dp,10.dp)) {
    TriStateCheckbox(
    state = toggleState.value,
    onClick = {
    toggleState.value = when(toggleState.value){
    ToggleableState.On->{
    ToggleableState.Indeterminate
    }
    ToggleableState.Off->ToggleableState.On
    else-> ToggleableState.Off
    }
    },
    modifier = Modifier.size(50.dp),
    enabled = true,
    interactionSource = interactionSource,
    colors = CheckboxDefaults.colors(
    checkedColor= if(pressState.value) Color.Red else Color.Green,
    uncheckedColor = Color.Gray,
    disabledColor = Color.Gray,
    checkmarkColor = Color.White,
    disabledIndeterminateColor = Color.Yellow
    )
    )
    }
    }
    复制代码

    二:Checkbox


    Checkbox其实内部就是new了个TriStateCheckbox。只是CheckBox没有ToggleableState.Indeterminate的情况,只有选中和不选中。代码如下:


    @Composable
    fun Checkbox(
    checked: Boolean,
    onCheckedChange: ((Boolean) -> Unit)?,
    modifier: Modifier = Modifier,
    enabled: Boolean = true,
    interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
    colors: CheckboxColors = CheckboxDefaults.colors()
    ) {
    TriStateCheckbox(
    state = ToggleableState(checked),
    onClick = if (onCheckedChange != null) { { onCheckedChange(!checked) } } else null,
    interactionSource = interactionSource,
    enabled = enabled,
    colors = colors,
    modifier = modifier
    )
    }
    复制代码


    • checked 是否选中

    • onCheckedChange 选中改变的监听

    • modifier 修饰符

    • enabled 是否可用

    • interactionSource 跟上面一样

    • colors 跟上面一样


    举例:


    @Preview()
    @Composable
    fun checkBoxTest(){
    val context = LocalContext.current
    val interactionSource = remember {
    MutableInteractionSource()
    }
    val pressState = interactionSource.collectIsPressedAsState()
    val borderColor = if (pressState.value) Color.Green else Color.Black
    var isCheck = remember {
    mutableStateOf(false)
    }

    Column(modifier = Modifier.padding(10.dp,10.dp)) {
    Checkbox(
    checked = isCheck.value,
    onCheckedChange = {
    isCheck.value = it
    },
    modifier = Modifier.size(50.dp),
    enabled = true,
    interactionSource = interactionSource,
    colors = CheckboxDefaults.colors(
    checkedColor= Color.Red,
    uncheckedColor = Color.Gray,
    disabledColor = Color.Gray,
    checkmarkColor = Color.White,
    disabledIndeterminateColor = Color.Yellow
    )
    )
    }
    }
    复制代码

    三 Switch


    Switch 开关控件,代码如下:


    @Composable
    @OptIn(ExperimentalMaterialApi::class)
    fun Switch(
    checked: Boolean,
    onCheckedChange: ((Boolean) -> Unit)?,
    modifier: Modifier = Modifier,
    enabled: Boolean = true,
    interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
    colors: SwitchColors = SwitchDefaults.colors()
    ) {
    ...
    }
    复制代码


    • checked 是否选中

    • onCheckedChange 选中改变的监听

    • modifier 修饰符

    • enabled 是否可用

    • interactionSource 跟上面一样

    • colors 设置各种颜色 通过SwitchDefaults.colors设置,SwitchDefaults.colors的代码如下
       @Composable
      fun colors(
      checkedThumbColor: Color = MaterialTheme.colors.secondaryVariant,
      checkedTrackColor: Color = checkedThumbColor,
      checkedTrackAlpha: Float = 0.54f,
      uncheckedThumbColor: Color = MaterialTheme.colors.surface,
      uncheckedTrackColor: Color = MaterialTheme.colors.onSurface,
      uncheckedTrackAlpha: Float = 0.38f,
      disabledCheckedThumbColor: Color = checkedThumbColor
      .copy(alpha = ContentAlpha.disabled)
      .compositeOver(MaterialTheme.colors.surface),
      disabledCheckedTrackColor: Color = checkedTrackColor
      .copy(alpha = ContentAlpha.disabled)
      .compositeOver(MaterialTheme.colors.surface),
      disabledUncheckedThumbColor: Color = uncheckedThumbColor
      .copy(alpha = ContentAlpha.disabled)
      .compositeOver(MaterialTheme.colors.surface),
      disabledUncheckedTrackColor: Color = uncheckedTrackColor
      .copy(alpha = ContentAlpha.disabled)
      .compositeOver(MaterialTheme.colors.surface)
      ): SwitchColors = DefaultSwitchColors(
      checkedThumbColor = checkedThumbColor,
      checkedTrackColor = checkedTrackColor.copy(alpha = checkedTrackAlpha),
      uncheckedThumbColor = uncheckedThumbColor,
      uncheckedTrackColor = uncheckedTrackColor.copy(alpha = uncheckedTrackAlpha),
      disabledCheckedThumbColor = disabledCheckedThumbColor,
      disabledCheckedTrackColor = disabledCheckedTrackColor.copy(alpha = checkedTrackAlpha),
      disabledUncheckedThumbColor = disabledUncheckedThumbColor,
      disabledUncheckedTrackColor = disabledUncheckedTrackColor.copy(alpha = uncheckedTrackAlpha)
      )
      复制代码


      • checkedThumbColor 当没有设置checkedTrackColor的时候。表示选中的背景颜色(圆形部分,包括横的部分),当有设置checkedTrackColor则该属性只作用再圆形的部分

      • checkedTrackColor 这个是表示开关开起来的时候横线部分的背景

      • checkedTrackAlpha 这个是表示开关开起来的时候横线部分的背景的透明度

      • uncheckedThumbColor 当没有设置uncheckedTrackColor的时候。表示没有选中的背景颜色(圆形部分,包括横的部分),当有设置uncheckedTrackColor则该属性只作用再圆形的部分

      • uncheckedTrackColor 这个是表示开关关闭的时候横线部分的背景

      • uncheckedTrackAlpha 这个是表示开关关闭的时候横线部分的背景的透明度

      • disabledCheckedThumbColor 表示不可用的时候的并且选中时候背景颜色 有设置disabledCheckedTrackColor则只作用于圆形部分,没有设置disabledCheckedTrackColor则作用于圆形跟横线部分

      • disabledCheckedTrackColor 表示不可用的时候并且选中时候的横线部分的背景颜色

      • disabledUncheckedThumbColor 表示不可用的时候的并且开关关闭的时候背景颜色 有设置disabledUncheckedTrackColor则只作用于圆形部分,没有设置disabledUncheckedTrackColor则作用于圆形跟横线部分

      • disabledUncheckedTrackColor 表示不可用的时候的并且开关关闭的时候的横线部分的背景颜色




    @Preview()
    @Composable
    fun switchTest(){
    val context = LocalContext.current
    val interactionSource = remember {
    MutableInteractionSource()
    }
    val pressState = interactionSource.collectIsPressedAsState()
    val checkedThumbColor = if (pressState.value) Color.Green else Color.Red
    var isCheck = remember {
    mutableStateOf(false)
    }

    Column(modifier = Modifier.padding(10.dp,10.dp)) {
    Switch(
    checked = isCheck.value,
    onCheckedChange = {
    isCheck.value = it
    },
    // modifier = Modifier.size(50.dp),
    enabled = true,
    interactionSource = interactionSource,
    colors = SwitchDefaults.colors(checkedThumbColor= checkedThumbColor,checkedTrackColor=Color.Yellow,checkedTrackAlpha = 0.1f)
    )
    }
    }

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

    iOS - UIStackView 布局 详解

    一、UIStackView简介概念:一个堆叠视图的容器,iOS9的新特性。用途:StackView及其子视图会自适应界面,减少我们设置约束的工作量。特点:类似ContainView,不会渲染到界面上。StackView中的子视图只能朝一个方向进行排布,要么水平...
    继续阅读 »

    一、UIStackView简介

    概念:

    一个堆叠视图的容器,iOS9的新特性。
    用途:StackView及其子视图会自适应界面,减少我们设置约束的工作量。

    特点:

    • 类似ContainView,不会渲染到界面上。
    • StackView中的子视图只能朝一个方向进行排布,要么水平要么垂直。
    • StackView支持多层嵌套
    • 约束比StackView的自适应优先级高,可以通过设置约束来调整StackView的布局
    • 支持属性动画
    • 不能滚动

    属性:

    axis轴: -> 用来设置子视图的排列方式(H/V)
    aligement: -> 用来设置子视图的对齐方式
    distribution -> 用来设置子视图的分布方式(fill-填充)
    spacing -> 子视图之间的间距

    二、属性详解

    1. axis

    主要设置UIStackView布局的方向:水平方向或垂直方向。

    typedefNS_ENUM(NSInteger,UILayoutConstraintAxis) {
    UILayoutConstraintAxisHorizontal =0, //水平
    UILayoutConstraintAxisVertical =1 //垂直
    };
    2. alignment

    主要设置非轴方向子视图的对齐方式。

    typedef NS_ENUM(NSInteger, UIStackViewAlignment) {
    UIStackViewAlignmentFill, // 子视图填充
    UIStackViewAlignmentLeading, // 子视图左对齐(axis为垂直方向而言)
    UIStackViewAlignmentTop = UIStackViewAlignmentLeading, // 子视图顶部对齐(axis为水平方向而言)
    UIStackViewAlignmentFirstBaseline, // 按照第一个子视图的文字的第一行对齐,同时保证高度最大的子视图底部对齐(只在axis为水平方向有效)
    UIStackViewAlignmentCenter, // 子视图居中对齐
    UIStackViewAlignmentTrailing, // 子视图右对齐(axis为垂直方向而言)
    UIStackViewAlignmentBottom = UIStackViewAlignmentTrailing, // 子视图底部对齐(axis为水平方向而言)
    UIStackViewAlignmentLastBaseline, // 按照最后一个子视图的文字的最后一行对齐,同时保证高度最大的子视图顶部对齐(只在axis为水平方向有效)
    } API_AVAILABLE(ios(9.0));

    具体显示效果如下:







    3. distribution

    设置轴方向上子视图的分布比例(如果axis是水平方向,也即设置子视图的宽度,如果axis是垂直方向,则是设置子视图的高度)。

    typedef NS_ENUM(NSInteger, UIStackViewDistribution) {
    UIStackViewDistributionFill = 0,
    UIStackViewDistributionFillEqually,
    UIStackViewDistributionFillProportionally,
    UIStackViewDistributionEqualSpacing,
    UIStackViewDistributionEqualCentering,
    } API_AVAILABLE(ios(9.0));

    下面以
    axis = UILayoutConstraintAxisHorizontal,
    alignment = UIStackViewAlignmentCenter
    为例:

    往UIStackView中添加三个UIView:

    1. 第一个UIView设为40*100
    2. 第二个UIView设为80*80
    3. 第三个UIView设为120*60

    通过实例来说明每个属性的区别:

    (1)UIStackViewDistributionFill = 0,默认属性,轴方向上填充UIStackView。如果axis为水平方向,则所有子视图的宽度等于UIStackView的宽,所以如果只有一个子视图,则子视图的宽度就等于UIStackView的宽,如果有两个子视图,且优先级一样,则会拉伸或压缩某个子视图,使两个子视图的宽度之和等于UIStackView的宽……,如果axis是垂直方向,则所有子视图的高度等于UIStackView的高,必要时会拉伸或压缩某个子视图。

    上面是在子视图优先级一致的情况下,如果子视图优先级不一致,则会按优先级从高到低设置子视图的位置,对优先级最低的子视图进行必要的拉伸或压缩。

    设置distribution = UIStackViewDistributionFill后显示效果:


    UIStackViewDistributionFill

    如图所示,由于三个子视图的宽度之和不够UIStackView的宽度,优先级又一致,所以第三个子视图被拉伸了。当然,我们可以修改某个子视图的优先级来让其被拉伸。

    (2)UIStackViewDistributionFillEqually,该属性设置后使所有子视图在轴方向上等宽或等高。即如果是水平方向,所有子视图都会被必要的拉伸或压缩,使得每个子视图的宽度一致,原来设置的子视图的宽度都会被忽略;如果是垂直方向,所有子视图的高度也会保持一致,如下所示:


    UIStackViewDistributionFillEqually

    (3)UIStackViewDistributionFillProportionally 该属性设置后会根据原先子视图的比例来拉伸或压缩子视图的宽或高,如实例中三个子视图原先设置的宽度是1:2:3,所以水平方向上显示时,会按照这个比例进行拉伸,如下图所示,拉伸后的宽度依然是1:2:3。


    UIStackViewDistributionFillProportionally

    (4)UIStackViewDistributionEqualSpacing 该属性会保持子视图的宽高,所有子视图中间的间隔保持一致。如下图所示,图中子视图的间隔(绿线所示的长度)都是一致的。


    UIStackViewDistributionEqualSpacing

    (5)UIStackViewDistributionEqualCentering 该属性是控制所有子视图的中心之间的距离保持一致,如下图所示,子视图中心点之间的间隔(绿线所示的长度)是一致的。


    UIStackViewDistributionEqualCentering

    4. spacing

    该属性控制子视图之间的间隔大小,在distribution前三个属性值设置的情况下,子视图之间是没有间隔,我们可以通过spacing属性显式的设置,如下图在distribution=UIStackViewDistributionFillEqually情况下,设置子视图间隔为10,子视图之间间隔都为10,且子视图依然等宽。


    三、subView和arrangedSubView

    对于Stack View的子控件添加和移除,我们是这样描述的。

    添加 --> (Stack View管理的subview)
    addArrangedSubview:
    insertArrangedSubview:atIndex: arrangedSubviews
    数组是subviews属性的子集。
    移除 --> (Stack View管理的subview)
    removeArrangedSubview:–>移除是指移除Stack View内部子控件的约束,并没有真正的把控件从父视图上移除。
    removeFromSuperview–>从视图层次结构中删除,从父视图上删除

    四、知识点小结

    1、Axis表示Stack View的subview是水平排布还是垂直排布。
    2、Alignment控制subview对齐方式。
    3、Distribution定义subview的分布方式。
    4、Spacing 为subview间的最小间距。

    五、使用技巧

    **可以hidden指定子view,根据动态拉伸规则,灵活使用组件。

    例如:


    原文链接:https://blog.csdn.net/songzhuo1991/article/details/115626992

    收起阅读 »

    JS实现精确倒计时

    实现倒计时对前端工程师来说,是很常见的需求。那么,要怎么实现精确的倒计时呢?首先,考虑到客户端时间和服务端时间有误差,所以计算倒计时的时候,应该读取服务端的时间。但是,只考虑到这一点还远远不够的。页面运行时间长了,新打开页面的倒计时和原打开页面的倒计时还是存在...
    继续阅读 »

    实现倒计时对前端工程师来说,是很常见的需求。那么,要怎么实现精确的倒计时呢?

    首先,考虑到客户端时间和服务端时间有误差,所以计算倒计时的时候,应该读取服务端的时间。但是,只考虑到这一点还远远不够的。页面运行时间长了,新打开页面的倒计时和原打开页面的倒计时还是存在误差。要减少这里的误差,就要说到Javascript解释器的工作原理。

    Javascript解释器工作原理
    Javascript解释器是单线程工作的,它执行任务按照任务进入队列的先后顺序执行。这会造成什么影响呢?
    打个比方,设置定时器的时候,按照理想状况,下面的程序应当稳定的输出0。

    let start = new Date().getTime()
    let count = 0
    setInterval(function(){
    count++
    console.log(new Date().getTime() - (start + count * 1000))
    },1000)


    由于代码执行占用时间,以及其他事件的阻塞,导致有些事件的执行延迟了几ms,阻塞事件不多时,影响微乎其微。但当我们添加更多的阻塞事件时,这个影响就会被放大,如下面的代码

    let start = new Date().getTime()
    let count = 0
    setInterval(function(){
    let j = 0
    while(j++ < 100000000){}
    },1)
    setInterval(function(){
    count++
    console.log(new Date().getTime() - (start + count * 1000))
    },1000)


    线程阻塞解决方案

    那么我们要怎么解决线程阻塞的问题呢?
    按照正常的思路,如果没有被阻塞,下面设置好的定时器应该每隔1s执行一次。

    setInterval(function(){},1000)

    但是,如果出现阻塞事件,定时器可能就要隔1000+ms才执行一次。要精确的实现每隔1s执行一次,必须要先获取阻塞的时间。这里要用到定时器函数setTimeout控制定时器的执行时间,代码实现如下

    setInterval(function(){
    let j = 0
    while(j++ < 100000000){}
    },1)
    let interval = 1000,
    ms = 50000, //从服务器和活动开始时间计算出的时间差,这里测试用50000ms
    count = 0,
    startTime = new Date().getTime();
    if( ms >= 0){
    var timeCounter = setTimeout(countDownStart,interval);
    }

    第一部分的setInterval是一段阻塞代码。然后,我们分别定义了interval作为定时器的执行时间,距活动结束的时间用ms表示(ms=活动结束时间-服务器时间),
    count表示计数器,然后启动定时器timeCounter。其中,countDownStart函数的实现逻辑如下

    function countDownStart(){
    count++;
    let offset = new Date().getTime() - (startTime + count * interval);
    let nextTime = interval - offset;
    if (nextTime < 0) { nextTime = 0 };
    ms -= interval;
    console.log("误差:" + offset + "ms" );
    if(ms < 0){
    clearTimeout(timeCounter);
    }else{
    timeCounter = setTimeout(countDownStart,nextTime);
    }
    }

    countDownStart的实现原理是,首先定义一个变量offset用来记录阻塞导致延误的时间是多少。nextTime代表offset和interval的差距,根据nextTime修改定时器timeCounter的执行时间,使它nextTime(ms)执行一次。

    打个比方,如果上一次执行过程中因为阻塞延误了100ms,那么下一次就提前100ms启动定时器,即

    timeCounter = setTimeout(countDownStart,900)



    原文链接:https://blog.csdn.net/weixin_41672178/article/details/88372553

    收起阅读 »

    iOS -SEL、Method 和 IMP区别及使用

    Runtime中,SEL、Method 和 IMP有什么区别,使用场景?SEL:定义: typedef struct objc_selector *SEL,代表方法的名称。仅以名字来识别。翻译成中文叫做选择子或者选择器,选择子代表方法在 Runtime期间的标...
    继续阅读 »

    Runtime中,SEL、Method 和 IMP有什么区别,使用场景?

    SEL:定义: typedef struct objc_selector *SEL,代表方法的名称。
    仅以名字来识别。翻译成中文叫做选择子或者选择器,选择子代表方法在 Runtime期间的标识符。为 SEL类型,虽然 SEL是 objc_selector 结构体指针,但实际上它只是一个 C 字符串。

          在类加载的时候,编译器会生成与方法相对应的选择子,并注册到 Objective-C的 Runtime 运行系统。不论两个类是否存在依存关系,只要他们拥有相同的方法名,那么他们的SEL都是相同的。
         比如,有n个viewcontroller页面,每个页面都有一个viewdidload,每个页面的载入,肯定都是不尽相同的。但是我们可以通过打印,观察发现,这些viewdidload的SEL都是同一个
    SEL sel = @selector(methodName); // 方法名字 NSLog(@"address = %p",sel);// log输出为 address = 0x1df807e29因此类方法定义时,尽量不要用相同的名字,就算是变量类型不同也不行。否则会引起重复,例如:
    -(void)setWidth:(int)width; -(void)setWidth:(double)width;
    IMP:定义:typedef id (*IMP)(id, SEL, ...),代表函数指针,即函数执行的入口。该函数使用标准的 C调用。第一个参数指向 self(它代表当前类实例的地址,如果是类则指向的是它的元类),作为消息的接受者;第二个参数代表方法的选择子;... 代表可选参数,前面的 id 代表返回值。

    Method:定义:typedef struct objc_method *Method,Method对开发者来说是一种不透明的类型,被隐藏在我们平时书写的类或对象的方法背后。它是一个objc_method结构体指针,我们可以看到该结构体中包含一个SEL和IMP,实际上相当于在SEL和IMP之间作了一个映射。有了SEL,我们便可以找到对应的IMP,从而调用方法的实现代码。 objc_method的定义为:

    /// Method
    struct objc_method {
    SEL method_name;
    char *method_types;
    IMP method_imp;
    };

    方法名 method_name 类型为 SEL,相同名字的方法即使在不同类中定义,它们的方法选择器也相同。

    方法类型 method_types 是个 char 指针,其实存储着方法的参数类型和返回值类型,即是 Type Encoding 编码。

    method_imp 指向方法的实现,本质上是一个函数的指针

    SEL selector的简写,俗称方法选择器,实质存储的是方法的名称
    IMP implement的简写,俗称方法实现,看源码得知它就是一个函数指针
    Method 对上述两者的一个包装结构.



    转自:https://www.jianshu.com/p/3db9622209e2
    收起阅读 »

    iOS-通过Runtime防止重复点击-UIButton、UITableView

    Gesture有系统处理单机双击,暂不去自定义时间间隔了。只处理UIButton、UITableView(UICollectionView)1、思路:UIButton hook sendActionUITableView hook setDelegate(sw...
    继续阅读 »

    Gesture有系统处理单机双击,暂不去自定义时间间隔了。只处理UIButton、UITableView(UICollectionView)

    1、思路:

    UIButton hook sendAction
    UITableView hook setDelegate(swift中没有此方法,改用OC)
    Gesture hook initWithTarget:action:

    注意:
    1、hook button的sendAction方法其实hook的是UIControl的的sendAction,点击UIControl子类(导航栏返回按钮)会崩溃。因此,把UIButton hook换为UIControl hook即可,同时为了避免对其他UIControl子类(UISlider/UISwitch)造成影响和最小影响原则,默认关闭防止重复点击功能

    [_UIButtonBarButton xx_sendActionWithAction:to:forEvent:]: unrecognized selector sent to instance 0x7f8e2a41b380'

    2、OC中的方法是NSDate.date.timeIntervalSince1970,不是[[NSDate date] timeIntervalSince1970]

    3、由于setDelegate方法可能被多次调用,所以要判断是否已经swizzling了,防止重复执行。基类A中hook了tableview之后,子类B、C分别setDelegate的话会调用两次method_exchange...(didSelectRowAtIndexPath)。具体表现为:基类为UITableViewController时无影响,基类为自定义的有UITableView的VC时,子类A正常,子类B异常。解决办法1:didSelectRow基类里面不写,子类里面自己去实现,或基类里面写了但子类各自去重写。解决方法2:更安全的运行时方法交换库 Aspects。

    2、代码

    +(void)load{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
    SEL originalAppearSelector = @selector(setDelegate:);
    SEL swizzingAppearSelector = @selector(my_setDelegate:);
    method_exchangeImplementations(class_getInstanceMethod([self class], originalAppearSelector), class_getInstanceMethod([self class], swizzingAppearSelector));
    });
    }
    -(void)my_setDelegate:(id<UITableViewDelegate>)delegate{
    [self my_setDelegate:delegate];

    SEL sel = @selector(tableView:didSelectRowAtIndexPath:);
    SEL sel_t = @selector(my_tableView:didSelectRowAtIndexPath:);

    //如果没实现tableView:didSelectRowAtIndexPath:就不需要hook
    if (![delegate respondsToSelector:sel]){
    return;
    }
    BOOL addsuccess = class_addMethod([delegate class],
    sel_t,
    method_getImplementation(class_getInstanceMethod([self class], sel_t)),
    nil);

    //如果添加成功了就直接交换实现, 如果没有添加成功,说明之前已经添加过并交换过实现了
    if (addsuccess) {
    Method selMethod = class_getInstanceMethod([delegate class], sel);
    Method sel_Method = class_getInstanceMethod([delegate class], sel_t);
    method_exchangeImplementations(selMethod, sel_Method);
    }
    }

    // 由于我们交换了方法, 所以在tableview的 didselected 被调用的时候, 实质调用的是以下方法:
    -(void)my_tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath{

    if(NSDate.date.timeIntervalSince1970 - tableView.acceptEventTime < tableView.accpetEventInterval) {
    NSLog(@"点击太快了");
    return;
    }
    if (tableView.accpetEventInterval > 0) {
    tableView.acceptEventTime = NSDate.date.timeIntervalSince1970;
    }
    [self my_tableView:tableView didSelectRowAtIndexPath:indexPath];
    }

    3、注意点、风险点

    1、避免交换父类方法
    如果当前类未实现被交换的方法而父类实现了的情况下,此时父类的实现会被交换,若此父类的多个继承者都在交换时会导致方法被交换多次而混乱,同时当调用父类的方法时会因为找不到而发生崩溃。所以在交换前都应该先尝试为当前类添加被交换的函数的新的实现IMP,如果添加成功则说明类没有实现被交换的方法,则只需要替代分类交换方法的实现为原方法的实现,如果添加失败,则原类中实现了被交换的方法,则可以直接进行交换。
    2、load方法的加载顺序和相互影响
    一个类B可能有继承来的super类A,还有可能有自己的分类C,如果分类中也实现了load方法,它们的调用顺序是怎么样的呢?系统首先会调用super的load方法,然后再调用类B自身的load方法,再次才会调用类B的分类C的load方法,也即是说真个继承链包括分类扩展中的load方法都会被执行到,只是执行顺序需要关注一下。load方法不同于其他覆盖方法在分类中的体现,如果类B本身中的其他方法在分类C中被重写,则会优先执行分类C中的。但是load不同,都会被执行到,因为这是类加载设置的方法。
    3、出问题难排查
    文本长按-编辑-复制或剪切的点击事件,需要过滤


    摘自链接:https://www.jianshu.com/p/5499c7a4cba3
    收起阅读 »

    iOS-Crash文件的解析

    开发程序的过程中不管我们已经如何小心,总是会在不经意间遇到程序闪退。脑补一下当你在一群人面前自信的拿着你的App做功能预演的时候,流畅的操作被无情地Crash打断。联想起老罗在发布Smartisan OS的时候说了,他准备了10个手机,如果一台有问题,就换一台...
    继续阅读 »

    开发程序的过程中不管我们已经如何小心,总是会在不经意间遇到程序闪退。脑补一下当你在一群人面前自信的拿着你的App做功能预演的时候,流畅的操作被无情地Crash打断。联想起老罗在发布Smartisan OS的时候说了,他准备了10个手机,如果一台有问题,就换一台,如果10台后挂了他就不做手机了。好了不闲扯了,今天就跟大家一起聊聊iOSCrash文件的组成以及常用的分析工具。

    一、Crash文件结构

    当程序运行Crash的时候,系统会把运行的最后时刻的运行信息记录下来,存储到一个文件中,也就是我们所说的Crash文件。iOS的Crash日志通常由以下6各部分组成。

    1、Process Information(进程信息)


    2、Basic Information


    3、Exception(非常重要


    4、Thread Backtrace


    发生Crash的线程的Crash调用栈,从上到下分别代表调用顺序,最上面的一个表示抛出异常的位置,依次往下可以看到API的调用顺序。上图的信息表明本次Crash出现xxxViewController的323行,出错的函数调用为orderCountLoadFailed。

    5、Thread State


    Crash时发生时刻,线程的状态,通常我们根据Crash栈即可获取到相关信息,这部分一般不用关心。

    6、Binary Images


    Crash时刻App加载的所有的库,其中第一行是Crash发生时我们App可执行文件的信息,可以看出为armv7,可执行文件的包得uuid位c0f……cd65,解析Crash的时候dsym文件的uuid必须和这个一样才能完成Crash的符号化解析。

    二、常见的Crash类型

    1、Watchdog timeout

    Exception Code:0x8badf00d, 不太直观,可以读成“eat bad food”,意思是don‘t block main thread

    紧接着下面会有一段描述:

    Application Specific Information:

    com.xxx.yyy   failed to resume in time

    对于此类Crash,我们应该去审视自己App初始化时做的事情是否正确,是否在主线程请求了网络,或者其他耗时的事情卡住了正常初始化流程。

    通常系统允许一个App从启动到可以相应用户事件的时间最多为5S,如果超过了5S,App就会被系统终止掉。在Launch,resume,suspend,quit时都会有相应的时间要求。在Highlight Thread里面我们可以看到被终止时调用到的位置,xxxAppDelegate加上行号。 

    PS. 在连接Xcode调试时为了便于调试,系统会暂时禁用掉Watchdog,所以此类问题的发现需要使用正常的启动模式。

    2、User force-quit

    Exception Codes: 0xdeadfa11, deadfall

    这个强制退出跟我们平时所说的kill掉后台任务操作还不太一样,通常在程序bug造成系统无法响应时可以采用长按电源键,当屏幕出现关机确认画面时按下Home键即可关闭当前程序。

    3、Low Memory termination

    跟一般的Crash结构不太一样,通常有Free pages,Wired Pages,Purgeable pages,largest process 组成,同事会列出当前时刻系统运行所有进程的信息。

    关于Memory warning可以参看我之前写的一篇文章IOS 内存警告 Memory warning level

    App在运行过程中,系统内存紧张时通常会先发警告,同时把后台挂起的程序终止掉,最终如果还是内存不够的话就会终止掉当前前台的进程。

    当接受到内存警告的事后,我们应该释放尽可能多的内存,Crash其实也可以看做是对App的一种保护。

    4、Crash due to bugs

    因为程序bug导致的Crash通常千奇百怪,很难一概而论。大部分情况通过Crash日志就可以定位出问题,当然也不排除部分疑难杂症看半天都不值问题出在哪儿。这个就只能看功底了,一点点找,总是能发现蛛丝马迹。是在看不出来时还可以求助于Google大神,总有人遇到和你一样的Bug 

    三、常见的Exception Type & Exception Code

    1、Exception Type

    1)EXC_BAD_ACCESS

    此类型的Excpetion是我们最长碰到的Crash,通常用于访问了不改访问的内存导致。一般EXC_BAD_ACCESS后面的"()"还会带有补充信息。

    SIGSEGV: 通常由于重复释放对象导致,这种类型在切换了ARC以后应该已经很少见到了。

    SIGABRT:  收到Abort信号退出,通常Foundation库中的容器为了保护状态正常会做一些检测,例如插入nil到数组中等会遇到此类错误。

    SEGV:(Segmentation  Violation),代表无效内存地址,比如空指针,未初始化指针,栈溢出等;

    SIGBUS:总线错误,与 SIGSEGV 不同的是,SIGSEGV 访问的是无效地址,而 SIGBUS 访问的是有效地址,但总线访问异常(如地址对齐问题)

    SIGILL:尝试执行非法的指令,可能不被识别或者没有权限

    2)EXC_BAD_INSTRUCTION

    此类异常通常由于线程执行非法指令导致

    3)EXC_ARITHMETIC

    除零错误会抛出此类异常

    2、Exception Code


    三、获取Crash的途径

    1、本机

    通过xCode连接测试机器,直接在Device中即可读取到该机器上发生的所有Crash log。

    2、itunes connect

    通过itunes connect后台获取到用户上报的Crash日志。

    3、第三方的Crash收集系统

    有很多优秀的第三方Crash收集系统大大的方便了我们收集Crash,甚至还带了符号化Crash日志的功能。比较常用的有CrashlyticsFlurry等。


     Crash日志记录的时候是将Crash发生时刻,函数的调用栈,以及线程等信息写入文件。一般都是直接写的16进制地址,如果不经过符号化的话,基本上很难获取到有用信息,下一篇我们将聊一聊Crash日志的符号化,通俗点讲就是让Crash日志变成我们可读的格式。


    转自:https://www.cnblogs.com/smileEvday/p/Crash1.html

    收起阅读 »

    Kotlin - 内部类

    内部类 内部类就是定义在类内部的类,Kotlin 中的内部类大致分为 2 种: 静态内部类 非静态内部类 静态内部类 在某个类中像普通类一样声明即可,可以认为静态内部类与外部类没有关系,只是定义在了外部类"体内"而已,在使用静态内部类时需要"带上"外部类:...
    继续阅读 »

    内部类


    内部类就是定义在类内部的类,Kotlin 中的内部类大致分为 2 种:



    • 静态内部类

    • 非静态内部类


    静态内部类


    在某个类中像普通类一样声明即可,可以认为静态内部类与外部类没有关系,只是定义在了外部类"体内"而已,在使用静态内部类时需要"带上"外部类:


    class Outer {
    val a: Int = 0

    class Inner {
    val a: Int = 5
    }
    }

    fun main() {
    val outer = Outer()
    println(outer.a)
    val inner = Outer.Inner()
    println(inner.a)
    }
    复制代码


    注意,在 Java 中,这种写法就是在定义 非静态内部类,而 静态内部类 需要在声明时使用 static 修饰。



    非静态内部类


    非静态内部类与静态内部类有的区别有:



    • 非静态内部类 会持有外部类的引用,而 静态内部类 不会(可以认为两者没有关系)。

    • 非静态内部类 使用时需要基于外部类对象(Outer().Inner()),而 静态内部类 则是基于外部类(Outer.Inner())。


    因为 非静态内部类 会持有外部类的引用,所以内部类可以直接使用外部类成员;当非静态内部类与外部类存在同名成员时,可以使用 @标记 来解决歧义:


    class Outer {
    val b: Int = 3
    val a: Int = 0

    inner class Inner {
    val a: Int = 5
    fun test() {
    println("Outer b = $b") // 3,因为持有外部类的引用,所以直接使用外部类成员
    println("Outer a = ${this@Outer.a}") // 0,使用 @Outer 指定this是外部类对象
    println("Inner a = ${this@Inner.a}") // 5,使用 @Inner 指定this是内部类对象
    println("Inner a = ${this.a}") // 5,不使用 @标记 默认this就是内部类对象
    }
    }
    }

    fun main() {
    val inner = Outer().Inner()
    inner.test()
    }
    复制代码

    为了区分 Kotlin 与 Java 中静态内部类和非静态内部类声明上的不同,以下分别使用 Kotlin 和 Java 各自编写内部类代码:


    // Kotlin - 非静态内部类
    class Outer {
    inner class Inner {...}
    }

    // Kotlin - 静态内部类
    class Outer {
    class Inner {...}
    }
    复制代码

    // Java - 非静态内部类
    public class Outer {
    public class Inner {...}
    }

    // Java - 静态内部类
    public class Outer {
    public static class Inner {...}
    }
    复制代码

    匿名内部类


    匿名内部类就是没有定义名字的内部类,一般格式为 object : 接口或(和)类,实际开发中,方法的回调接口(即 callback)一般不会专门声明一个类再创建对象来使用,而是直接使用匿名内部类:


    val textArea = TextArea()
    textArea.addTextListener(object : TextListener {
    override fun textValueChanged(e: TextEvent?) {...}
    })
    复制代码

    Kotlin 的匿名内部类很强大,在使用时,可以有多个接口或父类,如:


    val textArea = TextArea()
    textArea.addTextListener(object : TextField(), TextListener {
    override fun textValueChanged(e: TextEvent?) {...}
    })
    复制代码

    这个匿名内部类既是 TextField 的子类,也是 TextListener 的实现类,不过可能实际应用场景会比较少,了解即可。



    Java 中的匿名内部类就没这么强大了,只能是 单个 接口(或父类) 的 实现类(子类)。


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

    iOS上架unity工程包含UIWebView问题

    在经过一系列的开发之后,来到了游戏上架的步骤,但是在上架的过程中,收到了被拒邮件ITMS-90809: Deprecated API Usage - New apps that use UIWebView are no longer accepted. Ins...
    继续阅读 »

    在经过一系列的开发之后,来到了游戏上架的步骤,但是在上架的过程中,收到了被拒邮件

    ITMS-90809: Deprecated API Usage - New apps that use UIWebView are no longer accepted. 
    Instead, use WKWebView for improved security and reliability.
    Learn more (https://developer.apple.com/documentation/uikit/uiwebview).

    Though you are not required to fix the following issues,
    we wanted to make you aware of them:

    收到这个邮件之后,我首先全局搜索了我的工程中,是否包含UIWebView,但是并没有找到对应的文件。此时,就需要通过命令行来搜索自己的工程中,到底哪些地方包含UIWebView

    1、首先确定包含UIWebView的地方,在命令行中cd到你的工程文件夹下,输入以下命令:

    grep -r UIWebView .



    2、确定包含的UIWebView之后,我们需要处理掉lib.a中的UIWebView

    由于这个是包含在游戏的lib.a的静态库里边,所以,我们要对这个库进行处理,可以通过Git上的自动脚本来处理:

    处理lib.a静态库中的UIWebView

    3、或者也可以自己手动处理(建议使用脚本)

    1.新建URLUtility.mm文件,放在桌面
    复制以下代码

    #include <iostream>
    #import <UIKit/UIKit.h>

    using namespace std;

    namespace core {
    template <class type>
    class StringStorageDefault {};
    template <class type,class type2>
    class basic_string {
    public:
    char *c_str(void);
    };
    }

    void OpenURLInGame(core::basic_string< char,core::StringStorageDefault<char> > const&arg){}

    void OpenURL(core::basic_string<char,core::StringStorageDefault<char> >const&arg){
    const void *arg2= &arg;
    UIApplication *app = [UIApplication sharedApplication];
    NSString *urlStr = [NSString stringWithUTF8String:(char *)arg2];
    NSURL *url = [NSURL URLWithString:urlStr];
    [app openURL:url];
    }

    void OpenURL(std::string const&arg){
    UIApplication *app = [UIApplication sharedApplication];
    NSString *urlStr = [NSString stringWithUTF8String:arg.c_str()];
    NSURL *url = [NSURL URLWithString:urlStr];
    [app openURL:url];

    }

    2.查看Unity项目下libiPhone-lib.a架构

    lipo -info libiPhone-lib.a

    结果如下:
    Architectures in the fat file:
    /Users/xxx/Desktop/libiPhone-lib.a are: arm64 armv7
    则该静态库包含两种框架

    生成URLUtility.mm armv7架构对应的URLUtility.o

    clang -c URLUtility.mm -arch armv7 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk

    新建armv7文件夹,将生成的URLUtility.o放入该文件夹, 后面会用到
    生成URLUtility.mm arm64架构对应的URLUtility.o

    clang -c URLUtility.mm -arch arm64 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk

    新建arm64文件夹,将新生成的URLUtility.o放入该文件夹,后面会用到

    如果有更多架构只需要把armv7替换成对应的架构分别生成

    拆分libiPhone-lib.a
    该命令是拆分libiPhone-lib.a中armv7架构部分
    输出到/Users/xxx/Desktop/armv7/libiPhone-armv7.a
    拆分成armv7架构

    lipo libiPhone-lib.a -thin armv7 -output /Users/xxx/Desktop/armv7/libiPhone-armv7.a

    拆分成arm64架构

    lipo libiPhone-lib.a -thin arm64 -output /Users/xxx/Desktop/arm64/libiPhone-arm64.a

    替换libiPhone-lib.a中的URLUtility.o
    将各自架构libiPhone-lib.a里的URLUtility.o替换为我们生成的

    ar -d 是移除
    ar -q是添加
    移除并且替换armv7中的URLUtility.o

    ar -d /Users/xxx/Desktop/armv7/libiPhone-armv7.a URLUtility.o
    ar -q /Users/xxx/Desktop/armv7/libiPhone-armv7.a /Users/xxx/Desktop/armv7/URLUtility.o

    移除并且替换arm64

    ar -d /Users/xxx/Desktop/arm64/libiPhone-arm64.a URLUtility.o
    ar -q /Users/xxx/Desktop/arm64/libiPhone-arm64.a /Users/xxx/Desktop/arm64/URLUtility.o

    合并libiPhone-lib.a

    该命令的意思是将libiPhone-arm64.a libiPhone-armv7.a合并成桌面上的libiPhone-lib2.a

    lipo -create /Users/xxx/Desktop/arm64/libiPhone-arm64.a /Users/xxx/Desktop/armv7/libiPhone-armv7.a -output /Users/xxx/Desktop/libiPhone-lib2.a

    然后将libiPhone-lib2.a替换进Unity项目中即可使用

    3、替换之后,重新运行,打包工程,提交上架即可

    收起阅读 »

    Kotlin - 区间与数组

    区间(Range) 区间是一个数学上的概念,表示范围。 区间的声明 Kotlin 中可以使用 .. 或 until 来声明区间: val range: IntRange = 0..1024 // 闭区间[0,1024],包括1024 val rangeExcl...
    继续阅读 »

    区间(Range)


    区间是一个数学上的概念,表示范围。


    区间的声明


    Kotlin 中可以使用 ..until 来声明区间:


    val range: IntRange = 0..1024 // 闭区间[0,1024],包括1024
    val rangeExclusive: IntRange = 0 until 1024 // 半开区间[0,1024),不包括1024
    val emptyRange: IntRange = 0..-1 // 空区间[]
    复制代码

    其实这里的 .. 操作符对应的是 Int 类中的一个 rangeTo() 方法:


    /** Creates a range from this value to the specified [other] value. */
    public operator fun rangeTo(other: Byte): IntRange
    /** Creates a range from this value to the specified [other] value. */
    public operator fun rangeTo(other: Short): IntRange
    /** Creates a range from this value to the specified [other] value. */
    public operator fun rangeTo(other: Int): IntRange
    /** Creates a range from this value to the specified [other] value. */
    public operator fun rangeTo(other: Long): LongRange
    复制代码

    区间常用操作


    判断某个元素是否在区间内:


    println(range.contains(50)) // true
    println(500 in range) // true
    复制代码


    这里的 in 关键字对应的就是 IntRange 类中的 contains() 方法,因此上面的两行代码实质上是一样的。



    判断区间是否为空:


    println(rangeExclusive.isEmpty()) // false
    println(emptyRange.isEmpty()) // true
    复制代码

    对区间进行遍历:


    // 输出:0, 1, 2, 3 ..... 1020, 1021, 1022, 1023,
    for (i in rangeExclusive) {
    print("$i, ")
    }
    复制代码


    这里的 infor 配合使用,就可以实现区间的遍历效果。



    区间的类型


    所有的区间都是 ClosedRange 的子类,IntRange 最常用。通过源码不难发现,除了 IntRangeClosedRange 的子类还有 LongRangeCharRange 等等。



    以 CharRange 为例,我们还可以写出 26 个大小写字母的区间:


    // a b c d e f g h i j k l m n o p q r s t u v w x y z
    val lowerRange: CharRange = 'a'..'z'
    // A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
    val upperRange: CharRange = 'A'..'Z'
    复制代码

    数组(Array)


    数组(Array)跟数(Number)没有关系,它指的是一系列对象。


    创建数组


    创建数组一般有 2 种方式:



    1. 使用 Array 类创建数组

    2. 使用库函数 arrayOfXXX() 创建数组


    使用 Array 类创建数组


    先看看 Array 的构造函数:


    public class Array<T> {
    /**
    * Creates a new array with the specified [size], where each element is calculated by calling the specified
    * [init] function. The [init] function returns an array element given its index.
    */
    public inline constructor(size: Int, init: (Int) -> T)

    ...
    }
    复制代码

    使用 Array 创建数组,需要指定元素类型(一般情况下可以省略),有 2 个必传参数,分别是数组长度 size,和元素初始化函数 init。


    val array = Array<String>(5) { index -> "No.$index" }
    println(array.size) // 5
    for (str in array) { // No.0 No.1 No.2 No.3 No.4
    print("$str ")
    }
    复制代码


    当函数参数是最后一个形参时,可以把它写到括号外,这是 Kotlin 中的 lambda 写法,当然,你也可以不用 lambda 写法,就写在括号内:val array = Array<String>(5, { index -> "No.$index" }),关于 lambda 的相关知识在这里暂不细说。



    使用库函数 arrayOfXXX() 创建数组


    直接使用 Array 创建数组会稍稍有点麻烦,要指定个数,又要传入初始化函数, 而实际开发中,我们希望有更方便的写法来提高工作效率,Kotlin 就为此就提供了一系列创建数组的库函数 arrayOfXXX()


    val arrayOfString: Array<String> = arrayOf("我", "是", "LQR")
    val arrayOfHuman: Array<Human> = arrayOf(Boy("温和", "英俊", "浑厚"), Girl("温柔", "甜美", "动人"))
    val arrayOfInt: IntArray = intArrayOf(1, 3, 5, 7)
    val arrayOfChar: CharArray = charArrayOf('H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd')
    复制代码

    要注意,用于存放 String 类型或自定义类型的对象数组 的创建使用的是 arrayOf(),而基本数据类型数组的创建则有专门的库函数,如:intArrayOf()charArrayOf() 等。intArrayOf()charArrayOf() 等库函数是 Kotlin 为了避免基本数据装箱折箱的开销而专门创造出来的,比如:intArrayOf(1, 3, 5, 7) 创建出来的数组是 IntArray 类型,对应到 Java 中是 int[] ,而 arrayOf(1, 2, 3, 4) 创建出来的数组是 Array<Int> 类型,对应 Java 中是 Integer[]


    基本数据类型数组


    为了避免不必要的装箱和拆箱,基本数据类型的数组是定制的:



































    JavaKotlin
    int[]IntArray
    short[]ShortArray
    long[]LongArray
    float[]FloatArray
    double[]DoubleArray
    char[]CharArray


    注意:IntArrayArray<Int> 是完全不同的类型,无法直接相互转换!

    原话:Kotlin 也有无装箱开销的专门的类来表示原生类型数组: ByteArray、 ShortArray、IntArray 等等。这些类与 Array 并没有继承关系,但是它们有同样的方法属性集。



    了解更多 Kotlin 中数组的相关知识,请访问:www.kotlincn.net/docs/refere…


    数组常用操作


    可以使用 .size 获取数组长度,使用 for-in 遍历数组:


    println(arrayOfInt.size) // 4
    for (int in arrayOfInt) { // 1 3 5 7
    print("$int ")
    }
    复制代码

    Array 定义了 get 与 set 函数(按照运算符重载约定这会转变为 []),因此我们可以通过 [] 来获取或修改数组中的元素:


    println(arrayOfHuman[1]) // 我是性格温柔,长相甜美,声音动人的人
    arrayOfHuman[1] = Boy("温和1", "英俊1", "浑厚1")
    println(arrayOfHuman[1]) // 我是性格温和1,长相英俊1,声音浑厚1的人
    复制代码


    注意:自定义类型对象使用 println() 默认输出的是对象地址信息,如:com.charylin.kotlinlearn.Boy@7440e464 ,需要重写类的 toString() 方法来修改输出日志内容。



    CharArray 提供了 joinToString() 方法,用于将字符数组拼接成字符串,默认以 , 作为拼接符:


    println(arrayOfChar.joinToString()) // H, e, l, l, o, W, o, r, l, d
    println(arrayOfChar.joinToString("")) // HelloWorld
    复制代码

    可以使用 slice() 方法对数组进行切片:


    println(arrayOfInt.slice(1..2)) // [3, 5]

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

    【疯狂Android之Kotlin】关于Kotlin的高阶函数

    高阶函数介绍 概念 相信许多同学都已经知道,所谓的高阶函数就是就是方法的参数 或 返回值 是函数类型的 函数 2. 通过例子说明 List 集合的 forEach( )循环 , 该方法就是接收一个高阶函数类型变量作为参数 , 有点类似于C/C++中的函数指...
    继续阅读 »

    高阶函数介绍



    1. 概念


    相信许多同学都已经知道,所谓的高阶函数就是就是方法的参数 或 返回值 是函数类型的 函数
    2. 通过例子说明
    List 集合的 forEach( )循环 , 该方法就是接收一个高阶函数类型变量作为参数 , 有点类似于C/C++中的函数指针(指向函数的指针)


    函数作为函数参数



    1. 这里先介绍下sumBy()这个高阶函数,通过这个我们来看下如何将函数用作参数,源码如下:


    // sumBy函数的源码
    public inline fun CharSequence.sumBy(selector: (Char) -> Int): Int {
    var sum: Int = 0
    for (element in this) {
    sum += selector(element)
    }
    return sum
    }
    复制代码


    1. 说明



    • 大家这里可以不必纠结inline,和sumBy函数前面的CharSequence.。因为这是Koltin中的内联函数与扩展功能。

    • 该函数返回一个Int类型的值。并且接受了一个selector()函数作为该函数的参数。其中,selector()函数接受一个Char类型的参数,并且返回一个Int类型的值。

    • 定义一个sum变量,并且循环这个字符串,循环一次调用一次selector()函数并加上sum。用作累加。其中this关键字代表字符串本身。



    1. 该函数的作用:把字符串中的每一个字符转换为Int的值,用于累加,最后返回累加的值



    • 举个例子


    val testStr = "abc"
    val sum = testStr.sumBy { it.toInt() }
    println(sum)
    复制代码


    • 输出结果


    294  // 因为字符a对应的值为97,b对应98,c对应99,故而该值即为 97 + 98 + 99 = 294
    复制代码

    函数作为函数返回值



    1. 同样这里也是使用一个lock()函数来进行讲解,先看看源码:


    fun <T> lock(lock: Lock, body: () -> T): T {
    lock.lock()
    try {
    return body()
    }
    finally {
    lock.unlock()
    }
    }
    复制代码


    1. 说明



    • 这其中用到了kotlin中泛型的知识点,这里暂且不考虑。同学我会在后续的文章进行介绍。

    • 从源码可以看出,该函数接受一个Lock类型的变量作为参数1,并且接受一个无参且返回类型为T的函数作为参数2.

    • 该函数的返回值为一个函数,我们可以看这一句代码return body()可以看出。



    1. 使用



    • 下面的代码都是伪代码,我就是按照官网的例子直接拿过来用的


    fun toBeSynchronized() = sharedResource.operation()
    val result = lock(lock, ::toBeSynchronized)
    复制代码

    其中,::toBeSynchronized即为对函数toBeSynchronized()的引用,其中关于双冒号::的使用在这里不做讨论与讲解。



    • 上面的写法也可以写作:


    val result = lock(lock, {sharedResource.operation()} )
    复制代码

    函数作为函数类型变量


    这里同学我使用匿名函数来简单讲解一下



    1. 函数变量需求


    在上面的forEach()函数中, 需要传入一个 (String) -> Unit 函数类型的变量, 该函数类型的函数 参数是 String 类型 , 返回值是Unit空类型 ;



    1. 普通的函数声明 : 下面定义的函数 , 参数类型是 String , 返回值是 Unit 空类型 , 这个函数是 (String) -> Unit 类型的 , 但是 study 不能当做参数传入到 forEach 方法中;list.forEach(study),是错误的调用,编译不通过 ;


    fun study(student : String) : Unit{
    println(student + " 在学习")
    }
    复制代码


    1. 函数类型变量 : 可以使用匿名函数 , 赋值给一个变量 , 然后将这个变量当做参数传递给 forEach 当做参数 ;



    • 指定变量 : 为 (String) -> Unit 类型函数指定一个引用变量 var study2 ;

    • 匿名函数 : 顾名思义,就是没有函数名称 , 省略调上面普通函数的名称,赋值给变量 ; 具体用法如下 :


    var study2 = fun (student : String) : Unit{
    println(student + " 在学习")
    }
    复制代码

    高阶函数的使用与示例




    • 在上面的这些例子中,我们出现了str.sumBy{ it.toInt },这样的写法这里主要讲高阶函数中对Lambda语法的简写。




    • 从上面的例子我们的写法应该是这样的:




    str.sumBy( { it.toInt } )
    复制代码


    1. 但是根据Kotlin中的约定,即当函数中只有一个函数作为参数,并且您使用了lambda表达式作为相应的参数,则可以省略函数的小括号()。


    故而我们可以写成:


    str.sumBy{ it.toInt }
    复制代码


    1. 还有一个约定,即当函数的最后一个参数是一个函数,并且你传递一个lambda表达式作为相应的参数,则可以在圆括号之外指定它。故而上面例2中的代码,所以我们可写成:


    val result = lock(lock){
    sharedResource.operation()
    }
    复制代码

    Kotlin常用标准高阶函数介绍


    介绍几个Kotlin中常用的标准高阶函数。如果用好下面的几个函数,能减少很多的代码量,并增加代码的可读性。下面的几个高阶函数的源码几乎上都出自Standard.kt文件


    TODO函数


    其实严格来说,该函数不是一个高阶函数,只是一个抛出异常以及测试错误的一个普通函数



    1. 看下它的源码如下:


    @kotlin.internal.InlineOnly
    public inline fun TODO(): Nothing = throw NotImplementedError()

    @kotlin.internal.InlineOnly
    public inline fun TODO(reason: String): Nothing =
    throw NotImplementedError("An operation is not implemented: $reason")
    复制代码


    • 作用:显示抛出NotImplementedError错误

    • NotImplementedError错误类继承至Java中的Error



    1. 举个例子:


    fun main(args: Array<String>) {
    TODO("测试TODO函数,是否显示抛出错误")
    }
    复制代码


    • 如果调用TODO()时,不传参数的,则会输出An operation is not implemented.


    with()函数


    对于with函数,其实简单来说就是可以让用户省略点号之前的对象引用,针对with对象,在Standard.kt中语法如下


    public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
    contract {
    callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return receiver.block()
    }
    复制代码

    看出with是一个全局函数,并没有作为任何类的扩展方法,仔细查看block会发现它又是一个带接收者的字面函数,这是一种临时的扩展方法,只在调用过程中有效,调用结束之后就不再生效,所以block就成了receiver临时的扩展函数,临时扩展函数的内部调换用上下文就是receiver对象。


    举个栗子


    class MyLogger {
    var tag: String = "TAG"

    fun e(msg: String) {
    println("$tag $i")
    }

    fun tag(tagStr: String) {
    tag = tagStr
    }
    }

    fun main(args: Array<String>) {
    val logger = MyLogger()
    with(logger) {
    tag("Kotlin")
    e("It is a good language")
    }
    }
    复制代码

    apply()函数


    关于apply()函数用于lambda表达式里切换上下文,可以查看


    public inline fun <T> T.apply(block: T.() -> Unit): T {
    contract {
    callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block()
    return this
    }
    复制代码


    • 可以看到block这个函数,它不是一个普通函数,block其实就是带接收者的字面函数,这样传入的lambda表达式就临时扩展了T类,调用lambda表达式时的上下文就是调用方法的T类对象。


    /**
    * @author : Jacky
    * @date: : 2021/2/24
    * 数据库链接
    **/
    class DbConfig {
    var url: String = ""
    var username: String = ""
    var password: String = ""

    override fun toString(): String {
    return "url = $url, username = $username, password = $password"
    }
    }

    class DbConnection {
    fun config(conf: DbConfig) {
    println(conf)
    }
    }

    fun main(args: Array<String>) {
    val conn = DbConnection()

    //上下表达式
    conn.config(DbConfig().apply {
    url = "mysql://127.0.0.1:3306/hello"
    username = "root"
    password = "123456"
    })
    }
    复制代码

    这里使用apply函数,不但初始化了所有属性的值还可以把对象返回来用来配置数据库连接对象


    also()函数



    1. 关于T.also函数来说,它和T.apply很相似。我们先看看其源码的实现:


    public inline fun <T> T.also(block: (T) -> Unit): T {
    contract {
    callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block(this)
    return this
    }
    复制代码


    • 上面的源码在结合T.apply函数的源码我们可以看出: T.also函数中的参数block函数传入了自身对象

    • 这个函数的作用是用用block函数调用自身对象,最后在返回自身对象



    1. 下面举个例子,用实例来说明一下和apply的区别


    "kotlin".also {
    println("结果:${it.plus("-java")}")
    }.also {
    println("结果:${it.plus("-php")}")
    }

    "kotlin".apply {
    println("结果:${this.plus("-java")}")
    }.apply {
    println("结果:${this.plus("-php")}")
    }
    复制代码


    • 输出结果如下


    结果:kotlin-java
    结果:kotlin-php

    结果:kotlin-java
    结果:kotlin-php
    复制代码


    • 可以看出,他们的区别在于:



    • T.also中只能使用it调用自身,而T.apply中只能使用this调用自身。

    • 因为在源码中T.also是执行block(this)后在返回自身。而T.apply是执行block()后在返回自身。

    • 这就是为什么在一些函数中可以使用it,而一些函数中只能使用this的关键所在


    let()函数



    1. 首先查看Standard.kt源文件let函数的源代码


    public inline fun <T, R> T.let(block: (T) -> R): R {
    contract {
    callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
    }
    复制代码

    接收了调用者作为参数并且返回任意的类型的lambda表达式,最后以自己为参数调用lambda表达式


    val arr = intArrayOf(1, 2, 4, 6)
    arr.let {
    var sum = 0
    // 这个it就是arr对象
    for (i in it) {
    sum += i
    }
    println(sum)
    }
    复制代码

    对于系统标准高阶函数的总结



    • 一般我们使用最多就是also,let,apply这三个函数,一般在实际项目开发过程中都不会进行连贯着使用

    • 关于它们之间的区别,或者在什么情况下需要使用那个高阶函数,同学可以参考以下两篇文章



    自定义高阶函数



    1. 多说不易,我们可以看下一个例子:


    // 源代码
    fun test(a : Int , b : Int) : Int{
    return a + b
    }

    fun sum(num1 : Int , num2 : Int) : Int{
    return num1 + num2
    }

    // 调用
    test(10,sum(3,5)) // 结果为:18

    // lambda
    fun test(a : Int , b : (num1 : Int , num2 : Int) -> Int) : Int{
    return a + b.invoke(3,5)
    }

    // 调用
    test(10,{ num1: Int, num2: Int -> num1 + num2 }) // 结果为:18
    复制代码

    以上我们可以看到直接写死了值,这在开发中是非常不合理的,上面的例子在阐述Lambda的语法,另举一个例子



    1. 传入两个参数,并传入一个函数实现不同的逻辑


    private fun resultByOpt(num1 : Int , num2 : Int , result : (Int ,Int) -> Int) : Int{
    return result(num1,num2)
    }

    private fun testDemo() {
    val result1 = resultByOpt(1,2){
    num1, num2 -> num1 + num2
    }

    val result2 = resultByOpt(3,4){
    num1, num2 -> num1 - num2
    }

    val result3 = resultByOpt(5,6){
    num1, num2 -> num1 * num2
    }

    val result4 = resultByOpt(6,3){
    num1, num2 -> num1 / num2
    }

    println("result1 = $result1")
    println("result2 = $result2")
    println("result3 = $result3")
    println("result4 = $result4")
    }
    复制代码


    • 输出结果为


    result1 = 3
    result2 = -1
    result3 = 30
    result4 = 2
    复制代码


    • 根据传入不同的Lambda表达式,实现了两个数的(+、- 、 * 、/)。

    • 当然了,在实际的项目开发中,自己去定义高阶函数的实现是很少了,因为用系统给我们提供的高阶函数已经够用了。

    • 不过,当我们掌握了Lambda语法以及怎么去定义高阶函数的用法后。在实际开发中有了这种需求的时候也难不倒我们了。fighting


    总结



    • 既然我们选择了Kotlin这门编程语言。那其高阶函数时必须要掌握的一个知识点,因为,在系统的源码中,实现了大量的高阶函数操作。

    • 除了上面讲解到的标准高阶函数外,对于字符串(String)以及集合等,都用高阶函数去编写了他们的一些常用操作。比如,元素的过滤、排序、获取元素、分组等等

    • 对于上面讲述到的标准高阶函数,同学我要多实践,因为它们真的能在实际的项目开发中减少大量的代码编写量。

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

    Android 开发经验谈:多线程你了解多少?

     i= i+1;如上代码很简单,在单线程中i就等于i+1,执行不会出问题。但是在多线程中就会有问题。在说多线程之前我从别人的博客里摘了一段文字:大家都知道,计算机在执行程序时,每条指令都是在CPU中执行的,而执行指令过程中,势必涉及到数据的读取和写入...
    继续阅读 »
     

    i= i+1;

    如上代码很简单,在单线程中i就等于i+1,执行不会出问题。

    但是在多线程中就会有问题。

    在说多线程之前我从别人的博客里摘了一段文字:

    大家都知道,计算机在执行程序时,每条指令都是在CPU中执行的,而执行指令过程中,势必涉及到数据的读取和写入。由于程序运行过程中的临时数据是存放在主存(物理内存)当中的,这时就存在一个问题,由于CPU执行速度很快,而从内存读取数据和向内存写入数据的过程跟CPU执行指令的速度比起来要慢的多,因此如果任何时候对数据的操作都要通过和内存的交互来进行,会大大降低指令执行的速度。因此在CPU里面就有了高速缓存。

      也就是,当程序在运行过程中,会将运算需要的数据从主存复制一份到CPU的高速缓存当中,那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据,当运算结束之后,再将高速缓存中的数据刷新到主存当中。

    当线程执行这个语句时,会先从主存当中读取i的值,然后复制一份到高速缓存当中,然后CPU执行指令对i进行加1操作,然后将数据写入高速缓存,最后将高速缓存中i最新的值刷新到主存当中。

    也就是说有两个线程来执行这段代码,在两个线程中都有缓存,计算时都会把i的值写入到自己的缓存中,计算后再进行同步,这就导致计算结果与预期不符。

    为了解决每个线程中都用自己的缓存,于是就采用了关键字volatile

    volatile关键字就会强制变量都从主存中获取

    但是呢...由于volatile加减并非线程安全,volatile并不适用于计算。

    当然也有其专用的使用范围。

    volatile(java5):可以保证多线程下的可见性;

    读volatile:每当子线程某一语句要用到volatile变量时,都会从主线程重新拷贝一份,这样就保证子线程的会跟主线程的一致。

    写volatile: 每当子线程某一语句要写volatile变量时,都会在读完后同步到主线程去,这样就保证主线程的变量及时更新。

    所以在Android 单例模式中,我大多都采用volatile关键字修饰

    当然如何让i=i+1呢?

    咱们可以采用如下几个synchronized, AtomicInteger,lock

    AtomicInteger:

    一个提供原子操作的Integer的类。 一种线程安全的加减操作接口, 相比 synchroized、lock 高效.

    例子:

    private final AtomicInteger mThreadNumber = new AtomicInteger(1);
    mThreadNumber.getAndIncrement()

    这便可以保证线程安全。

    synchronized:

    synchronized是java内置关键字,对象锁,在jvm层面的锁,只能把一块代码锁着,并不能获取到锁的状态。

    悲观锁机制,线程获取的是独占锁,当一个线程进入时后,其他线程被阻塞等待。

    synchronized修饰方法时要注意以下几点:
    1. synchronized关键字不能继承。
    虽然可以使用synchronized来定义方法,但synchronized并不属于方法定义的一部分,因此,synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字,而在子类中覆盖了这个方法,在子类中的这个方法默认情况下并不是同步的,而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然,还可以在子类方法中调用父类中相应的方法,这样虽然子类中的方法不是同步的,但子类调用了父类的同步方法,因此,子类的方法也就相当于同步了。这

    2. 在定义接口方法时不能使用synchronized关键字。

    3. 构造方法不能使用synchronized关键字,但可以使用synchronized代码块来进行同步。

    误区:

    非静态:无论你是对方法标注synchronized还是对类标注synchronized,都是对对象的锁。

    例:

    public class Test {

    int i = 0;
    public synchronized void methon1(){
    i++;
    System.out.println("methon1 "+i);
    }

    public synchronized void methon2(){
    i++;
    System.out.println("methon2 "+i);
    }

    }

    public static void main(String[] args){
    Test test = new Test();
    new Thread(new Runnable() {
    @Override
    public void run() {
    int i =0;
    do {
    test.methon1();
    i++;
    }while (i<100);
    }
    }).start();
    new Thread(new Runnable() {
    @Override
    public void run() {
    int i =0;
    do {
    test.methon2();
    i++;
    }while (i<100);
    }
    }).start();
    }
    }

    输出:
    methon2 1
    methon1 2
    methon2 3
    methon1 4
    methon2 5
    methon1 6
    methon2 7
    methon1 8
    methon2 9
    methon1 10
    methon2 11
    methon1 12
    methon2 13

    所以你要是想对某个方法单独进行方法锁,就必须锁另一个的对象,此时你用静态方法可能比较好呢。

    例:


    Object object = new Object();

    public void methon2(){
    synchronized (object){
    i++;
    System.out.println("methon2 "+i);
    }
    }

    lock:

    需要指定起始位置与终止位置 

    lock 与unlock,锁与释放锁

    一般为了健壮性在finally中调用unlock

    相比synchronized 性能低效,操作比较重量级

    乐观锁机制:假设没有锁,如果有冲突失败,则重试。

    Lock可以知道线程有没有成功获取到锁。

      1)Lock不是Java语言内置的,synchronized是Java语言的关键字,因此是内置特性。Lock是一个类,通过这个类可以实现同步访问;

      2)Lock和synchronized有一点非常大的不同,采用synchronized不需要用户去手动释放锁,当synchronized方法或者synchronized代码块执行完之后,系统会自动让线程释放对锁的占用;而Lock则必须要用户去手动释放锁,如果没有主动释放锁,就有可能导致出现死锁现象。


    sleep/wait区别

    sleep()方法,我们首先要知道该方法是属于Thread类中的native方法。而wait()方法,则是属于Object类中的。

    wait方法需要锁来控制

    sleep 方法导致了程序暂停执行指定的时间,让出cpu该其他线程,但是他的监控状态依然保持者,当指定的时间到了又会自动恢复运行状态。

    在调用sleep()方法的过程中,线程不会释放对象锁。

    而当调用wait()方法的时候,线程会放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象调用notify()方法后本线程才进入对象锁定池准备

    wait/notify机制

    方法名称描述
    notify()随机唤醒等待队列中等待同一共享资源的 “一个线程”,并使该线程退出等待队列,进入可运行状态,也就是notify()方法仅通知“一个线程”
    notifyAll()使所有正在等待队列中等待同一共享资源的 “全部线程” 退出等待队列,进入可运行状态。此时,优先级最高的那个线程最先执行,但也有可能是随机执行,这取决于JVM虚拟机的实现
    wait()使调用该方法的线程释放共享资源锁,然后从运行状态退出,进入等待队列,直到被再次唤醒
    wait(long)超时等待一段时间,这里的参数时间是毫秒,也就是等待长达n毫秒,如果没有通知就超时返回
    wait(long,int)对于超时时间更细力度的控制,可以达到纳秒
    收起阅读 »

    Android添加联系人到通讯录

    本周项目中遇到了需要添加联系人或者添加到已有联系人的需求,联系人中需要保存的字段有很多,之前不太熟悉,在这里总结一下。 字段 联系人名字 名字不知道为什么,值设置了之后传过去没有,于是自己通过Intent最后又单独传了一次 // 联系人名字 ContentVa...
    继续阅读 »

    本周项目中遇到了需要添加联系人或者添加到已有联系人的需求,联系人中需要保存的字段有很多,之前不太熟悉,在这里总结一下。


    字段


    联系人名字

    名字不知道为什么,值设置了之后传过去没有,于是自己通过Intent最后又单独传了一次


    // 联系人名字
    ContentValues row1 = new ContentValues();String name = lastName + middleName + firstName;row1.put(ContactsContract.Data.MIMETYPE,
    ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE);row1.put(ContactsContract.CommonDataKinds.StructuredName.DISPLAY_NAME,
    name);row1.put(ContactsContract.CommonDataKinds.StructuredName.GIVEN_NAME,
    firstName);row1.put(ContactsContract.CommonDataKinds.StructuredName.FAMILY_NAME,
    lastName);row1.put(ContactsContract.CommonDataKinds.StructuredName.MIDDLE_NAME,
    middleName);
    复制代码

    联系人昵称

    // 联系人昵称
    ContentValues row2 = new ContentValues();
    row2.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Nickname.CONTENT_ITEM_TYPE);
    row2.put(ContactsContract.CommonDataKinds.Nickname.NAME, nickName);
    复制代码

    联系人头像

    这里需要将图片的byte数组传进去


    ContentValues row3 = new ContentValues();
    //添加头像
    row3.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Photo.CONTENT_ITEM_TYPE);
    Bitmap bitmap = BitmapFactory.decodeFile(photoFilePath);
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);
    row3.put(ContactsContract.CommonDataKinds.Photo.PHOTO, baos.toByteArray());
    复制代码

    联系人备注

    // 联系人备注
    ContentValues row4 = new ContentValues();
    row4.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Note.CONTENT_ITEM_TYPE);
    row4.put(ContactsContract.CommonDataKinds.Note.NOTE, remark);
    复制代码

    联系人号码

    号码有很多种类型,电话,手机,传真,公司,家庭,等


    ContentValues row5 = new ContentValues();
    // 联系人的电话号码
    addPhoneNumber(row5, values, mobilePhoneNumber,
    ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE);ContentValues row6 = new ContentValues();
    // 联系人的公司电话
    addPhoneNumber(row6, values, hostNumber,
    ContactsContract.CommonDataKinds.Phone.TYPE_COMPANY_MAIN);ContentValues row7 = new ContentValues();
    // 联系人的工作号码
    addPhoneNumber(row7, values, workPhoneNumber,
    ContactsContract.CommonDataKinds.Phone.TYPE_WORK_MOBILE);ContentValues row8 = new ContentValues();
    // 联系人的工作传真
    addPhoneNumber(row8, values, workFaxNumber,
    ContactsContract.CommonDataKinds.Phone.TYPE_FAX_WORK);ContentValues row9 = new ContentValues();
    // 联系人的住宅号码
    addPhoneNumber(row9, values, homePhoneNumber,
    ContactsContract.CommonDataKinds.Phone.TYPE_HOME);ContentValues row10 = new ContentValues();
    // 联系人的住宅传真
    addPhoneNumber(row10, values, homeFaxNumber,
    ContactsContract.CommonDataKinds.Phone.TYPE_FAX_HOME);

    //封装的添加方法
    private void addPhoneNumber(
    ContentValues row, ArrayList<ContentValues> values, String phoneNumber, int type) {
    row.put(ContactsContract.Data.MIMETYPE,
    ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
    row.put(ContactsContract.CommonDataKinds.Phone.NUMBER, phoneNumber);
    row.put(ContactsContract.CommonDataKinds.Phone.TYPE, type);
    values.add(row);
    }
    复制代码

    联系人公司和职位

    // 联系人公司和职位
    ContentValues row11 = new ContentValues();
    row11.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Organization.CONTENT_ITEM_TYPE);
    row11.put(ContactsContract.CommonDataKinds.Organization.COMPANY, organization);
    row11.put(ContactsContract.CommonDataKinds.Organization.TITLE, title);
    复制代码

    网站

    // 联系人网站
    ContentValues row12 = new ContentValues();
    row12.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Website.CONTENT_ITEM_TYPE);
    row12.put(ContactsContract.CommonDataKinds.Website.URL, url);
    复制代码

    联系人邮箱

    // 插入Email数据
    ContentValues row13 = new ContentValues();
    row13.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE);
    row13.put(ContactsContract.CommonDataKinds.Email.DATA, email);
    row13.put(ContactsContract.CommonDataKinds.Email.TYPE, ContactsContract.CommonDataKinds.Email.TYPE_WORK);
    复制代码

    联系人地址

    地址分为家庭,工作和其他。有个问题,这里分段传入之后添加完成无法显示,只能自己将国家省市街道拼接,传入到了地址字段,这样就可以显示出来,但是邮政编码是无法显示的


    //其他地址
    ContentValues row14 = new ContentValues();
    addAddress(row14, values, addressCountry, addressState, addressCity, addressStreet, addressPostalCode, ContactsContract.CommonDataKinds.StructuredPostal.TYPE_OTHER);
    //家庭地址
    ContentValues row15 = new ContentValues();
    addAddress(row15, values, homeAddressCountry, homeAddressState, homeAddressCity, homeAddressStreet, homeAddressPostalCode, ContactsContract.CommonDataKinds.StructuredPostal.TYPE_HOME);
    //工作地址
    ContentValues row16 = new ContentValues();
    addAddress(row16, values, workAddressCountry, workAddressState, workAddressCity, workAddressStreet, workAddressPostalCode, ContactsContract.CommonDataKinds.StructuredPostal.TYPE_WORK);

    //添加地址方法
    private void addAddress(ContentValues row, ArrayList<ContentValues> values, String country, String region, String city, String street, String addressPostalCode, int type) {
    row.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE);
    row.put(ContactsContract.CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS, country + region + city + street);
    row.put(ContactsContract.CommonDataKinds.StructuredPostal.COUNTRY, country);
    row.put(ContactsContract.CommonDataKinds.StructuredPostal.REGION, region);
    row.put(ContactsContract.CommonDataKinds.StructuredPostal.CITY, city);
    row.put(ContactsContract.CommonDataKinds.StructuredPostal.STREET, street);
    row.put(ContactsContract.CommonDataKinds.StructuredPostal.POSTCODE, addressPostalCode);
    row.put(ContactsContract.CommonDataKinds.StructuredPostal.TYPE, type);
    values.add(row);
    }
    复制代码

    添加方式


    添加方式分为三种,一种是静默添加,直接存入数据库中,另外两种是跳转,直接新增或者添加到现有联系人中


    1.静默添加

    以添加名字为例,直接插入到数据库中


    // 向RawContacts.CONTENT_URI空值插入,
    // 先获取Android系统返回的rawContactId
    // 后面要基于此id插入值
    Uri rawContactUri = mActivity.getContentResolver().insert(ContactsContract.RawContacts.CONTENT_URI, values);
    long rawContactId = ContentUris.parseId(rawContactUri);
    values.put(ContactsContract.Data.RAW_CONTACT_ID, rawContactId);
    // 内容类型
    values.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE);
    // 联系人名字
    values.put(ContactsContract.CommonDataKinds.StructuredName.GIVEN_NAME, firstName);
    values.put(ContactsContract.CommonDataKinds.StructuredName.FAMILY_NAME, lastName);
    values.put(ContactsContract.CommonDataKinds.StructuredName.MIDDLE_NAME, middleName);
    // 向联系人URI添加联系人名字
    mActivity.getContentResolver().insert(ContactsContract.Data.CONTENT_URI, values);
    复制代码

    2.跳转添加

    将上边的所有row添加到数组中,一起传递


    List<ContentValues> values = new ArrayList<>();
    //添加需要设置的数据
    ...
    Intent intent = new Intent(Intent.ACTION_INSERT, ContactsContract.Contacts.CONTENT_URI);
    intent.putExtra(ContactsContract.Intents.Insert.NAME, name);
    intent.putParcelableArrayListExtra(ContactsContract.Intents.Insert.DATA, values);
    mActivity.startActivity(intent);
    复制代码

    2.添加到现有联系人

    将上边的所有row添加到数组中,一起传递,跳转后需要选择联系人


    List<ContentValues> values = new ArrayList<>();
    //添加需要设置的数据
    ...
    Intent intent = new Intent(Intent.ACTION_INSERT_OR_EDIT);
    intent.setType(ContactsContract.Contacts.CONTENT_ITEM_TYPE);
    intent.putParcelableArrayListExtra(ContactsContract.Intents.Insert.DATA, values);
    startActivity(intent);
    复制代码

    权限

    权限不能忘了,不然会闪退报错的,分别是联系人的读写权限


        <uses-permission android:name="android.permission.READ_CONTACTS"/>
    <uses-permission android:name="android.permission.WRITE_CONTACTS"/>
    复制代码

    总结到此为止,还算比较详细,有补充欢迎评论。


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

    iOS运行unity导出工程权限问题

    最近公司新开发了一款游戏,分别导出了安卓工程和xcode工程,在运行的过程中,出现了权限问题提示:在这边提示我,有两个.sh文件是被禁止的,没有运行的权限。其实这个问题很好解决,1、首先找到你xcode所在工程的文件夹,找到这两个.sh文件2、打开你的命令行控...
    继续阅读 »

    最近公司新开发了一款游戏,分别导出了安卓工程和xcode工程,在运行的过程中,出现了权限问题提示:


    在这边提示我,有两个.sh文件是被禁止的,没有运行的权限。

    其实这个问题很好解决,

    1、首先找到你xcode所在工程的文件夹,找到这两个.sh文件


    2、打开你的命令行控制器,输入chmod 777 MapFileParser.sh(其实这个·sh文件,直接拖入到命令行就行了)


    3、运行完命令之后,再次编译工程即可

    收起阅读 »

    Jetpack之Navigation(2)

    Jetpack之Navigation(1)2.原理 初始化过程 NavHostFragment生命周期方法 1.create—NavHostFragment的创建 在NavHostFragment.create方法 初始化Bundle,并且将graphRes...
    继续阅读 »

    Jetpack之Navigation(1)


    2.原理


    初始化过程 NavHostFragment生命周期方法


    1.create—NavHostFragment的创建


    在NavHostFragment.create方法



    1. 初始化Bundle,并且将graphResId,startDestinationArgs存储在Bundle中。

    2. new NavHostFragment()返回NavHostFragment实例。


        //NavHostFragment.java
    @NonNull
    public static NavHostFragment create(@NavigationRes int graphResId,
    @Nullable Bundle startDestinationArgs)
    {
    Bundle b = null;
    if (graphResId != 0) {
    b = new Bundle();
    b.putInt(KEY_GRAPH_ID, graphResId);
    }
    if (startDestinationArgs != null) {
    if (b == null) {
    b = new Bundle();
    }
    b.putBundle(KEY_START_DESTINATION_ARGS, startDestinationArgs);
    }

    final NavHostFragment result = new NavHostFragment();
    if (b != null) {
    result.setArguments(b);
    }
    return result;
    }
    复制代码

    2.onInflate—XML文件的解析


    主要是解析布局文件的两个属性:defaultNavHost和navGraph,并且初始化全局变量。


    NavHostFragment.onInflate方法 当Fragment以XML的方式静态加载时,最先会调用onInflate的方法(调用时机:Fragment所关联的Activity在执行setContentView时)。


        //NavHostFragment.java
    @CallSuper
    @Override
    public void onInflate(@NonNull Context context, @NonNull AttributeSet attrs,
    @Nullable Bundle savedInstanceState)
    {
    super.onInflate(context, attrs, savedInstanceState);

    final TypedArray navHost = context.obtainStyledAttributes(attrs,
    androidx.navigation.R.styleable.NavHost);
    final int graphId = navHost.getResourceId(
    androidx.navigation.R.styleable.NavHost_navGraph, 0);
    if (graphId != 0) {
    mGraphId = graphId; //navigation的图布局
    }
    navHost.recycle();

    final TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.NavHostFragment);
    final boolean defaultHost = a.getBoolean(R.styleable.NavHostFragment_defaultNavHost, false);
    if (defaultHost) {
    mDefaultNavHost = true; //是否监听物理返回键
    }
    a.recycle();
    }
    复制代码

    3.onCreateNavController—创建Navigator


    在实现导航的时候,我们需要根据navigation配置文件生成NavGraph类,然后在根据每个不同的actionid,找到对应的NavDestination就可以实现页面导航跳转了。


    创建Navigator


    Navigator类的作用是:能够实例化对应的NavDestination,并且能够实现导航功能,拥有自己的回退栈。


        @CallSuper
    protected void onCreateNavController(@NonNull NavController navController) {
    navController.getNavigatorProvider().addNavigator(
    new DialogFragmentNavigator(requireContext(), getChildFragmentManager()));

    //创建Navigator并绑定到NavigatorProvider中。
    //mNavigatorProvider是NavController中的全局变量,内部通过HashMap键值对的形式保存Navigator类。
    navController.getNavigatorProvider().addNavigator(createFragmentNavigator());
    }
    复制代码


    1. 其中mNavigatorProvider是NavController中的全局变量,内部通过HashMap键值对的形式保存Navigator类

    2. createFragmentNavigator方法,构建了FragmentNavigator对象,其中抽象类Navigator还有个重要的实现类ActivityNavigator和NavGraphNavigator。这个两个类的对象在NavController的构造方法中被添加。


    //NavController.java
    public NavController(@NonNull Context context) {
    mContext = context;
    while (context instanceof ContextWrapper) {
    if (context instanceof Activity) {
    mActivity = (Activity) context;
    break;
    }
    context = ((ContextWrapper) context).getBaseContext();
    }
    mNavigatorProvider.addNavigator(new NavGraphNavigator(mNavigatorProvider));
    mNavigatorProvider.addNavigator(new ActivityNavigator(mContext));
    }
    复制代码

    4.onCreate—导航初始化


    无论是XML实现还是代码实现,都会执行Fragment的onCreate方法。NavController在这里被创建,并且NavHostFragment中有一个NavController对象。


       @CallSuper
    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
    final Context context = requireContext();

    //1.初始化NavController,NavController为导航的控制类,核心类
    mNavController = new NavHostController(context);
    mNavController.setLifecycleOwner(this);
    mNavController.setOnBackPressedDispatcher(requireActivity().getOnBackPressedDispatcher());

    mNavController.enableOnBackPressed(
    mIsPrimaryBeforeOnCreate != null && mIsPrimaryBeforeOnCreate);
    mIsPrimaryBeforeOnCreate = null;
    mNavController.setViewModelStore(getViewModelStore());
    onCreateNavController(mNavController);

    Bundle navState = null;
    //2.开始恢复状态
    if (savedInstanceState != null) {
    navState = savedInstanceState.getBundle(KEY_NAV_CONTROLLER_STATE);
    if (savedInstanceState.getBoolean(KEY_DEFAULT_NAV_HOST, false)) {
    mDefaultNavHost = true;
    getParentFragmentManager().beginTransaction()
    .setPrimaryNavigationFragment(this)
    .commit();
    }
    mGraphId = savedInstanceState.getInt(KEY_GRAPH_ID);
    }

    if (navState != null) {
    mNavController.restoreState(navState);
    }

    //3.设置导航图信息
    if (mGraphId != 0) {
    mNavController.setGraph(mGraphId);
    } else {
    final Bundle args = getArguments();
    final int graphId = args != null ? args.getInt(KEY_GRAPH_ID) : 0;
    final Bundle startDestinationArgs = args != null
    ? args.getBundle(KEY_START_DESTINATION_ARGS)
    : null;
    if (graphId != 0) {
    mNavController.setGraph(graphId, startDestinationArgs);
    }
    }
    super.onCreate(savedInstanceState);
    }
    复制代码

    5.onCreateView


    NavHostFragment的视图就只有一个FragmentContainerView 继承 FrameLayout


        //NavHostFragment.java
    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
    @Nullable Bundle savedInstanceState) {
    FragmentContainerView containerView = new FragmentContainerView(inflater.getContext());

    //这行主要用于以代码方式添加fragment
    containerView.setId(getContainerId());
    return containerView;
    }
    复制代码

    6.onViewCreated


        @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);
    if (!(view instanceof ViewGroup)) {
    throw new IllegalStateException("created host view " + view + " is not a ViewGroup");
    }
    //把mNavController记录在view的tag中
    Navigation.setViewNavController(view, mNavController);

    if (view.getParent() != null) {
    mViewParent = (View) view.getParent();
    if (mViewParent.getId() == getId()) {
    //把mNavController记录在view的tag中
    Navigation.setViewNavController(mViewParent, mNavController);
    }
    }
    }
    复制代码

    获取NavController


    1.获取NavController


    NavHostFragment.findNavController(fragment)
    复制代码

        //NavHostFragment.java
    @NonNull
    public static NavController findNavController(@NonNull Fragment fragment) {
    Fragment findFragment = fragment;
    while (findFragment != null) {
    if (findFragment instanceof NavHostFragment) {
    return ((NavHostFragment) findFragment).getNavController();
    }
    Fragment primaryNavFragment = findFragment.getParentFragmentManager()
    .getPrimaryNavigationFragment();
    if (primaryNavFragment instanceof NavHostFragment) {
    return ((NavHostFragment) primaryNavFragment).getNavController();
    }
    findFragment = findFragment.getParentFragment();
    }

    View view = fragment.getView();
    if (view != null) {
    return Navigation.findNavController(view);
    }

    Dialog dialog = fragment instanceof DialogFragment
    ? ((DialogFragment) fragment).getDialog()
    : null;
    if (dialog != null && dialog.getWindow() != null) {
    return Navigation.findNavController(dialog.getWindow().getDecorView());
    }

    throw new IllegalStateException("Fragment " + fragment
    + " does not have a NavController set");
    }
    复制代码

    2.Navigation中findNavController


    3.findViewNavController


    通过view.tag查找NavController。内部调用了getViewNavController方法。


    4.getViewNavController


    getViewNavController方法 通过获取view的Tag,获取NavController对象,这里的tag ID和setViewNavController都是nav_controller_view_tag。


        //Navigation.java
    @NonNull
    public static NavController findNavController(@NonNull View view) {
    //3.
    NavController navController = findViewNavController(view);
    if (navController == null) {
    throw new IllegalStateException("View " + view + " does not have a NavController set");
    }
    return navController;
    }


    @Nullable
    private static NavController findViewNavController(@NonNull View view) {
    while (view != null) {
    NavController controller = getViewNavController(view);
    if (controller != null) {
    return controller;
    }
    ViewParent parent = view.getParent();
    view = parent instanceof View ? (View) parent : null;
    }
    return null;
    }

    @Nullable
    private static NavController getViewNavController(@NonNull View view) {
    //4.这里的tag ID和setViewNavController都是nav_controller_view_tag。
    Object tag = view.getTag(R.id.nav_controller_view_tag);
    NavController controller = null;
    if (tag instanceof WeakReference) {
    controller = ((WeakReference) tag).get();
    } else if (tag instanceof NavController) {
    controller = (NavController) tag;
    }
    return controller;
    }
    复制代码

    导航navigate


    navigate


    在构建和获取到NavController对象以及NavGraph之后。下面是使用它来实现真正的导航了。下面从navigate开始分析。在navigate方法内部会查询到NavDestination,然后根据不同的Navigator实现页面导航。


    public void navigate(@IdRes int resId, @Nullable Bundle args, @Nullable NavOptions navOptions,
    @Nullable Navigator.Extras navigatorExtras) {
    NavDestination currentNode = mBackStack.isEmpty()
    ? mGraph
    : mBackStack.getLast().getDestination();
    if (currentNode == null) {
    throw new IllegalStateException("no current navigation node");
    }
    @IdRes int destId = resId;
    //2.根据id,获取对应的NavAction
    final NavAction navAction = currentNode.getAction(resId);
    Bundle combinedArgs = null;
    if (navAction != null) {
    if (navOptions == null) {
    navOptions = navAction.getNavOptions();
    }
    //3.通过NavAction获取目的地id
    destId = navAction.getDestinationId();
    Bundle navActionArgs = navAction.getDefaultArguments();
    if (navActionArgs != null) {
    combinedArgs = new Bundle();
    combinedArgs.putAll(navActionArgs);
    }
    }

    if (args != null) {
    if (combinedArgs == null) {
    combinedArgs = new Bundle();
    }
    combinedArgs.putAll(args);
    }

    if (destId == 0 && navOptions != null && navOptions.getPopUpTo() != -1) {
    popBackStack(navOptions.getPopUpTo(), navOptions.isPopUpToInclusive());
    return;
    }

    if (destId == 0) {
    throw new IllegalArgumentException("Destination id == 0 can only be used"
    + " in conjunction with a valid navOptions.popUpTo");
    }
    //4.利用目的地ID属性,通过findDestination方法,找到准备导航的目的地
    NavDestination node = findDestination(destId);
    if (node == null) {
    final String dest = NavDestination.getDisplayName(mContext, destId);
    if (navAction != null) {
    throw new IllegalArgumentException("Navigation destination " + dest
    + " referenced from action "
    + NavDestination.getDisplayName(mContext, resId)
    + " cannot be found from the current destination " + currentNode);
    } else {
    throw new IllegalArgumentException("Navigation action/destination " + dest
    + " cannot be found from the current destination " + currentNode);
    }
    }
    //5.开始导航
    navigate(node, combinedArgs, navOptions, navigatorExtras);
    }


    private void navigate(@NonNull NavDestination node, @Nullable Bundle args,
    @Nullable NavOptions navOptions, @Nullable Navigator.Extras navigatorExtras) {
    boolean popped = false;
    boolean launchSingleTop = false;
    if (navOptions != null) {
    if (navOptions.getPopUpTo() != -1) {
    popped = popBackStackInternal(navOptions.getPopUpTo(),
    navOptions.isPopUpToInclusive());
    }
    }
    Navigator navigator = mNavigatorProvider.getNavigator(
    node.getNavigatorName());
    Bundle finalArgs = node.addInDefaultArgs(args);
    NavDestination newDest = navigator.navigate(node, finalArgs,
    navOptions, navigatorExtras);
    ...
    }
    复制代码

    findDestination


    如果回退栈为null返回NavGraph,不为null返回回退栈中的最后一项。


      NavDestination findDestination(@IdRes int destinationId) {
    if (mGraph == null) {
    return null;
    }
    if (mGraph.getId() == destinationId) {
    return mGraph;
    }
    //1.如果回退栈为null返回NavGraph,不为null返回回退栈中的最后一项。
    NavDestination currentNode = mBackStack.isEmpty()
    ? mGraph
    : mBackStack.getLast().getDestination();
    NavGraph currentGraph = currentNode instanceof NavGraph
    ? (NavGraph) currentNode
    : currentNode.getParent();
    return currentGraph.findNode(destinationId);
    }
    复制代码

    FragmentNavigator的实现


    通过以上的分析,又来到了Navigator 的子类FragmentNavigator类。下面来看看FragmentNavigator.navigate的方法。
    (1)调用instantiateFragment,通过反射机制构建Fragment实例

    (2)处理进出场等动画逻辑

    (3)最终调用FragmentManager来处理导航逻辑。


    @Nullable
    @Override
    public NavDestination navigate(@NonNull Destination destination, @Nullable Bundle args,
    @Nullable NavOptions navOptions, @Nullable Navigator.Extras navigatorExtras) {
    if (mFragmentManager.isStateSaved()) {
    Log.i(TAG, "Ignoring navigate() call: FragmentManager has already"
    + " saved its state");
    return null;
    }
    String className = destination.getClassName();
    if (className.charAt(0) == '.') {
    className = mContext.getPackageName() + className;
    }
    //通过反射机制构建Fragment实例
    final Fragment frag = instantiateFragment(mContext, mFragmentManager,
    className, args);
    frag.setArguments(args);
    final FragmentTransaction ft = mFragmentManager.beginTransaction();

    //处理动画逻辑
    int enterAnim = navOptions != null ? navOptions.getEnterAnim() : -1;
    int exitAnim = navOptions != null ? navOptions.getExitAnim() : -1;
    int popEnterAnim = navOptions != null ? navOptions.getPopEnterAnim() : -1;
    int popExitAnim = navOptions != null ? navOptions.getPopExitAnim() : -1;
    if (enterAnim != -1 || exitAnim != -1 || popEnterAnim != -1 || popExitAnim != -1) {
    enterAnim = enterAnim != -1 ? enterAnim : 0;
    exitAnim = exitAnim != -1 ? exitAnim : 0;
    popEnterAnim = popEnterAnim != -1 ? popEnterAnim : 0;
    popExitAnim = popExitAnim != -1 ? popExitAnim : 0;
    ft.setCustomAnimations(enterAnim, exitAnim, popEnterAnim, popExitAnim);
    }

    //FragmentManager来处理导航逻辑
    ft.replace(mContainerId, frag);
    ft.setPrimaryNavigationFragment(frag);

    final @IdRes int destId = destination.getId();
    final boolean initialNavigation = mBackStack.isEmpty();
    final boolean isSingleTopReplacement = navOptions != null && !initialNavigation
    && navOptions.shouldLaunchSingleTop()
    && mBackStack.peekLast() == destId;

    boolean isAdded;
    if (initialNavigation) {
    isAdded = true;
    } else if (isSingleTopReplacement) {
    if (mBackStack.size() > 1) {
    mFragmentManager.popBackStack(
    generateBackStackName(mBackStack.size(), mBackStack.peekLast()),
    FragmentManager.POP_BACK_STACK_INCLUSIVE);
    ft.addToBackStack(generateBackStackName(mBackStack.size(), destId));
    }
    isAdded = false;
    } else {
    ft.addToBackStack(generateBackStackName(mBackStack.size() + 1, destId));
    isAdded = true;
    }
    if (navigatorExtras instanceof Extras) {
    Extras extras = (Extras) navigatorExtras;
    for (Map.Entry sharedElement : extras.getSharedElements().entrySet()) {
    ft.addSharedElement(sharedElement.getKey(), sharedElement.getValue());
    }
    }
    ft.setReorderingAllowed(true);
    ft.commit();
    if (isAdded) {
    mBackStack.add(destId);
    return destination;
    } else {
    return null;
    }
    }
    复制代码

    ActivityNavigator


    ActivityNavigator最终也是调用了startActivity方法,请自己阅读源码。


        @Nullable
    @Override
    public NavDestination navigate(@NonNull Destination destination, @Nullable Bundle args,
    @Nullable NavOptions navOptions, @Nullable Navigator.Extras navigatorExtras) {
    ....
    if (navigatorExtras instanceof Extras) {
    Extras extras = (Extras) navigatorExtras;
    ActivityOptionsCompat activityOptions = extras.getActivityOptions();
    if (activityOptions != null) {
    ActivityCompat.startActivity(mContext, intent, activityOptions.toBundle());
    } else {
    mContext.startActivity(intent);
    }
    } else {
    mContext.startActivity(intent);
    }
    ...
    }
    复制代码

    3.总结



    1. NavHostFragment 作为导航载体,在Activity的layout文件里被引用(或者在代码中动态),并且持有导航控制类NavController引用。

    2. NavController 将导航任务委托给Navigator类,Navigator类有两个重要的子类FragmentNavigator和ActivityNavigator子类。NavController类持有NavInflater类引用。

    3. NavInflater 负责解析Navgation文件,负责构建NavGraph导航图。

    4. NavDestination 存有各个目的地信息,在FragmentNavigator和ActivityNavigator内部分别对应一个Destination类,该类继承NavDestination。

    5. 在页面导航时,fragment的操作还是交由FragmentManager在操作,activity交由startActivity执行。


    image-20210421174444170


    作者:贾里
    链接:https://juejin.cn/post/6953624951194664968
    来源:掘金
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

    收起阅读 »

    Jetpack之Navigation(1)

    1.基本使用引入库 def nav_version = "2.3.2" // Java language implementation implementation "androidx.navigation:navigation-fragment:$nav_...
    继续阅读 »

    1.基本使用

    引入库



    def nav_version = "2.3.2"
    // Java language implementation
    implementation "androidx.navigation:navigation-fragment:$nav_version"
    implementation "androidx.navigation:navigation-ui:$nav_version"
    复制代码

    Activity布局


    <?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:orientation="vertical"
    tools:context=".MainActivity">

    <!--
    app:defaultNavHost="true"
    拦截系统back键
    -->

    <androidx.fragment.app.FragmentContainerView
    android:id="@+id/my_nav_host_fragment"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_weight="9"
    android:name="androidx.navigation.fragment.NavHostFragment"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintLeft_toLeftOf="parent"
    app:layout_constraintRight_toRightOf="parent"
    app:layout_constraintTop_toTopOf="parent"
    app:defaultNavHost="true"
    app:navGraph="@navigation/nav_graph_main"/>


    </LinearLayout>
    复制代码

    在res/navigation目录下nav_graph_main.xml


    <?xml version="1.0" encoding="utf-8"?>
    <navigation 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:id="@+id/nav_graph_main.xml"
    app:startDestination="@id/page1Fragment">

    <fragment
    android:id="@+id/page1Fragment"
    android:name="com.example.lsn4_navigationdemo.MainPage1Fragment"
    android:label="fragment_page1"
    tools:layout="@layout/fragment_main_page1">


    <!--action:程序中使用id跳到destination对应的类-->
    <action
    android:id="@+id/action_page2"
    app:destination="@id/page2Fragment" />

    </fragment>

    <fragment
    android:id="@+id/page2Fragment"
    android:name="com.example.lsn4_navigationdemo.MainPage2Fragment"
    android:label="fragment_page2"
    tools:layout="@layout/fragment_main_page2">

    <action
    android:id="@+id/action_page1"
    app:destination="@id/page1Fragment" />

    <action
    android:id="@+id/action_page3"
    app:destination="@id/page3Fragment" />

    </fragment>

    <!-- <navigation-->
    <!-- android:id="@+id/nav_graph_page3"-->
    <!-- app:startDestination="@id/page3Fragment">-->
    <fragment
    android:id="@+id/page3Fragment"
    android:name="com.example.lsn4_navigationdemo.MainPage3Fragment"
    android:label="fragment_page3"
    tools:layout="@layout/fragment_main_page3"
    >

    <action
    android:id="@+id/action_page2"
    app:destination="@id/page2Fragment"/>

    </fragment>


    </navigation>
    复制代码

    Fragment中调用跳转


    //方式一:直接跳入指定的fragment
    Navigation.findNavController(view).navigate(R.id.page2Fragment);

    //方式二:通过action
    Navigation.findNavController(view).navigate(R.id.action_page2); //跳入page2
    复制代码

    Activity中调用跳转


    //获取controller方式一
    NavController controller=Navigation.findNavController(this,R.id.my_nav_host_fragment);

    //获取controller方式二
    NavHostFragment navHostFragment = (NavHostFragment) getSupportFragmentManager().findFragmentById(R.id.my_nav_host_fragment);
    NavController controller = navHostFragment.getNavController();

    //跳转
    controller.navigate(R.id.page2Fragment);
    复制代码

    Activity绑定navigation


    除了在Activity的布局中指定navigation布局资源以外,还可以通过java代码进行设置


    public class MainActivity extends AppCompatActivity {


    @Override
    protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //方式一
    val finalHost = NavHostFragment.create(R.navigation.nav_graph_main)
    supportFragmentManager.beginTransaction()
    .replace(R.id.ll_fragment_navigation, finalHost)
    .setPrimaryNavigationFragment(finalHost)
    .commit();
    }

    //方式二
    @Override
    public boolean onSupportNavigateUp() {
    Fragment fragment = getSupportFragmentManager().findFragmentById(R.id.my_nav_host_fragment);
    return NavHostFragment.findNavController(fragment).navigateUp();
    }
    }
    复制代码

    底部导航


    引入底部导航控件


    implementation 'com.google.android.material:material:1.1.0'
    复制代码

    布局


    <?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:orientation="vertical"
    tools:context=".MainActivity">
    <!--
    app:defaultNavHost="true"
    拦截系统back键
    -->
    <androidx.fragment.app.FragmentContainerView
    android:id="@+id/my_nav_host_fragment"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_weight="9"
    android:name="androidx.navigation.fragment.NavHostFragment"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintLeft_toLeftOf="parent"
    app:layout_constraintRight_toRightOf="parent"
    app:layout_constraintTop_toTopOf="parent"
    app:defaultNavHost="true"
    app:navGraph="@navigation/nav_graph_main"/>

    <com.google.android.material.bottomnavigation.BottomNavigationView
    android:id="@+id/nav_view"
    android:layout_width="match_parent"
    android:layout_weight="1"
    android:layout_height="wrap_content"
    app:itemTextColor="#ff0000"
    app:menu="@menu/menu"/>

    </LinearLayout>
    复制代码

    menu


    <?xml version="1.0" encoding="utf-8"?>
    <menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item
    android:id="@+id/page1Fragment"
    android:icon="@drawable/ic_launcher_foreground"
    android:title="1"/>
    <item
    android:id="@+id/page2Fragment"
    android:icon="@drawable/ic_launcher_foreground"
    android:title="2"/>
    <item
    android:id="@+id/page3Fragment"
    android:icon="@drawable/ic_launcher_foreground"
    android:title="3"/>

    </menu>
    复制代码

    Activity绑定导航


    public class MainActivity extends AppCompatActivity {

    BottomNavigationView bottomNavigationView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    findViewById(R.id.action_page1);
    bottomNavigationView=findViewById(R.id.nav_view);

    //获取controller方式一
    //NavController controller=Navigation.findNavController(this,R.id.my_nav_host_fragment);

    //获取controller方式二
    NavHostFragment navHostFragment = (NavHostFragment) getSupportFragmentManager().findFragmentById(R.id.my_nav_host_fragment);
    NavController controller = navHostFragment.getNavController();

    //绑定导航
    NavigationUI.setupWithNavController(bottomNavigationView,controller);

    }

    作者:贾里
    链接:https://juejin.cn/post/6953624951194664968
    来源:掘金
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

    收起阅读 »

    drawable用Kotlin应该这样写

    前言 通常我们在res/drawable下面自定义shape和selector来满足一些UI的设计,但是由于xml最终转换为drawable需要经过IO或反射创建,会有一些性能损耗,另外随着项目的增大和模块化等,很多通用的样式并不能快速复用,需要合理的项目资源...
    继续阅读 »

    前言


    通常我们在res/drawable下面自定义shapeselector来满足一些UI的设计,但是由于xml最终转换为drawable需要经过IO或反射创建,会有一些性能损耗,另外随着项目的增大和模块化等,很多通用的样式并不能快速复用,需要合理的项目资源管理规范才能实施。那么通过代码直接创建这些drawable,可以在一定程度上降低这些副作用。本篇介绍用kotlin DSL简洁的语法特性来实现常见的drawable.


    代码对应效果预览


    shape_line
    RECTANGLE
    OVAL
    LayerList
    Selector

    集成和使用



    1. 在项目级的build.gradle文件种添加仓库Jitpack:


    allprojects {
    repositories {
    ...
    maven { url 'https://jitpack.io' }
    }
    }
    复制代码


    1. 添加依赖


    dependencies {		
    implementation 'com.github.forJrking:DrawableDsl:0.0.1’
    }
    复制代码


    1. 抛弃xml创建方式示例(其他参见demo)


    // infix用法用于去掉括号更加简洁,详细后面说明
    image src = shapeDrawable {
    //指定shape样式
    shape(ShapeBuilder.Shape.RECTANGLE)
    //圆角,支持4个角单独设置
    corner(20f)
    //solid 颜色
    solid("#ABE2E3")
    //stroke 颜色,边框dp,虚线设置
    stroke(android.R.color.white, 2f, 5f, 8f)
    }
    //按钮点击样式
    btn.background = selectorDrawable {
    //默认样式
    normal = shapeDrawable {
    corner(20f)
    gradient(90, R.color.F97794, R.color.C623AA2)
    }
    //点击效果
    pressed = shapeDrawable {
    corner(20f)
    solid("#84232323")
    }
    }
    复制代码

    实现思路


    xml如何转换成drawable


    xml变成drawable,通过android.graphics.drawable.DrawableInflater这个类来IO解析标签创建:


    //标签创建
    private Drawable inflateFromTag(@NonNull String name) {
    switch (name) {
    case "selector":
    return new StateListDrawable();
    case "level-list":
    return new LevelListDrawable();
    case "layer-list":
    return new LayerDrawable();
    ....
    case "color":
    return new ColorDrawable();
    case "shape":
    return new GradientDrawable();
    case "vector":
    return new VectorDrawable();
    ...
    }
    }
    //反射创建
    private Drawable inflateFromClass(@NonNull String className) {
    try {
    Constructor<? extends Drawable> constructor;
    synchronized (CONSTRUCTOR_MAP) {
    constructor = CONSTRUCTOR_MAP.get(className);
    if (constructor == null) {
    final Class<? extends Drawable> clazz = mClassLoader.loadClass(className).asSubclass(Drawable.class);
    constructor = clazz.getConstructor();
    CONSTRUCTOR_MAP.put(className, constructor);
    }
    }
    return constructor.newInstance();
    } catch (NoSuchMethodException e) {
    ...
    }
    复制代码

    代码实现


    由于创建shape等需要设置各种属性来构建,比较符合build设计模式,那我们首先封装build模式的shapeBuilder,这样做虽然代码比起直接使用apply{}多但是可以让纯java项目用起来很舒服,其他实现请查看源码:


    class ShapeBuilder : DrawableBuilder {
    private var mRadius = 0f
    private var mWidth = 0f
    private var mHeight = 0f
    ...
    private var mShape = GradientDrawable.RECTANGLE
    private var mSolidColor = 0

    /**分别设置四个角的圆角*/
    fun corner(leftTop: Float,rightTop: Float,leftBottom: Float,rightBottom: Float): ShapeBuilder {
    ....
    return this
    }

    fun solid(@ColorRes colorId: Int): ShapeBuilder {
    mSolidColor = ContextCompat.getColor(context, colorId)
    return this
    }
    // 省略其他参数设置方法 详细代码查看源码
    override fun build(): Drawable {
    val gradientDrawable = GradientDrawable()
    gradientDrawable = GradientDrawable()
    gradientDrawable.setColor(mSolidColor)
    gradientDrawable.shape = mShape
    ....其他参数设置
    return gradientDrawable
    }
    }
    复制代码

    把build模式转换为dsl


    理论上所有的build模式都可以轻松转换为dsl写法:


    inline fun shapeDrawable(builder: ShapeBuilder.() -> Unit): Drawable {
    return ShapeBuilder().also(builder).build()
    }
    //使用方法
    val drawable = shapeDrawable{
    ...
    }
    复制代码

    备注:dsl用法参见juejin.cn/post/695318… 中dsl小节


    infix函数来去括号


    通过上面封装已经实现了dsl的写法,通常setBackground可以通过setter简化,但是我发现由于有些api设计还需要加括号,这样不太kotlin:


    //容易阅读
    iv1.background = shapeDrawable {
    shape(ShapeBuilder.Shape.RECTANGLE)
    solid("#ABE2E3")
    }
    //多了括号看起来不舒服
    iv2.setImageDrawable(shapeDrawable {
    solid("#84232323")
    })
    复制代码

    怎么去掉括号呢?这里就要用到infix函数特点和规范:



    • Kotlin允许在不使用括号和点号的情况下调用函数

    • 必须只有一个参数

    • 必须是成员函数或扩展函数

    • 不支持可变参数和带默认值参数


    /**为所有ImageView添加扩展infix函数 来去掉括号*/
    infix fun ImageView.src(drawable: Drawable?) {
    this.setImageDrawable(drawable)
    }
    //使用如下 舒服了
    iv2 src shapeDrawable {
    shape(ShapeBuilder.Shape.OVAL)
    solid("#E3ABC2")
    }
    复制代码

    当然了代码是用来阅读的。个人认为如果我们大量使用infix函数,阅读困难会大大增加,所以建议函数命名必须可以直击函数功能,而且函数功能简单且单一。


    优缺点


    优点:



    • 代码直接创建比起xml方式可以提升性能

    • dsl方式比起build模式和调用方法设置更加简洁符合kotlin风格

    • 通过合适的代码管理可以复用这些代码,比xml管理方便


    缺点:



    • 没有as的预览功能,只有通过上机观测

    • api还没有覆盖所有drawable属性


    后语


    上面把的DrawableDsl基础用法介绍完了,欢迎大家使用,欢迎提Issues,记得给个star哦。Github链接:https://github.com/forJrking/DrawableDsl


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

    Android各版本的行为变更

    本文的主要内容来自官方,摘出了Android开发者应该关注的重点变更,目前已经更新到Android 11,新版本发布时会持续更新,如果对您有帮助请不吝点赞! 一、Android 5.0——21——Lollipop(棒棒糖) ART 限制获取AppTask ...
    继续阅读 »

    本文的主要内容来自官方,摘出了Android开发者应该关注的重点变更,目前已经更新到Android 11,新版本发布时会持续更新,如果对您有帮助请不吝点赞!



    一、Android 5.0——21——Lollipop(棒棒糖)



    1. ART


    2. 限制获取AppTask


    3. WebView默认阻止第三方内容:setMixedContentMode()


    4. Material Design


    5. 提出JobScheduler



    6. 屏幕采集和屏幕共享


      Android 5.0 引入了新的 android.media.projection API,让您可以为应用添加屏幕采集和屏幕共享功能。例如,如果您想在视频会议应用中启用屏幕共享,便可使用此功能。

      新增的 createVirtualDisplay() 方法允许您的应用将主屏幕(默认显示)的内容采集到一个 Surface 对象中,然后您的应用便可将其发送至整个网络。该 API 只允许采集非安全屏幕内容,不允许采集系统音频。要开始采集屏幕,您的应用必须先使用通过 createScreenCaptureIntent() 方法获得的 Intent 启动屏幕采集对话框,请求用户授予权限。



    二、Android 6.0——23——Marshmallow(棉花糖)



    1. 省电机制Doze引入

    2. 运行时权限

    3. 移除了对设备本地硬件标识符的编程访问权

    4. 指纹API


    三、Android 7.0——24——Nougat(牛轧糖)



    1. FileProvider

    2. 低耗电模式进一步优化

    3. 多窗口支持

    4. 添加JIT,属于对AOT的一种补充机制


    四、Android 8.0——26——Oreo(奥利奥)



    1. 当您的应用进入已缓存状态时,如果没有活动的组件,系统将解除应用具有的所有唤醒锁。


    2. 应用无法使用其清单注册大部分隐式广播


    3. 应用尝试在不允许其创建后台服务的情况下使用 startService() 函数,则该函数将引发一个 IllegalStateException


    4. 后台应用时,降低了后台应用接收位置更新的频率


    5. 画中画模式


    6. 应用快捷菜单


    7. 音频自动闪避,失去焦点时自动调小音量



    8. 多显示器支持(移动Activity到另一个窗口会onConfigChange)


      在多窗口模式下,在任意时间点都只有用户最近一次互动的 Activity 处于活动状态。此 Activity 被视为最顶层的 Activity,而且是唯一处于 RESUMED 状态的 Activity。所有其他可见的 Activity 均处于 STARTED 而非 RESUMED 状态。不过,这些可见但并不处于 RESUMED 状态的 Activity 在系统中享有比不可见 Activity 更高的优先级。如果用户与其中一个可见的 Activity 互动,那么该 Activity 将进入 RESUMED 状态,而之前的最顶层 Activity 将进入 STARTED 状态。



    五、Android 9.0——28——Pie



    1. 后台应用无法访问用户输入和一些传感器数据,如麦克风相机,加速器陀螺仪等,除非使用前台服务

    2. 通话记录权限从Phone组移动到CALL_LOG组,plus,一个组的权限有了一个,其他的的权限也就有了(申请会自动授权)

    3. 不允许使用非SDKAPI,也就是hide的一些SDK方法不许用反射和JNI调用

    4. 支持检测显示屏缺口,非功能区域DisplayCutout,比如检测挖孔屏

    5. 利用 Wi-Fi RTT 进行室内定位

    6. ImageDecoder类可取代BitmapFactory


    六、Android 10——29——Q



    1. 屏幕边缘手势导航(各大厂商早就实现了)



    2. 为了让用户更好地管理自己的文件并减少混乱,以 Android 10(API 级别 29)及更高版本为目标平台的应用在默认情况下被赋予了对外部存储空间的分区访问权限(即分区存储)。此类应用只能访问外部存储空间上的应用专属目录,以及本应用所创建的特定类型的媒体文件。

      注意:如果您的应用在运行时请求与存储空间相关的权限,面向用户的对话框会表明您的应用正在请求对外部存储空间的广泛访问,即使已启用分区存储也是如此。


  • 后台应用不能启动一个新的Activity


  • 新增后台访问位置信息权限,无则不可以(ACCESS_BACKGROUND_LOCATION)


  • 应用必须具有 READ_PRIVILEGED_PHONE_STATE 特许权限才能访问设备的不可重置标识符(包含 IMEI 和序列号),普通应用基本是不可以的


  • 除非您的应用是默认输入法 (IME) 或是目前处于焦点的应用,否则它无法访问 Android 10 或更高版本平台上的剪贴板数据。



  • 七、Android 11——30——R



    1. 单次授权(权限只给这一次)


    2. 自动重置权限——几个月用户未与应用交互,将回收应用权限



    3. 支持瀑布屏API


      现有的 DisplayCutout.getSafeInset…() 方法现在会返回能够避开瀑布区域以及刘海的安全边衬区



    4. 新增前台服务类型属性,必须指明为camera和microphone才能访问麦克风,在后台运行时启动的前台服务无法访问麦克风和相机,除非具备后台访问权限


      <manifest>
      ...
      <service ... android:foregroundServiceType="location|camera" />
      </manifest>



    5. 软件包可见性——不是所有应用都对软件可见了


      1.影响queryIntentActivities()的返回结果
      2.影响启动其他应用的Service
      3.不影响启动Activity
      4.别的应用和你发生交互,那它对你是可见的
      5.系统的一些支持程序是可见的
      6.ContentProvider是可见的,如果你具备权限的话
      7.用<queries>生命想要可见的一些应用





    1. 应用退出原因


      Android 11 引入了 ActivityManager.getHistoricalProcessExitReasons() 方法,用于报告近期任何进程终止的原因。应用可以使用此方法收集崩溃诊断信息,例如进程终止是由于 ANR、内存问题还是其他原因所致。此外,您还可以使用新的 setProcessStateSummary() 方法存储自定义状态信息,以便日后进行分析。



    2. 资源加载器ResourcesLoader——可用做换肤和插件化


      Android 11 引入了一个新 API,允许应用动态扩展资源的搜索和加载方式。新的 API 类 ResourcesLoader 和 ResourcesProvider 主要负责提供新功能。两者协同作用,可以提供额外的资源,或修改现有资源的值。

      ResourcesLoader 对象是向应用的 Resources 实例提供 ResourcesProvider 对象的容器,而 ResourcesProvider 对象提供从 APK 和资源表加载资源数据的方法。

      此 API 的一个主要用例是自定义资源加载。您可以使用 loadFromDirectory() 创建一个 ResourcesProvider,用于重定向基于文件的资源的解析,从而让其搜索特定目录,而不是应用 APK。您可以通过 AssetManager API 类中的 open() 系列方法访问这些资源,就像访问 APK 中绑定的资源一样。


    作者:Mr云台
    链接:https://www.jianshu.com/p/e9fbbd52065b
    来源:简书
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。  

    收起阅读 »

    iOS内存管理

    将计算机上有限的物理内存分配给多个程序使用地址空间不隔离内存使用率低程序运行的地址不确定虚拟内存虚拟地址空间是指虚拟的、人们想象出来的地址空间,其实它并不存在,每个进程都有自己独立的虚拟空间,每个进程只能访问自己的地址空间,这样就能有效的做到了进程的隔离。注:...
    继续阅读 »

    将计算机上有限的物理内存分配给多个程序使用

    • 地址空间不隔离

    • 内存使用率低

    • 程序运行的地址不确定

    虚拟内存
    虚拟地址空间是指虚拟的、人们想象出来的地址空间,其实它并不存在,每个进程都有自己独立的虚拟空间,每个进程只能访问自己的地址空间,这样就能有效的做到了进程的隔离。
    注: 虚拟储存的实现需要依赖硬件的支持,对于不同的CPU来说不同,但是几乎所有的硬件都采用MMU(Memory Management Unit)的部件来进行页映射。


    分段
    把一段与程序所需要的内存空间大小的虚拟空间映射到某个地址空间。


    • 因为程序A和程序B被映射到了两块不同的物理空间区域,它们之间没有任何重叠,如果A程序访问虚拟空间的地址超出了0x00A00000这个范围,那么硬件就会判断这是一个非法访问,拒绝这个请求,所以做到了地址隔离。

    • 对于每个程序来说,无论它们被分配到物理地址的那一个区域,都是透明的,它们不关心物理地址的变化,只要按照从地址0x0000000到0x00A00000来编写程序,放置变量,所以程序不再需要重定位

    分页
    当一个程序运行时,在某个时间段内,它只是频繁的用到了一小部分数据,程序的很多数据其实在一个时间段内都不会被用到。人们很自然的想到了更小粒度的内存分割和映射的方法,使得程序的局部性原理得到充分的利用,大大提高了内存的使用率。


    • 进程1(VP0,VP5)和进程2(VP0,VP3,VP4,VP5)的虚拟地址映射到物理地址(PP0,PP2,PP2,PP3,PP4),可以看到有些虚拟空间被映射到同一个物理页,这样就实现了内存共享。

    • 还有一部分位于磁盘中,如果进程需要用到这两个页时,操作系统就会接管进程,负责将虚拟地址从磁盘中读出来并装入内存,然后再与物理地址建立映射关系。

    • 保护也是页映射的目的之一,每个页可以设置权限属性,而只有操作系统有权限修改这些属性,那么操作系统就可以保护自己和保护进程了。

    PAE
    原先的32位地址只能访问最多4GB的物理内存,但是自从扩展至36位地址线以后,Intel修改了页映射方式,使得新的映射方式可以访问到更多的物理内存,Intel把这个地址扩展方式叫做PAE(Physical Address Extension)、

    AWE
    应用程序可以根据需求来选择申请和映射,比如一个应用程序0x10000000 ~0x20000000这一段256MB的虚拟地址空间用来做窗口,程序可以从高4GB的物理空间申请多个大小为256MB的物理空间,编号成A、B、C的等,然后根据需要将这个窗口映射到不同物理空间块,用到A时映射到A,用到B、C时再映射过去,叫做AWE(Address Windowing Extension),而Linux等UNIX类操作系统则采用mmap()系统调用来实现

    • 程序执行做需要的指令和数据必须在内存中才能够正常运行,最简单的办法就是将进程运行所需要的指令和数据全部装入内存中,这就是简单的静态装入。

    • 由于内存的昂贵稀有,所需的内存大余物理内存,所以我们将程序最常用的部分驻留在内存中,不太常用的数据存放在磁盘里,这就是动态装入。覆盖装入和页映射就是两种很典型的动态装载方法。

    覆盖装入(Overlay)


    • 这个树状结构从任何一个模块到树的根(main)模块都叫调用路径,当该模块被调用时,整个调用路径上的模块都必须在内存中,已确保执行完毕后能正确返回至模块。

    • 禁止跨树间调用。任意一个模块不允许跨过树状结构进行调用。

    • 由于跨模块间的调用需要经过覆盖管理器,已确保所有被调用到的模块都能够正确的驻留在内存,而且一旦模块没有在内存中,还需要从磁盘或者其他存储器读取响应的模块,所以覆盖装入的速度肯定比较慢,是典型的利用时间换取空间的方法

    页映射(Paging)


    • 将内存和所有磁盘中的数据和指令按照page为单位划分为若干个页,以后所有的装载和操作的单位都是页,硬件规定页的大小为4096字节,8192KB等,那么512MB的物理内存就拥有512 * 1024 * 1024 /4096 = 131072 页。

    • 假设32的机器有16KB的内存,每个页4096字节,则共有4个页(F0、F1、F2、F3),假设程序需有的指令和数据总和为32KB,那么程序被分为8个页(P0~P7)。很明显16KB的内存无法同时将32KB的程序装入,那么我们将按照动态装入的原理来进行整个装入过程。

    • 如果只有4个页,那么程序能一直执行下去,但问题很明显不是,如果超过4个页,装载管理器必须作出抉择,放弃目前正在使用的4个内存中的其中一个。至于放弃那个页有多种算法:比如F0,先进先出;比如很少访问的F2,最少使用法

    页错误(Page Fault)
    一些存储在磁盘中的数据,在CPU执行这个地址指令时,发现页面是一个空的页面,于是他就认为这是一个页错误,CPU将控制权交给操作系统,操作系统有专门处理例程来处理,操作系统将查询这个数据结构,然后找到空页面所在的VMA,计算相应的页面在可执行文件中的偏移,然后再物理内存中分配一个物理页面,将进程中该虚拟页与分配的物理页之间建立映射,然后再交给进程去执行。

    进程虚拟空间分布
    ELF文件被映射时,是以页长度为单位的,每个段在映射时的长度应该是系统页长度的整倍数,如果不是,多余的部分页将占领一个页,造成了内存空间的大量浪费。而在ELF文件中,段的权限直邮为数不多的几种组合:

    • 以代码段为代表的权限为可读可执行的段

    • 以数据段和BSS段为代表的权限为可读可写的段

    • 以只读数据段为代表的权限为只读的段

    那么对于相同的段,我们把他们合并在一起当成一个段来映射,ELF可执行文件引入一个概念叫做Segment,一个segment包含一个或多个section,这样很明显的减少了页面内部的碎片,节省了空间

    段地址对齐
    假设一个ELF执行文件,它有三个段需要装载,SEG0 、SEG1、SEG2,如图:


    可以看到这种对齐方式在文件段的内部会有很多内部碎片,浪费磁盘空间,可执行文件总长度只有12014字节,却占了5个页。为了解决这个问题,UNIX系统采用了让那些个个段接壤的部分共用一个物理页面,将该物理页面映射两次,系统将它们映射两份到虚拟地址空间,其他的都按照正常的页粒度进行映射。

    转自:https://www.jianshu.com/p/779154738361


    收起阅读 »

    iOS 中事件的响应链和传递链

    iOS事件链有两条:事件的响应链;Hit-Testing事件的传递链响应链:由离用户最近的view向系统传递。initial view –> super view –> ….. –> view controller –> window ...
    继续阅读 »

    iOS事件链有两条:事件的响应链;Hit-Testing事件的传递链

    • 响应链:由离用户最近的view向系统传递。initial view –> super view –> ….. –> view controller –> window –> Application –> AppDelegate

    • 传递链:由系统向离用户最近的view传递。UIKit –> active app's event queue –> window –> root view –> …… –> lowest view

    在iOS中只有继承UIResponder的对象才能够接收并处理事件,UIResponder是所有响应对象的基类,在UIResponder类中定义了处理上述各种事件的接口。我们熟悉的UIApplication、UIViewController、UIWindow和所有继承自UIView的UIKit类都直接或间接的继承自UIResponder,所以它们的实例都是可以构成响应者链的响应者对象,首先我们通过一张图来简单了解一下事件的传递以及响应


    1、传递链

    • 事件传递的两个核心方法

    - (nullable UIView *)hitTest:(CGPoint)point withEvent:(nullable UIEvent *)event;   // recursively calls -pointInside:withEvent:. point is in the receiver's coordinate system
    - (BOOL)pointInside:(CGPoint)point withEvent:(nullable UIEvent *)event; // default returns YES if point is in bounds
    • 第一个方法返回的是一个UIView,是用来寻找最终哪一个视图来响应这个事件

    • 第二个方法是用来判断某一个点击的位置是否在视图范围内,如果在就返回YES

    • 其中UIView不接受事件处理的情况有

    1. alpha <0.01
    2. userInteractionEnabled = NO
    3. hidden = YES
    • 事件传递的流程图


    • 流程描述

         1、我们点击屏幕产生触摸事件,系统将这个事件加入到一个由UIApplication管理的事件队列中,UIApplication会从消息队列里取事件分发下去,首先传给UIWindow

         2、在UIWindow中就会调用hitTest:withEvent:方法去返回一个最终响应的视图

         3、在hitTest:withEvent:方法中就会去调用pointInside: withEvent:去判断当前点击的point是否在UIWindow范围内,如果是的话,就会去遍历它的子视图来查找最终响应的子视图

         4、遍历的方式是使用倒序的方式来遍历子视图,也就是说最后添加的子视图会最先遍历,在每一个视图中都回去调用它的hitTest:withEvent:方法,可以理解为是一个递归调用

         5、最终会返回一个响应视图,如果返回视图有值,那么这个视图就作为最终响应视图,结束整个事件传递;如果没有值,那么就会将UIWindow作为响应者

    2、相应链

    • 响应者链流程图


    • 响应者链的事件传递过程总结如下

         1、如果view的控制器存在,就传递给控制器处理;如果控制器不存在,则传递给它的父视图

         2、在视图层次结构的最顶层,如果也不能处理收到的事件,则将事件传递给UIWindow对象进行处理

         3、如果UIWindow对象也不处理,则将事件传递给UIApplication对象

         4、如果UIApplication也不能处理该事件,则将该事件丢弃

    3、实例场景

    • 在一个方形按钮中点击中间的圆形区域有效,而点击四角无效

    • 核心思想是在pointInside: withEvent:方法中修改对应的区域

    - (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event {
    // 如果控件不允许与用用户交互,那么返回nil
    if (!self.userInteractionEnabled || [self isHidden] || self.alpha <= 0.01) {
    return nil;
    }

    //判断当前视图是否在点击范围内
    if ([self pointInside:point withEvent:event]) {
    //遍历当前对象的子视图(倒序)
    __block UIView *hit = nil;
    [self.subviews enumerateObjectsWithOptions:NSEnumerationReverse usingBlock:^(__kindof UIView * _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
    //坐标转换,把当前坐标系上的点转换成子控件坐标系上的点
    CGPoint convertPoint = [self convertPoint:point toView:obj];
    //调用子视图的hitTest方法,判断自己的子控件是不是最适合的View
    hit = [obj hitTest:convertPoint withEvent:event];
    //如果找到了就停止遍历
    if (hit) *stop = YES;
    }];

    //返回当前的视图对象
    return hit?hit:self;
    }else {
    return nil;
    }
    }

    // 该方法判断触摸点是否在控件身上,是则返回YES,否则返回NO,point参数必须是方法调用者的坐标系
    - (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event {
    CGFloat x1 = point.x;
    CGFloat y1 = point.y;

    CGFloat x2 = self.frame.size.width / 2;
    CGFloat y2 = self.frame.size.height / 2;

    //判断是否在圆形区域内
    double dis = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
    if (dis <= self.frame.size.width / 2) {
    return YES;
    }
    else{
    return NO;
    }
    }

    转自:jianshu.com/p/cfcde82c67f6


    收起阅读 »

    iOS 中 如何从视频中提取音频

    .h文件/**提取视频中的音频@param videoPath 视频路径@param completionHandle 完成回调*/+(void)accessAudioFromVideo:(NSURL *)videoPath completion:(void ...
    继续阅读 »

    .h文件
    /**

    提取视频中的音频

    @param videoPath 视频路径
    @param completionHandle 完成回调
    */

    +(void)accessAudioFromVideo:(NSURL *)videoPath completion:(void (^)(NSURL *outputPath,BOOL isSucceed)) completionHandle;

    .m文件
    需要导入系统的#import <Photos/Photos.h>
    /**

    提取视频中的音频

    @param videoPath 视频路径
    @param completionHandle 完成回调
    */

    +(void)accessAudioFromVideo:(NSURL *)videoPath completion:(void (^)(NSURL *outputPath,BOOL isSucceed)) completionHandle{

    AVAsset *videoAsset = [AVAsset assetWithURL:videoPath];
    //1创建一个AVMutableComposition
    AVMutableComposition *mixComposition = [[AVMutableComposition alloc]init];
    //2 创建一个轨道,类型为AVMediaTypeAudio
    AVMutableCompositionTrack *audioTrack = [mixComposition addMutableTrackWithMediaType:AVMediaTypeAudio preferredTrackID:kCMPersistentTrackID_Invalid];

    //获取videoPath的音频插入轨道
    [audioTrack insertTimeRange:CMTimeRangeMake(kCMTimeZero, videoAsset.duration) ofTrack:[[videoAsset tracksWithMediaType:AVMediaTypeAudio] objectAtIndex:0] atTime:kCMTimeZero error:nil];

    //4创建输出路径
    NSURL *outputURL = [self exporterPath:@"mp4"];

    //5创建输出对象
    AVAssetExportSession *exporter = [[AVAssetExportSession alloc]initWithAsset:mixComposition presetName:AVAssetExportPresetAppleM4A];
    exporter.outputURL = outputURL ;
    exporter.outputFileType = AVFileTypeAppleM4A;
    exporter.shouldOptimizeForNetworkUse = YES;
    [exporter exportAsynchronouslyWithCompletionHandler:^{
    if (exporter.status == AVAssetExportSessionStatusCompleted) {
    NSURL *outputURL = exporter.outputURL;
    completionHandle(outputURL,YES);
    }else {
    NSLog(@"失败%@",exporter.error.description);
    completionHandle(outputURL,NO);
    }
    }];

    }
    // 输出路径
    + (NSURL *)exporterPath:(NSString *)filename{
    NSDateFormatter *formatter = [[NSDateFormatter alloc]init];
    formatter.dateFormat = @"yyyyMMddHHmmss";
    NSString *str = [formatter stringFromDate:[NSDate date]];
    NSString *fileName = [NSString stringWithFormat:@"selfMusic%@.%@",str,filename];
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *docPath = [paths firstObject];
    //这个是录制视频时存储到本地的video
    NSString *path = [NSString stringWithFormat:@"%@/KSYShortVideoCache",docPath];
    //判断文件夹是否存在,不存在就创建
    //创建附件存储目录
    if (![[NSFileManager defaultManager] fileExistsAtPath:path]) {
    [[NSFileManager defaultManager] createDirectoryAtPath:path withIntermediateDirectories:YES attributes:nil error:nil];
    }
    NSString *outputFilePath = [path stringByAppendingPathComponent:fileName];
    return [NSURL fileURLWithPath:outputFilePath];
    }

    转自:https://www.jianshu.com/p/ffa126bb2736

    收起阅读 »

    静态拦截iOS对象方法调用的简易实现

    最近出现了几篇关于二进制重排启动优化的文章。所有方案中都需要事先统计所有的函数调用情况,并根据函数调用的频次来进行代码的重排。这些函数调用中,OC对象的方法调用最多。统计OC对象的方法调用可以在运行时通过第三方库比如fishhook来Hook所有objc_ms...
    继续阅读 »

    最近出现了几篇关于二进制重排启动优化的文章。所有方案中都需要事先统计所有的函数调用情况,并根据函数调用的频次来进行代码的重排。
    这些函数调用中,OC对象的方法调用最多。统计OC对象的方法调用可以在运行时通过第三方库比如fishhook来Hook所有objc_msgSend调用来实现,也可以在编译后链接前通过静态插桩的方式来实现Hook拦截。
    对于静态插桩的实现一般有如下两个方案:
    1、助于LLVM语法树分析来实现代码插桩。
    2、将源码编译为静态库,并通过修改静态库中.o目标文件的代码段来实现代码插桩。
    上述的两个方法实现起来比较复杂,要么就要了解LLVM,要么就要熟悉目标文件中间字节码以及符号表相关的底层知识。
    本文所介绍的是第三种静态Hook方案,也是依赖于静态库这个前提来实现对objc_msgSend函数进行Hook,从而实现在编译前链接后的OC对象方法调用插桩。
    这个方案实现的原理很简单。因为静态库其实只是一个编译阶段的中间产物,静态库目标文件中的所有引用的外部符号会保存到一张字符串表中,所有函数调用都只是记录了函数名称在字符串表的索引位置,在链接时会才会根据符号名称来替换为真实的函数调用指令。因此我们可以将所有静态库字符串表中的objc_msgSend统一替换为另外一个长度相同的字符串:hook_msgSend(名字任意只要长度一致并唯一)即可。然后在主工程源代码中实现一个名字为hook_msgSend的函数即可。这个函数必须要和objc_msgSend的函数签名保持一致,这样在链接时所有静态库中的objc_msgSend调用都会统一转化为hook_msgSend调用。

    下面的是具体的实现步骤:

    1.在主工程中编写hook_msgSend的实现。
    hook_msgSend的函数签名要和objc_msgSend保持一致,并且要在主工程代码中实现,而且必须要用汇编代码实现。具体实现的逻辑和目前很多文章中介绍的对objc_msgSend函数的Hook实现保持一致即可。
    很多对objc_msgSend进行Hook的实现其实是不完整的,因此如果想完全掌握函数调用ABI规则的话请参考:《深入iOS系统底层之函数调用》

    2. 将所有其他代码都统一编译为一个或多个静态库。
    将源代码按功能编译为一个或多个静态库,并且主工程链接这些静态库。这种程序代码的组织方式已经很成熟了,最常用的方法是我们可以借助代码依赖集成工具cocoapods来实现,这里就不再赘述了。

    3.在主工程的Build Phases 中添加Run Script脚本。
    我们需要保证这个脚本一定要运行在链接所有静态库之前执行。因此可以放到Compile Sources 下面。

    4.实现静态库符号替换的Run Script脚本。
    这是最为关键的一步,我们可以实现一个符号替换的程序,然后在Run Script脚本中 执行这个符号替换程序。符号替换程序的输入参数就是主工程中所链接的所有静态库的路径。至于这个符号替换程序如何编写则没有限制,你可以用ruby编写也可以用python也可以用C语言编写。 无论用何种方法实现,你都需要首先了解一下静态库.a的文件结构。你可以从:《深入iOS系统底层之静态库》一文中掌握到一个静态库文件的组成结构。了解了静态库文件的组成结构后,你的符号替换程序要做的事情就可以按如下步骤实现:

    一)、 打开静态库.a文件。
    二)、找.a文件中定义的字符串表部分。字符串表的描述如下:

    struct stringtab
    {
    int size; //字符串表的尺寸
    char strings[0]; //字符串表的内容,每个字符串以\0分隔。
    };

    字符串表中的strings的内容就是一个个以\0分隔的字符串,这些字符串的内容其实就是这个目标文件所引用的所有外部和内部的符号名称。
    三)、将字符串表中的objc_msgSend字符串替换为hook_msgSend字符串。
    四)、保存并关闭静态库.a文件。

    5.编译、链接并运行你的主工程程序。
    采用本文中所介绍的静态Hook方法的好处是我们不必Hook所有的OC方法调用,而是可以有选择的进行特定对象和类的方法调用拦截。因此这种技术不仅可以应用代码重排统计上,还可以应用在其他的监控和统计应用中。因为这种机制可以避免程序在运行时进行objc_msgSend替换而产生的函数调用风暴问题。另外的一个点就是这个方法不局限于对objc_msgSend进行Hook,还可以对任意的其他函数进行Hook处理。因此这种技术也可以应用在其他方面。

    转自:https://www.jianshu.com/p/843642c9df32

    收起阅读 »

    webpack手写loader

    手写loader   我们在在Webpack配置基础篇介绍过,loader是链式传递的,对文件资源从上一个loader传递到下一个,而loader的处理也遵循着从下到上的顺序,我们简单了解一下loader的开发原则: 单一原则: 每个Loader只做一件事,...
    继续阅读 »

    手写loader


      我们在在Webpack配置基础篇介绍过,loader是链式传递的,对文件资源从上一个loader传递到下一个,而loader的处理也遵循着从下到上的顺序,我们简单了解一下loader的开发原则:



    1. 单一原则: 每个Loader只做一件事,简单易用,便于维护;

    2. 链式调用: Webpack 会按顺序链式调用每个Loader;

    3. 统一原则: 遵循Webpack制定的设计规则和结构,输入与输出均为字符串,各个Loader完全独立,即插即用;

    4. 无状态原则:在转换不同模块时,不应该在loader中保留状态;


      因此我们就来尝试写一个less-loaderstyle-loader,将less文件处理后通过style标签的方式渲染到页面上去。


    同步loader


      loader默认导出一个函数,接受匹配到的文件资源字符串和SourceMap,我们可以修改文件内容字符串后再返回给下一个loader进行处理,因此最简单的一个loader如下:


    module.exports = function(source, map){
    return source
    }


    导出的loader函数不能使用箭头函数,很多loader内部的属性和方法都需要通过this进行调用,比如this.cacheable()来进行缓存、this.sourceMap判断是否需要生成sourceMap等。



      我们在项目中创建一个loader文件夹,用来存放我们自己写的loader,然后新建我们自己的style-loader:


    //loader/style-loader.js
    function loader(source, map) {
    let style = `
    let style = document.createElement('style');
    style.innerHTML = ${JSON.stringify(source)};
    document.head.appendChild(style)
    `
    ;
    return style;
    }
    module.exports = loader;

      这里的source就可以看做是处理后的css文件字符串,我们把它通过style标签的形式插入到head中;同时我们也发现最后返回的是一个JS代码的字符串,webpack最后会将返回的字符串打包进模块中。


    异步loader


      上面的style-loader都是同步操作,我们在处理source时,有时候会进行异步操作,一种方法是通过async/await,阻塞操作执行;另一种方法可以通过loader本身提供的回调函数callback


    //loader/less-loader
    const less = require("less");
    function loader(source) {
    const callback = this.async();
    less.render(source, function (err, res) {
    let { css } = res;
    callback(null, css);
    });
    }
    module.exports = loader;

      callback的详细传参方法如下:


    callback({
    //当无法转换原内容时,给 Webpack 返回一个 Error
    error: Error | Null,
    //转换后的内容
    content: String | Buffer,
    //转换后的内容得出原内容的Source Map(可选)
    sourceMap?: SourceMap,
    //原内容生成 AST语法树(可选)
    abstractSyntaxTree?: AST
    })

      有些时候,除了将原内容转换返回之外,还需要返回原内容对应的Source Map,比如我们转换less和scss代码,以及babel-loader转换ES6代码,为了方便调试,需要将Source Map也一起随着内容返回。


    //loader/less-loader
    const less = require("less");
    function loader(source) {
    const callback = this.async();
    less.render(source,{sourceMap: {}}, function (err, res) {
    let { css, map } = res;
    callback(null, css, map);
    });
    }
    module.exports = loader;

      这样我们在下一个loader就能接收到less-loader返回的sourceMap了,但是需要注意的是:



    Source Map生成很耗时,通常在开发环境下才会生成Source Map,其它环境下不用生成。Webpack为loader提供了this.sourceMap这个属性来告诉loader当前构建环境用户是否需要生成Source Map。



    加载本地loader


      loader文件准备好了之后,我们需要将它们加载到webpack配置中去;在基础篇中,我们加载第三方的loader只需要安装后在loader属性中写loader名称即可,现在加载本地loader需要把loader的路径配置上。


    module.exports = {
    module: {
    rules: [{
    test: /\.less/,
    use: [
    {
    loader: './loader/style-loader.js',
    },
    {
    loader: path.resolve(__dirname, "loader", "less-loader"),
    },
    ],
    }]
    }
    }

      我们可以在loader中配置本地loader的相对路径或者绝对路径,但是这样写起来比较繁琐,我们可以利用webpack提供的resolveLoader属性,来告诉webpack应该去哪里解析本地loader。


    module.exports = {
    module: {
    rules: [{
    test: /\.less/,
    use: [
    {
    loader: 'style-loader',
    },
    {
    loader: 'less-loader',
    },
    ],
    }]
    },
    resolveLoader:{
    modules: [path.resolve(__dirname, 'loader'), 'node_modules']
    }
    }

      这样webpack会先去loader文件夹下找loader,没有找到才去node_modules;因此我们写的loader尽量不要和第三方loader重名,否则会导致第三方loader被覆盖加载。


    处理参数


      我们在配置loader时,经常会给loader传递参数进行配置,一般是通过options属性来传递的,也有像url-loader通过字符串来传参:


    {
    test: /\.(jpg|png|gif|bmp|jpeg)$/,
    use: 'url-loader?limt=1024&name=[hash:8].[ext]'
    }

      webpack也提供了query属性来获取传参;但是query属性很不稳定,如果像上面的通过字符串来传参,query就返回字符串格式,通过options方式就会返回对象格式,这样不利于我们处理。因此我们借助一个官方的包loader-utils帮助处理,它还提供了很多有用的工具。


    const { 
    getOptions,
    parseQuery,
    stringifyRequest,
    } = require("loader-utils");

    module.exports = function (source, map) {
    //获取options参数
    const options = getOptions(this);
    //解析字符串为对象
    parseQuery("?param1=foo")
    //将绝对路由转换成相对路径
    //以便能在require或者import中使用以避免绝对路径
    stringifyRequest(this, "test/lib/index.js")
    }

      常用的就是getOptions将处理后的参数返回出来,它内部的实现逻辑也非常的简单,也是根据query属性进行处理,如果是字符串的话调用parseQuery方法进行解析,源码如下:


    //loader-utils/lib/getOptions.js
    'use strict';
    const parseQuery = require('./parseQuery');
    function getOptions(loaderContext) {
    const query = loaderContext.query;
    if (typeof query === 'string' && query !== '') {
    return parseQuery(loaderContext.query);
    }
    if (!query || typeof query !== 'object') {
    return {};
    }
    return query;
    }
    module.exports = getOptions;

      获取到参数后,我们还需要对获取到的options参数进行完整性校验,避免有些参数漏传,如果一个个判断校验比较繁琐,这就用到另一个官方包schema-utils


    const { getOptions } = require("loader-utils");
    const { validate } = require("schema-utils");
    const schema = require("./schema.json");
    module.exports = function (source, map) {
    const options = getOptions(this);
    const configuration = { name: "Loader Name"};
    validate(schema, options, configuration);
    //省略其他代码
    }

      validate函数并没有返回值,打印返回值发现是`undefined,因为如果参数不通过的话直接会抛出ValidationError异常,直接进程中断;这里引入了一个schema.json,就是我们对options``中参数进行校验的一个json格式的对应表:


    {
    "type": "object",
    "properties": {
    "source": {
    "type": "boolean"
    },
    "name": {
    "type": "string"
    },
    },
    "additionalProperties": false
    }

      properties中的健名就是我们需要检验的options中的字段名称,additionalProperties代表了是否允许options中还有其他额外的属性。


    less-loader源码分析


      写完我们自己简单的less-loader,让我们来看一下官方的less-loader源码到底是怎么样的,这里贴上部分源码:


    import less from 'less';
    import { getOptions } from 'loader-utils';
    import { validate } from 'schema-utils';
    import schema from './options.json';
    async function lessLoader(source) {
    const options = getOptions(this);
    //校验参数
    validate(schema, options, {
    name: 'Less Loader',
    baseDataPath: 'options',
    });
    const callback = this.async();
    //对options进一步处理,生成less渲染的参数
    const lessOptions = getLessOptions(this, options);
    //是否使用sourceMap,默认取options中的参数
    const useSourceMap =
    typeof options.sourceMap === 'boolean'
    ? options.sourceMap : this.sourceMap;
    //如果使用sourceMap,就在渲染参数加入
    if (useSourceMap) {
    lessOptions.sourceMap = {
    outputSourceFiles: true,
    };
    }
    let data = source;
    let result;
    try {
    result = await less.render(data, lessOptions);
    } catch (error) {
    }
    const { css, imports } = result;
    //有sourceMap就进行处理
    let map =
    typeof result.map === 'string'
    ? JSON.parse(result.map) : result.map;

    callback(null, css, map);
    }
    export default lessLoader;

      可以看到官方的less-loader和我们写的简单的loader本质上都是调用less.render函数,对文件资源字符串进行处理,然后将处理好后的字符串和sourceMap通过callback返回。


    loader依赖


      在loader中,我们有时候也会使用到外部的资源文件,我们需要在loader对这些资源文件进行声明;这些声明信息主要用于使得缓存loader失效,以及在观察模式(watch mode)下重新编译。


      我们尝试写一个banner-loader,在每个js文件资源后面加上我们自定义的注释内容;如果传了filename,就从文件中获取预设好的banner内容,首先我们预设两个banner的txt:


    //loader/banner1.txt
    /* build from banner1 */

    //loader/banner2.txt
    /* build from banner2 */

      然后在我们的banner-loader中根据参数来进行判断:


    //loader/banner-loader
    const fs = require("fs");
    const path = require("path");
    const { getOptions } = require("loader-utils");

    module.exports = function (source) {
    const options = getOptions(this);
    if (options.filename) {
    let txt = "";
    if (options.filename == "banner1") {
    this.addDependency(path.resolve(__dirname, "./banner1.txt"));
    txt = fs.readFileSync(path.resolve(__dirname, "./banner1.txt"));
    } else if (options.filename == "banner2") {
    this.addDependency(path.resolve(__dirname, "./banner1.txt"));
    txt = fs.readFileSync(path.resolve(__dirname, "./banner1.txt"));
    }
    return source + txt;
    } else if (options.text) {
    return source + `/* ${options.text} */`;
    } else {
    return source;
    }
    };

      这里使用了this.addDependency的API将当前处理的文件添加到文件依赖中(并不是项目的package.json)。如果在观察模式下,依赖的text文件发生了变化,那么打包生成的文件内容也随之变化。



    如果不添加this.addDependency的话项目并不会报错,只是在观察模式下,如果依赖的文件发生了变化生成的bundle文件并不能及时更新。



    缓存加速


      在有些情况下,loader处理需要大量的计算非常耗性能(比如babel-loader),如果每次构建都重新执行相同的转换操作每次构建都会非常慢。


      因此webpack默认会将loader的处理结果标记为可缓存,也就是说在需要被处理的文件或者其依赖的文件没有发生变化时,它的输出结果必然是相同的;如果不想让webpack缓存该loader,可以禁用缓存:


    module.exports = function(source) {
    // 强制不缓存
    this.cacheable(false);
    return source;
    };

    手写loader所有代码均在webpackdemo19



    收起阅读 »

    深入webpack打包原理

    本文讨论的核心内容如下: webpack进行打包的基本原理 如何自己实现一个loader和plugin 注: 本文使用的webpack版本是v4.43.0, webpack-cli版本是v3.3.11,node版本是v12.14.1,npm版本v6.13....
    继续阅读 »

    本文讨论的核心内容如下:



    1. webpack进行打包的基本原理

    2. 如何自己实现一个loaderplugin


    注: 本文使用的webpack版本是v4.43.0, webpack-cli版本是v3.3.11node版本是v12.14.1npm版本v6.13.4(如果你喜欢yarn也是可以的),演示用的chrome浏览器版本81.0.4044.129(正式版本) (64 位)


    1. webpack打包基本原理


    webpack的一个核心功能就是把我们写的模块化的代码,打包之后,生成可以在浏览器中运行的代码,我们这里也是从简单开始,一步步探索webpack的打包原理


    1.1 一个简单的需求


    我们首先建立一个空的项目,使用npm init -y快速初始化一个package.json,然后安装webpack webpack-cli


    接下来,在根目录下创建src目录,src目录下创建index.jsadd.jsminus.js,根目录下创建index.html,其中index.html引入index.js,在index.js引入add.jsminus.js


    目录结构如下:



    文件内容如下:

    // add.js
    export default (a, b) => {
    return a + b
    }
    // minus.js
    export const minus = (a, b) => {
    return a - b
    }
    // index.js
    import add from './add.js'
    import { minus } from './minus.js'

    const sum = add(1, 2)
    const division = minus(2, 1)
    console.log('sum>>>>>', sum)
    console.log('division>>>>>', division)
    <!--index.html-->

    <!DOCTYPE html>
    <html lang="en">
    <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>demo</title>
    </head>
    <body>
    <script src="./src/index.js"></script>
    </body>
    </html>

    <<span class="hljs-attribute">span</span> class=<span class="hljs-string">"hljs-attribute"</span>>demo</span>

    这样直接在index.html引入index.js的代码,在浏览器中显然是不能运行的,你会看到这样的错误


    Uncaught SyntaxError: Cannot use import statement outside a module

    是的,我们不能在script引入的js文件里,使用es6模块化语法


    1.2 实现webpack打包核心功能


    我们首先在项目根目录下再建立一个bundle.js,这个文件用来对我们刚刚写的模块化js代码文件进行打包


    我们首先来看webpack官网对于其打包流程的描述:


    it internally builds a dependency graph which maps every module your project needs and generates one or more bundles(webpack会在内部构建一个 依赖图(dependency graph),此依赖图会映射项目所需的每个模块,并生成一个或多个 bundle)


    在正式开始之前,结合上面webpack官网说明进行分析,明确我们进行打包工作的基本流程如下:



    1. 首先,我们需要读到入口文件里的内容(也就是index.js的内容)

    2. 其次,分析入口文件,递归的去读取模块所依赖的文件内容,生成依赖图

    3. 最后,根据依赖图,生成浏览器能够运行的最终代码


    1. 处理单个模块(以入口为例)


    1.1 获取模块内容


    既然要读取文件内容,我们需要用到node.js的核心模块fs,我们首先来看读到的内容是什么:

    // bundle.js
    const fs = require('fs')
    const getModuleInfo = file => {
    const body = fs.readFileSync(file, 'utf-8')
    console.log(body)
    }
    getModuleInfo('./src/index.js')


    1.2 分析模块内容


    我们安装@babel/parser,演示时安装的版本号为^7.9.6


    这个babel模块的作用,就是把我们js文件的代码内容,转换成js对象的形式,这种形式的js对象,称做抽象语法树(Abstract Syntax Tree, 以下简称AST)

    // bundle.js
    const fs = require('fs')
    const parser = require('@babel/parser')
    const getModuleInfo = file => {
    const body = fs.readFileSync(file, 'utf-8')
    const ast = parser.parse(body, {
    // 表示我们要解析的是es6模块
    sourceType: 'module'
    })
    console.log(ast)
    console.log(ast.program.body)
    }
    getModuleInfo('./src/index.js')



    入口文件内容被放到一个数组中,总共有六个Node节点,我们可以看到,每个节点有一个type属性,其中前两个的type属性是ImportDeclaration,这对应了我们入口文件的两条import语句,并且,每一个type属性是ImportDeclaration的节点,其source.value属性是引入这个模块的相对路径,这样我们就得到了入口文件中对打包有用的重要信息了。


    接下来要对得到的ast做处理,返回一份结构化的数据,方便后续使用。


    1.3 对模块内容做处理


    ast.program.body部分数据的获取和处理,本质上就是对这个数组的遍历,在循环中做数据处理,这里同样引入一个babel的模块@babel/traverse来完成这项工作。


    安装@babel/traverse,演示时安装的版本号为^7.9.6

    const fs = require('fs')
    const path = require('path')
    const parser = require('@babel/parser')
    const traverse = require('@babel/traverse').default

    const getModuleInfo = file => {
    const body = fs.readFileSync(file, 'utf-8')
    const ast = parser.parse(body, {
    sourceType: 'module'
    })
    const deps = {}
    traverse(ast, {
    ImportDeclaration({ node }) {
    const dirname = path.dirname(file);
    const absPath = './' + path.join(dirname, node.source.value)
    deps[node.source.value] = absPath
    }
    })
    console.log(deps)
    }
    getModuleInfo('./src/index.js')

    创建一个对象deps,用来收集模块自身引入的依赖,使用traverse遍历ast,我们只需要对ImportDeclaration的节点做处理,注意我们做的处理实际上就是把相对路径转化为绝对路径,这里我使用的是Mac系统,如果是windows系统,注意斜杠的区别


    获取依赖之后,我们需要对ast做语法转换,把es6的语法转化为es5的语法,使用babel核心模块@babel/core以及@babel/preset-env完成


    安装@babel/core @babel/preset-env,演示时安装的版本号均为^7.9.6

    const fs = require('fs')
    const path = require('path')
    const parser = require('@babel/parser')
    const traverse = require('@babel/traverse').default
    const babel = require('@babel/core')

    const getModuleInfo = file => {
    const body = fs.readFileSync(file, 'utf-8')
    const ast = parser.parse(body, {
    sourceType: 'module'
    })
    const deps = {}
    traverse(ast, {
    ImportDeclaration({ node }) {
    const dirname = path.dirname(file);
    const absPath = './' + path.join(dirname, node.source.value)
    deps[node.source.value] = absPath
    }
    })
    const { code } = babel.transformFromAst(ast, null, {
    presets: ["@babel/preset-env"]
    })
    const moduleInfo = { file, deps, code }
    console.log(moduleInfo)
    return moduleInfo
    }
    getModuleInfo('./src/index.js')


    2. 递归的获取所有模块的信息

    这个过程,也就是获取依赖图(dependency graph)的过程,这个过程就是从入口模块开始,对每个模块以及模块的依赖模块都调用getModuleInfo方法就行分析,最终返回一个包含所有模块信息的对象

    const parseModules = file => {
    // 定义依赖图
    const depsGraph = {}
    // 首先获取入口的信息
    const entry = getModuleInfo(file)
    const temp = [entry]
    for (let i = 0; i < temp.length; i++) {
    const item = temp[i]
    const deps = item.deps
    if (deps) {
    // 遍历模块的依赖,递归获取模块信息
    for (const key in deps) {
    if (deps.hasOwnProperty(key)) {
    temp.push(getModuleInfo(deps[key]))
    }
    }
    }
    }
    temp.forEach(moduleInfo => {
    depsGraph[moduleInfo.file] = {
    deps: moduleInfo.deps,
    code: moduleInfo.code
    }
    })
    console.log(depsGraph)
    return depsGraph
    }
    parseModules('./src/index.js')


    3. 生成最终代码


    在我们实现之前,观察上一节最终得到的依赖图,可以看到,最终的code里包含exports以及require这样的语法,所以,我们在生成最终代码时,要对exports和require做一定的实现和处理


    我们首先调用之前说的parseModules方法,获得整个应用的依赖图对象:


    const bundle = file => {
    const depsGraph = JSON.stringify(parseModules(file))
    }

    接下来我们应该把依赖图对象中的内容,转换成能够执行的代码,以字符串形式输出。
    我们把整个代码放在自执行函数中,参数是依赖图对象


    const bundle = file => {
    const depsGraph = JSON.stringify(parseModules(file))
    return `(function(graph){
    function require(file) {
    var exports = {};
    return exports
    }
    require('${file}')
    })(${depsGraph})`
    }

    接下来内容其实很简单,就是我们取得入口文件的code信息,去执行它就好了,使用eval函数执行,初步写出代码如下:


    const bundle = file => {
    const depsGraph = JSON.stringify(parseModules(file))
    return `(function(graph){
    function require(file) {
    var exports = {};
    (function(code){
    eval(code)
    })(graph[file].code)
    return exports
    }
    require('${file}')
    })(${depsGraph})`
    }

    上面的写法是有问题的,我们需要对file做绝对路径转化,否则graph[file].code是获取不到的,定义adsRequire方法做相对路径转化为绝对路径


    const bundle = file => {
    const depsGraph = JSON.stringify(parseModules(file))
    return `(function(graph){
    function require(file) {
    var exports = {};
    function absRequire(relPath){
    return require(graph[file].deps[relPath])
    }
    (function(require, exports, code){
    eval(code)
    })(absRequire, exports, graph[file].code)
    return exports
    }
    require('${file}')
    })(${depsGraph})`
    }

    接下来,我们只需要执行bundle方法,然后把生成的内容写入一个JavaScript文件即可


    const content = bundle('./src/index.js')
    // 写入到dist/bundle.js
    fs.mkdirSync('./dist')
    fs.writeFileSync('./dist/bundle.js', content)

    4. bundle.js的完整代码

    const fs = require('fs')
    const path = require('path')
    const parser = require('@babel/parser')
    const traverse = require('@babel/traverse').default
    const babel = require('@babel/core')

    const getModuleInfo = file => {
    const body = fs.readFileSync(file, 'utf-8')
    console.log(body)
    const ast = parser.parse(body, {
    sourceType: 'module'
    })
    // console.log(ast.program.body)
    const deps = {}
    traverse(ast, {
    ImportDeclaration({ node }) {
    const dirname = path.dirname(file);
    const absPath = './' + path.join(dirname, node.source.value)
    deps[node.source.value] = absPath
    }
    })
    const { code } = babel.transformFromAst(ast, null, {
    presets: ["@babel/preset-env"]
    })
    const moduleInfo = { file, deps, code }
    return moduleInfo
    }

    const parseModules = file => {
    // 定义依赖图
    const depsGraph = {}
    // 首先获取入口的信息
    const entry = getModuleInfo(file)
    const temp = [entry]
    for (let i = 0; i < temp.length; i++) {
    const item = temp[i]
    const deps = item.deps
    if (deps) {
    // 遍历模块的依赖,递归获取模块信息
    for (const key in deps) {
    if (deps.hasOwnProperty(key)) {
    temp.push(getModuleInfo(deps[key]))
    }
    }
    }
    }
    temp.forEach(moduleInfo => {
    depsGraph[moduleInfo.file] = {
    deps: moduleInfo.deps,
    code: moduleInfo.code
    }
    })
    // console.log(depsGraph)
    return depsGraph
    }


    // 生成最终可以在浏览器运行的代码
    const bundle = file => {
    const depsGraph = JSON.stringify(parseModules(file))
    return `(function(graph){
    function require(file) {
    var exports = {};
    function absRequire(relPath){
    return require(graph[file].deps[relPath])
    }
    (function(require, exports, code){
    eval(code)
    })(absRequire, exports, graph[file].code)
    return exports
    }
    require('${file}')
    })(${depsGraph})`
    }


    const build = file => {
    const content = bundle(file)
    // 写入到dist/bundle.js
    fs.mkdirSync('./dist')
    fs.writeFileSync('./dist/bundle.js', content)
    }

    build('./src/index.js')



    收起阅读 »

    iOS runtime之--动态修改字体大小

    那么既然runtime可以进行方法交换,我们只要自定义一个方法,替换系统的方法不就可以实现了吗?话不多说,我们开始动手UIFont设置font的类方法替换#import "UIFont+Category.h"#import "NSObject+Category...
    继续阅读 »

    介绍一下runtime的实际应用场景之一:怎样利用runtime的方法交换,在不修改原有代码的基础上动态的根据屏幕尺寸修改字体大小,包括xib和storyboard中拖的控件。

    我们知道,通常代码设置字体大小用的是UIFont的几个类方法 :

    systemFontOfSize

    fontWithName:size

    boldSystemFontOfSize

    italicSystemFontOfSize

    ...

    那么既然runtime可以进行方法交换,我们只要自定义一个方法,替换系统的方法不就可以实现了吗?话不多说,我们开始动手

    实现NSObject类方法交换

    创建NSObject分类,并增加一个可进行“Method交换”的方法。Method交换的本质,其实就是imp指针的交换。系统给我们提供了一个C语言的函数method_exchangeImplementations可以进行交换。流程如下:

    1.根据原方法和目标方法的selector,获取方法的method。如果是类方法用class_getClassMethod获取method,如是对象方法则用class_getInstanceMethod获取method

    2.获取到method后,调用method_exchangeImplementations函数进行两个method的imp指针的交换

    #import "NSObject+Category.h"
    #import

    @implementation NSObject (Category)

    /**
    @brief 方法替换
    @param originselector 替换的原方法
    @param swizzleSelector 替换后的方法
    @param isClassMethod 是否为类方法,YES为类方法,NO为对象方法
    */
    + (void)runtimeReplaceFunctionWithSelector:(SEL)originselector
    swizzleSelector:(SEL)swizzleSelector
    isClassMethod:(BOOL)isClassMethod
    {
    Method originMethod;
    Method swizzleMethod;
    if (isClassMethod == YES) {
    originMethod = class_getClassMethod([self class], originselector);
    swizzleMethod = class_getClassMethod([self class], swizzleSelector);
    }else{
    originMethod = class_getInstanceMethod([self class], originselector);
    swizzleMethod = class_getInstanceMethod([self class], swizzleSelector);
    }
    method_exchangeImplementations(originMethod, swizzleMethod);
    }
    @end

    UIFont设置font的类方法替换

    新建一个UIFont分类,在+(void)load方法中进行UIFont系统方法的替换
    #import "UIFont+Category.h"
    #import "NSObject+Category.h"

    @implementation UIFont (Category)

    //+(void)load方法会在main函数之前自动调用,不需要手动调用
    + (void)load
    {
    //交换systemFontOfSize: 方法
    [[self class] runtimeReplaceFunctionWithSelector:@selector(systemFontOfSize:) swizzleSelector:@selector(customSystemFontOfSize:) isClassMethod:YES];
    //交换fontWithName:size:方法
    [[self class] runtimeReplaceFunctionWithSelector:@selector(fontWithName:size:) swizzleSelector:@selector(customFontWithName:size:) isClassMethod:YES];
    }

    //自定义的交换方法
    + (UIFont *)customSystemFontOfSize:(CGFloat)fontSize
    {
    CGFloat size = [UIFont transSizeWithFontSize:fontSize];
    ///这里并不会引起递归,方法交换后,此时调用customSystemFontOfSize方法,其实是调用了原来的systemFontOfSize方法
    return [UIFont customSystemFontOfSize:size];
    }

    //自定义的交换方法
    + (UIFont *)customFontWithName:(NSString *)fontName size:(CGFloat)fontSize
    {
    CGFloat size = [UIFont transSizeWithFontSize:fontSize];
    return [UIFont customFontWithName:fontName size:size];
    }

    ///屏幕宽度大于320的,字体加10。(此处可根据不同的需求设置字体大小)
    + (CGFloat)transSizeWithFontSize:(CGFloat)fontSize
    {
    CGFloat size = fontSize;
    CGFloat width = [UIFont getWidth];
    if (width > 320) {
    size += 10;
    }
    return size;
    }

    ///获取竖屏状态下的屏幕宽度
    + (CGFloat)getWidth
    {
    for (UIScreen *windowsScenes in UIApplication.sharedApplication.connectedScenes) {
    UIWindowScene * scenes = (UIWindowScene *)windowsScenes;
    UIWindow *window = scenes.windows.firstObject;
    if (scenes.interfaceOrientation == UIInterfaceOrientationPortrait) {
    return window.frame.size.width;
    }
    return window.frame.size.height;
    }
    return 0;
    }

    @end

    至此就实现了,动态改变字体大小的目的,那xib和storyboard拖的控件怎么修改呢?我们接着看

    动态修改xib和storyboard控件的字体大小

    xib和sb拖拽的控件,都会调用 initWithCoder方法,那么我们可以自定义一个方法,替换掉initWithCoder,并在此方法中修改控件的字体不就可以了吗。我们先用UILabel举例,先创建一个UILabel的分类,然后在+(void)load方法中进行initWithCoder方法的交换

    #import "UILabel+Category.h"
    #import "NSObject+Category.h"

    @implementation UILabel (Category)

    + (void)load
    {
    [[self class] runtimeReplaceFunctionWithSelector:@selector(initWithCoder:) swizzleSelector:@selector(customInitWithCoder:) isClassMethod:NO];
    }

    - (instancetype)customInitWithCoder:(NSCoder *)coder
    {
    if ([self customInitWithCoder:coder]) {
    ///此时调用fontWithName:size:方法,实际上调用的是方法交换后的customFontWithName:size:
    self.font = [UIFont fontWithName:self.font.familyName size:self.font.pointSize];
    }
    return self;
    }

    @end

    此时我们就实现了,UILabel字体大小的动态修改,同理我们实现其它几个开发中常用的几个控件修改

    UIButton的分类

    #import "UIButton+Category.h"
    #import "NSObject+Category.h"

    @implementation UIButton (Category)

    + (void)load
    {
    [[self class] runtimeReplaceFunctionWithSelector:@selector(initWithCoder:) swizzleSelector:@selector(customInitWithCoder:) isClassMethod:NO];
    }

    - (instancetype)customInitWithCoder:(NSCoder *)coder
    {
    if ([self customInitWithCoder:coder]) {
    if (self.titleLabel != nil) {
    self.titleLabel.font = [UIFont fontWithName:self.titleLabel.font.familyName size:self.titleLabel.font.pointSize];
    }
    }
    return self;
    }

    @end

    UITextField的分类

    #import "UITextField+Category.h"
    #import "NSObject+Category.h"

    @implementation UITextField (Category)

    + (void)load
    {
    [[self class] runtimeReplaceFunctionWithSelector:@selector(initWithCoder:) swizzleSelector:@selector(customInitWithCoder:) isClassMethod:NO];
    }

    - (instancetype)customInitWithCoder:(NSCoder *)coder
    {
    if ([self customInitWithCoder:coder]) {
    self.font = [UIFont fontWithName:self.font.familyName size:self.font.pointSize];
    }
    return self;
    }

    @end

    UITextView的分类

    #import "UITextView+Category.h"
    #import "NSObject+Category.h"

    @implementation UITextView (Category)

    + (void)load
    {
    [[self class] runtimeReplaceFunctionWithSelector:@selector(initWithCoder:) swizzleSelector:@selector(customInitWithCoder:) isClassMethod:NO];
    }

    - (instancetype)customInitWithCoder:(NSCoder *)coder
    {
    if ([self customInitWithCoder:coder]) {
    self.font = [UIFont fontWithName:self.font.familyName size:self.font.pointSize];
    }
    return self;
    }

    @end

    到此,我们就完成了控件字体大小的动态修改,我们在storyboard中拖几个控件,然后用代码创建几个控件,分别看一下修改前和修改后的效果

                                                                           设置前


                                                                                        设置后

    注:Swift语言做法类似,但是Swift不允许重写+(void)load方法。所以如果是Swift,文中的+ (void)load需要改为自己定义的方法,并在AppDelegate的
    didFinishLaunchingWithOptions方法中进行调用。


    原贴链接:https://www.jianshu.com/p/c1f206433809
    收起阅读 »