注册
环信即时通讯云

环信即时通讯云

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

环信开发文档

Demo体验

Demo体验

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

RTE开发者社区

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

技术讨论区

技术交流、答疑
资源下载

资源下载

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

iOS Library

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

Android Library

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

7个你应该知道的Gradle实用技巧

前言 Gradle在android开发中应用地十分广泛,但相信有很多同学并不很了解gradle 本文主要介绍了使用gradle的一些实用技巧,帮助读者增进对这个熟悉的陌生人的了解 主要包括以下内容 1.Gradle依赖树查询 2.使用循环优化Gradle依赖...
继续阅读 »

前言


Gradleandroid开发中应用地十分广泛,但相信有很多同学并不很了解gradle

本文主要介绍了使用gradle的一些实用技巧,帮助读者增进对这个熟悉的陌生人的了解

主要包括以下内容



  • 1.Gradle依赖树查询

  • 2.使用循环优化Gradle依赖管理

  • 3.支持代码提示的Gradle依赖管理

  • 4.Gradle模块化

  • 5.Library模块Gradle代码复用

  • 6.资源文件分包

  • 7.AAR依赖与源码依赖快速切换


1.Gradle依赖树查询


有时我们在分析依赖冲突时,需要查看依赖树,我们常用的查看依赖树的命令为


gradlew app:dependencies
复制代码

不过这种命令行方式查看依赖树出来的信息太多,看的有些费劲

所以官方又推出了Scan工具来帮助我们更加方便地查看依赖树

在项目根目录位置下运行gradle build --scan即可,然后会生成 HTML 格式的分析文件的分析文件


分析文件会直接上传到Scan官网,命令行最后会给出远程地址

第一次跑会让你在 Scan 官网注册一下,邮件确认后就能看了

scan 工具是按照依赖变体挨个分类的,debugCompileClassPath 就是 dedug 打包中的依赖包了


如上,使用这种方式分析依赖树更加方便简洁


2.使用循环优化Gradle依赖管理


如下所示,我们常常使用ext来管理依赖


    dependencies {
implementation fileTree(include: ['*.jar'], dir: 'libs')
implementation rootProject.ext.dependencies["appcompat-v7"]
implementation rootProject.ext.dependencies["cardview-v7"]
implementation rootProject.ext.dependencies["design"]
implementation rootProject.ext.dependencies["constraint-layout"]
annotationProcessor rootProject.ext.dependencies["glide_compiler"]
...
}
复制代码

这样虽然实现了依赖的统一管理,但是随着项目越来越大,依赖也会越来越多,常常会有几十甚至上百行,导致build.gradle越来越长


有没有一种好的方式不在 build.gradle 中写这么多的依赖配置?

有,就是使用循环遍历依赖。

示例如下,首先添加config.gradle


ext{
dependencies = [
// base
"appcompat-v7" : "com.android.support:appcompat-v7:${version["supportLibraryVersion"]}",
...
]

annotationProcessor = [
"glide_compiler" : "com.github.bumptech.glide:compiler:${version["glideVersion"]}",
...
]

apiFileDependencies = [
"launchstarter" :"libs/launchstarter-release-1.0.0.aar"
]

debugImplementationDependencies = [
"MethodTraceMan" : "com.github.zhengcx:MethodTraceMan:1.0.7"
]

...

implementationExcludes = [
"com.android.support.test.espresso:espresso-idling-resource:3.0.2" : [
'com.android.support' : 'support-annotations'
]
]

...
}
复制代码

然后在build.gradle中配置如下:


apply from config.gradle
...

def implementationDependencies = project.ext.dependencies
def processors = project.ext.annotationProcesso
def implementationExcludes = project.ext.implementationExcludes
dependencies{
// 处理所有的 xxximplementation 依赖
implementationDependencies.each { k, v -> implementation v }
// 处理 annotationProcessor 依赖
processors.each { k, v -> annotationProcessor v }
// 处理所有包含 exclude 的依赖
implementationExcludes.each { entry ->
implementation(entry.key) {
entry.value.each { childEntry ->
exclude(group: childEntry)
}
}
}
...

}
复制代码

这样做的优点在于

1.后续添加依赖不需要改动build.gradle,直接在config.gradle中添加即可

2.精简了build.gradle的长度


3.支持代码提示的Gradle依赖管理


上面介绍了通过config.gradle管理依赖的方法

在我们添加Gradle依赖时,还有一些痛点

1.不支持代码提示

2.不支持单击跳转

3.多模块开发时,不同模块相同的依赖需要复制粘贴


使用buildSrc+kotlin可以解决这个问题

效果如下:



由于buildSrc是对全局的所有module的配置,所以可以在所有module中直接使用


这里就不多介绍了,详细开发及引入buildSrc的过程可见:

[译]Kotlin + buildSrc:更好的管理Gadle依赖


buildSrc vs includeBuild


上面介绍的方法使用的是buildSrc,使用起来比较方便

不过它的缺点在于构建速度上会慢一些,使用includeBuild可以实现同样的效果

两者实现的最终效果是差不多的

详细实现可见:【奇技淫巧】除了 buildSrc 还能这样统一配置依赖版本?巧用 includeBuild


4.Gradle模块化


我们在开发中,引入一些插件时,有时需要在build.gradle中引入一些配置,比如greendao,推送,tinker

这些其实是可以封装在相应gradle文件中,然后通过apply from引入

举个例子,例如在我们使用greendao数据库时,需要在build.gradle中指定版本


这种时候应该新建一个greendao-config.gradle


apply plugin: 'org.greenrobot.greendao'

//greenDao指定版本和路劲等
greendao {
//数据库的schema版本,也可以理解为数据库版本号
schemaVersion 1
//设置DaoMaster、DaoSession、Dao包名,也就是要放置这些类的包的全路径。
daoPackage 'com.example.ausu.big_progect.dao'
//设置DaoMaster、DaoSession、Dao目录
targetGenDir 'src/main/java'
}
复制代码

然后再在build.gradle中引入


apply from 'greendao-config.gradle'
复制代码

这样做主要有2个优点

1.单一职责原则,将greendao的相关配置封装在一个文件里,不与其他文件混淆

2.精简了build.gradle的代码,同时后续修改数据库相关时不需要修改build.gradle的代码


5.Library模块Gradle代码复用


随着我们项目的越来越大,Library Module也越建越多,每个Module都有自己的build.gradle

但其实每个build.gradle的内容都差不多,我们能不能将重复的部分封装起来复用?


我们可以做一个 basic 抽取,同样将共有参数/信息提取到 basic.gradle 中,每个 module apply,这样就是减少了不少代码量


apply plugin: 'com.android.library'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
apply plugin: 'kotlin-kapt'

android {
// 指定用于编译项目的 API 级别
compileSdkVersion Versions.compileSDK
// 指定在生成项目时要使用的 SDK 工具的版本,Android Studio 3.0 后不需要手动配置。
buildToolsVersion Versions.buildTools

// 指定 Android 插件适用于所有构建版本的版本属性的默认值
defaultConfig {
minSdkVersion Versions.minSDK
targetSdkVersion Versions.targetSDK
versionCode 1
versionName "1.0"
}

// 配置 Java 编译(编码格式、编译级别、生成字节码版本)
compileOptions {
encoding = 'utf-8'
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}

kotlinOptions {
jvmTarget = JavaVersion.VERSION_1_8.toString()
}

lintOptions {
// lint 异常后继续执行
abortOnError false
}
}

dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
...
}
复制代码

然后在相应的模块的build.gradle中引入即可


apply from:"../basic.gradle"

dependencies {
api Deps.constraintLayout
api Deps.retrofit
}
复制代码

这样是不是简洁很多?读者可根据项目实际情况判断是否适合抽取basic.gradle使用


6.资源文件分包


随着项目越来越大,项目中的资源文件也越来越大,比如layoutdrawable文件夹下的文件数量常常可达几百甚至上千个

我们能不能像代码一样,对资源文件进行分包呢?


答案是可以的,主要是利用gradlesourceSets属性

我们可以将资源文件像代码一样按业务分包,具体操作如下


1.新建res_xxx目录


main 目录下新建 res_core, res_feed(根据业务模块命名)等目录,在res_core中新建res目录中相同的文件夹如:layoutdrawable-xxhdpivalues等。


2.在gradle中配置res_xx目录


android {
//...
sourceSets {
main {
res.srcDirs(
'src/main/res',
'src/main/res_core',
'src/main/res_feed',
)
}
}
}
复制代码

以上就完成了资源文件分包,这样做主要有几点好处

1.按业务分包查找方便,结构清晰

2.strings.xmlkey-value型文件多人修改可以减少冲突

3.当删除模块或做组件化改造时资源文件删除或迁移方便,不必像以前一样一个个去找


7.AAR依赖与源码依赖快速切换


当我们的项目中Module越来越多,为了加快编译速度,常常把Module发布成AAR,然后在项目中直接依赖AAR

但是我们有时候又需要修改AAR,就需要依赖于源码

所以我们需要一个可以快速地切换依赖AAR与依赖源码的方式


我们下面举个例子,以retrofit为例

假如我们要修改retrofit的源码,修改步骤如下:

1.首先下载retrofit,可以放到和项目同级的目录,并修改目录名为retrofit-source,以便区分

2.在settings.gradle文件中添加需要修改的aar库的源码project


include ':retrofit-source'
project(':retrofit-source').projectDir = new File("../retrofit-source")
复制代码

3.替换aar为源码

build.gradle(android) 脚本中添加替换策略


allprojects {
repositories {
...
}

configurations.all {
resolutionStrategy {
dependencySubstitution {
substitute module( "com.squareup.retrofit2:retrofit") with project(':retofit-source')
}
}
}
}
复制代码

如上几步,就可以比较方便地实现aar依赖与源码依赖间的互换了

这样做的主要优点在于

1.不需要修改原有的依赖配置,而是通过全局的配置,利用本地的源码替换掉aar,侵入性低

2.如果有多个Module依赖于同一个aar,不需要重复修改,只需在根目录build.gradle中修改一处


总结


本文主要介绍了几个实用的Gradle技巧,如果觉得有所帮助,可以帮忙点赞

如果发现本文还有什么不足,欢迎在评论区指出~


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

一文读懂 View.Post 的原理及缺陷

很多开发者都了解这么一个知识点:在 Activity 的 onCreate 方法里我们无法直接获取到 View 的宽高信息,但通过 View.post(Runnable)这种方式就可以,那背后的具体原因你是否有了解过呢? 读者可以尝试以下操作。可以发现,除了通...
继续阅读 »

很多开发者都了解这么一个知识点:在 Activity 的 onCreate 方法里我们无法直接获取到 View 的宽高信息,但通过 View.post(Runnable)这种方式就可以,那背后的具体原因你是否有了解过呢?


读者可以尝试以下操作。可以发现,除了通过 View.post(Runnable)这种方式可以获得 View 的真实宽高外,其它方式取得的值都是 0


/**
* 作者:leavesC
* 时间:2020/03/14 11:05
* 描述:
* GitHub:https://github.com/leavesC
*/
class MainActivity : AppCompatActivity() {

private val view by lazy {
findViewById<View>(R.id.view)
}

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
getWidthHeight("onCreate")
view.post {
getWidthHeight("view.Post")
}
Handler().post {
getWidthHeight("handler")
}
}

override fun onResume() {
super.onResume()
getWidthHeight("onResume")
}

private fun getWidthHeight(tag: String) {
Log.e(tag, "width: " + view.width)
Log.e(tag, "height: " + view.height)
}

}
复制代码

github.leavesc.view E/onCreate: width: 0
github.leavesc.view E/onCreate: height: 0
github.leavesc.view E/onResume: width: 0
github.leavesc.view E/onResume: height: 0
github.leavesc.view E/handler: width: 0
github.leavesc.view E/handler: height: 0
github.leavesc.view E/view.Post: width: 263
github.leavesc.view E/view.Post: height: 263
复制代码

从这就可以引申出几个疑问:



  • View.post(Runnable) 为什么可以得到 View 的真实宽高

  • Handler.post(Runnable)View.post(Runnable)有什么区别

  • onCreateonResume 函数中为什么无法直接得到 View 的真实宽高

  • View.post(Runnable) 中的 Runnable 是由谁来执行的,可以保证一定会被执行吗


后边就来一一解答这几个疑问,本文基于 Android API 30 进行分析


一、View.post(Runnable)


看下 View.post(Runnable) 的方法签名,可以看出 Runnable 的处理逻辑分为两种:



  • 如果 mAttachInfo 不为 null,则将 Runnable 交由mAttachInfo内部的 Handler 进行处理

  • 如果 mAttachInfo 为 null,则将 Runnable 交由 HandlerActionQueue 进行处理


    public boolean post(Runnable action) {
final AttachInfo attachInfo = mAttachInfo;
if (attachInfo != null) {
return attachInfo.mHandler.post(action);
}
// Postpone the runnable until we know on which thread it needs to run.
// Assume that the runnable will be successfully placed after attach.
getRunQueue().post(action);
return true;
}

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

1、AttachInfo


先来看View.post(Runnable)的第一种处理逻辑


AttachInfo 是 View 内部的一个静态类,其内部持有一个 Handler 对象,从注释可知它是由 ViewRootImpl 提供的


final static class AttachInfo {

/**
* A Handler supplied by a view's {@link android.view.ViewRootImpl}. This
* handler can be used to pump events in the UI events queue.
*/
@UnsupportedAppUsage
final Handler mHandler;

AttachInfo(IWindowSession session, IWindow window, Display display,
ViewRootImpl viewRootImpl, Handler handler, Callbacks effectPlayer,
Context context) {
···
mHandler = handler;
···
}

···
}
复制代码

查找 mAttachInfo 的赋值时机可以追踪到 View 的 dispatchAttachedToWindow 方法,该方法被调用就意味着 View 已经 Attach 到 Window 上了


	@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
void dispatchAttachedToWindow(AttachInfo info, int visibility) {
mAttachInfo = info;
···
}
复制代码

再查找dispatchAttachedToWindow 方法的调用时机,可以跟踪到 ViewRootImpl 类。ViewRootImpl 内就包含一个 Handler 对象 mHandler,并在构造函数中以 mHandler 作为构造参数之一来初始化 mAttachInfo。ViewRootImpl 的performTraversals()方法就会调用 DecorView 的 dispatchAttachedToWindow 方法并传入 mAttachInfo,从而层层调用整个视图树中所有 View 的 dispatchAttachedToWindow 方法,使得所有 childView 都能获取到 mAttachInfo 对象


	final ViewRootHandler mHandler = new ViewRootHandler();

public ViewRootImpl(Context context, Display display, IWindowSession session,
boolean useSfChoreographer) {
···
mAttachInfo = new View.AttachInfo(mWindowSession, mWindow, display, this, mHandler, this,
context);
···
}

private void performTraversals() {
···
if (mFirst) {
···
host.dispatchAttachedToWindow(mAttachInfo, 0);
···
}
···
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
performLayout(lp, mWidth, mHeight);
performDraw();
···
}
复制代码

此外,performTraversals()方法也负责启动整个视图树的 Measure、Layout、Draw 流程,只有当 performLayout 被调用后 View 才能确定自己的宽高信息。而 performTraversals()本身也是交由 ViewRootHandler 来调用的,即整个视图树的绘制任务也是先插入到 MessageQueue 中,后续再由主线程取出任务进行执行。由于插入到 MessageQueue 中的消息是交由主线程来顺序执行的,所以 attachInfo.mHandler.post(action)就保证了 action 一定是在 performTraversals 执行完毕后才会被调用,因此我们就可以在 Runnable 中获取到 View 的真实宽高了


2、HandlerActionQueue


再来看View.post(Runnable)的第二种处理逻辑


HandlerActionQueue 可以看做是一个专门用于存储 Runnable 的任务队列,mActions 就存储了所有要执行的 Runnable 和相应的延时时间。两个post方法就用于将要执行的 Runnable 对象保存到 mActions中,executeActions就负责将mActions中的所有任务提交给 Handler 执行


public class HandlerActionQueue {

private HandlerAction[] mActions;
private int mCount;

public void post(Runnable action) {
postDelayed(action, 0);
}

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 executeActions(Handler handler) {
synchronized (this) {
final HandlerAction[] actions = mActions;
for (int i = 0, count = mCount; i < count; i++) {
final HandlerAction handlerAction = actions[i];
handler.postDelayed(handlerAction.action, handlerAction.delay);
}

mActions = null;
mCount = 0;
}
}

private static class HandlerAction {
final Runnable action;
final long delay;

public HandlerAction(Runnable action, long delay) {
this.action = action;
this.delay = delay;
}

public boolean matches(Runnable otherAction) {
return otherAction == null && action == null
|| action != null && action.equals(otherAction);
}
}

···

}
复制代码

所以说,getRunQueue().post(action)只是将我们提交的 Runnable 对象保存到了 mActions 中,还需要外部主动调用 executeActions方法来执行任务


而这个主动执行任务的操作也是由 View 的 dispatchAttachedToWindow来完成的,从而使得 mActions 中的所有任务都会被插入到 mHandler 的 MessageQueue 中,等到主线程执行完 performTraversals() 方法后就会来执行 mActions,所以此时我们依然可以获取到 View 的真实宽高


	@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
void dispatchAttachedToWindow(AttachInfo info, int visibility) {
mAttachInfo = info;
···
// Transfer all pending runnables.
if (mRunQueue != null) {
mRunQueue.executeActions(info.mHandler);
mRunQueue = null;
}
···
}
复制代码

二、Handler.post(Runnable)


Handler.post(Runnable)View.post(Runnable)有什么区别呢?


从上面的源码分析就可以知道,View.post(Runnable)之所以可以获取到 View 的真实宽高,主要就是因为确保了获取 View 宽高的操作一定是在 View 绘制完毕之后才被执行,而 Handler.post(Runnable)之所以不行,就是其无法保证这一点


虽然这两种post(Runnable)的操作都是往同个 MessageQueue 插入任务,且最终都是交由主线程来执行。但绘制视图树的任务是在onResume被回调后才被提交的,所以我们在onCreate中用 Handler 提交的任务就会早于绘制视图树的任务被执行,因此也就无法获取到 View 的真实宽高了


三、onCreate & onResume


onCreateonResume 函数中为什么无法也直接得到 View 的真实宽高呢?


从结果反推原因,这说明当 onCreateonResume被回调时 ViewRootImpl 的 performTraversals()方法还未执行,那么performTraversals()方法的具体执行时机是什么时候呢?


这可以从 ActivityThread -> WindowManagerImpl -> WindowManagerGlobal -> ViewRootImpl 这条调用链上找到答案


首先,ActivityThread 的 handleResumeActivity 方法就负责来回调 Activity 的 onResume 方法,且如果当前 Activity 是第一次启动,则会向 ViewManager(wm)添加 DecorView


	@Override
public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
String reason) {
···
//Activity 的 onResume 方法
final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
···
if (r.window == null && !a.mFinished && willBeVisible) {
···
ViewManager wm = a.getWindowManager();
if (a.mVisibleFromClient) {
if (!a.mWindowAdded) {
a.mWindowAdded = true;
//重点
wm.addView(decor, l);
} else {
a.onWindowAttributesChanged(l);
}
}
} else if (!willBeVisible) {
if (localLOGV) Slog.v(TAG, "Launch " + r + " mStartedActivity set");
r.hideForNow = true;
}
···
}
复制代码

此处的 ViewManager 的具体实现类即 WindowManagerImpl,WindowManagerImpl 会将操作转交给 WindowManagerGlobal


    @UnsupportedAppUsage
private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();

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

WindowManagerGlobal 就会完成 ViewRootImpl 的初始化并且调用其 setView 方法,该方法内部就会再去调用 performTraversals 方法启动视图树的绘制流程


public void addView(View view, ViewGroup.LayoutParams params,
Display display, Window parentWindow, int userId) {
···
ViewRootImpl root;
View panelParentView = null;
synchronized (mLock) {
···
root = new ViewRootImpl(view.getContext(), display);
view.setLayoutParams(wparams);
mViews.add(view);
mRoots.add(root);
mParams.add(wparams);
// do this last because it fires off messages to start doing things
try {
root.setView(view, wparams, panelParentView, userId);
} catch (RuntimeException e) {
// BadTokenException or InvalidDisplayException, clean up.
if (index >= 0) {
removeViewLocked(index, true);
}
throw e;
}
}
}
复制代码

所以说, performTraversals 方法的调用时机是在 onResume 方法之后,所以我们在 onCreateonResume 函数中都无法获取到 View 的实际宽高。当然,当 Activity 在单次生命周期过程中第二次调用onResume 方法时自然就可以获取到 View 的宽高属性


四、View.post(Runnable) 的兼容性


从以上分析可以得出一个结论:由于 View.post(Runnable)最终都是往和主线程关联的 MessageQueue 中插入任务且最终由主线程来顺序执行,所以即使我们是在子线程中调用View.post(Runnable),最终也可以得到 View 正确的宽高值


但该结论也只在 API 24 及之后的版本上才成立,View.post(Runnable) 方法也存在着一个版本兼容性问题,在 API 23 及之前的版本上有着不同的实现方式


	//Android API 24 及之后的版本
public boolean post(Runnable action) {
final AttachInfo attachInfo = mAttachInfo;
if (attachInfo != null) {
return attachInfo.mHandler.post(action);
}
// Postpone the runnable until we know on which thread it needs to run.
// Assume that the runnable will be successfully placed after attach.
getRunQueue().post(action);
return true;
}

//Android API 23 及之前的版本
public boolean post(Runnable action) {
final AttachInfo attachInfo = mAttachInfo;
if (attachInfo != null) {
return attachInfo.mHandler.post(action);
}
// Assume that post will succeed later
ViewRootImpl.getRunQueue().post(action);
return true;
}
复制代码

在 Android API 23 及之前的版本上,当 attachInfo 为 null 时,会将 Runnable 保存到 ViewRootImpl 内部的一个静态成员变量 sRunQueues 中。而 sRunQueues 内部是通过 ThreadLocal 来保存 RunQueue 的,这意味着不同线程获取到的 RunQueue 是不同对象,这也意味着如果我们在子线程中调用View.post(Runnable) 方法的话,该 Runnable 永远不会被执行,因为主线程根本无法获取到子线程的 RunQueue


    static final ThreadLocal<RunQueue> sRunQueues = new ThreadLocal<RunQueue>();

static RunQueue getRunQueue() {
RunQueue rq = sRunQueues.get();
if (rq != null) {
return rq;
}
rq = new RunQueue();
sRunQueues.set(rq);
return rq;
}
复制代码

此外,由于sRunQueues 是静态成员变量,主线程会一直对应同一个 RunQueue 对象,如果我们是在主线程中调用View.post(Runnable)方法的话,那么该 Runnable 就会被添加到和主线程关联的 RunQueue 中,后续主线程就会取出该 Runnable 来执行


即使该 View 是我们直接 new 出来的对象(就像以下的示例),以上结论依然生效,当系统需要绘制其它视图的时候就会顺便取出该任务,一般很快就会执行到。当然,由于此时 View 并没有 attachedToWindow,所以获取到的宽高值肯定也是 0


        val view = View(Context)
view.post {
getWidthHeight("view.Post")
}
复制代码

View.post(Runnable)方法的兼容性问题做下总结:



  • 当 API < 24 时,如果是在主线程进行调用,那么不管 View 是否有 AttachedToWindow,提交的 Runnable 均会被执行。但只有在 View 被 AttachedToWindow 的情况下才可以获取到 View 的真实宽高

  • 当 API < 24 时,如果是在子线程进行调用,那么不管 View 是否有 AttachedToWindow,提交的 Runnable 都将永远不会被执行

  • 当 API >= 24 时,不管是在主线程还是子线程进行调用,只要 View 被 AttachedToWindow 后,提交的 Runnable 都会被执行,且都可以获取到 View 的真实宽高值。如果没有被 AttachedToWindow 的话,Runnable 也将永远不会被执行


五、总结


Activity 的 onResume 方法在第一次被调用后,绘制视图树的 Runnable 才会被 Post 到和主线程关联的 MessageQueue 中,虽然该 Runnable 和回调 Activity 的 onResume 方法的操作都是在主线程中执行的,但是该 Runnable 只有等到主线程后续将其从 MessageQueue 取出来后才会被执行,所以这两者其实是构成了异步行为,因此我们在onCreateonResume 这两个方法里才无法直接获取到 View 的宽高大小


当 View 还未绘制完成时,通过 View.post(Runnable)提交的 Runnable 会等到 View.dispatchAttachedToWindow方法被调用后才会被保存到 MessageQueue 中,这样也依然保证了该 Runnable 一定是会在 View 绘制完成后才会被执行,所以此时我们才能获取到 View 的宽高大小


除了View.post(Runnable)外,我们还可以通过 OnGlobalLayoutListener 来获取 View 的宽高属性,onGlobalLayout 方法会在视图树发生变化的时候被调用,在该方法中我们就可以来获取 View 的宽高大小


        view.viewTreeObserver.addOnGlobalLayoutListener(object : ViewTreeObserver.OnGlobalLayoutListener {
override fun onGlobalLayout() {
view.viewTreeObserver.removeOnGlobalLayoutListener(this)
val width = view.width
}
})
复制代码

按照我自己的想法,系统提供View.post(Runnable)这个方法的目的不仅仅是为了用来获取 View 的宽高等属性这么简单,有可能是为了提供一种优化手段,使得我们可以在整个视图树均绘制完毕后才去执行一些不紧急又必须执行的操作,使得整个视图树可以尽快地呈现出来,以此优化用户体验


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

iOS -SDWebImage的使用和底层原理

一、SDWebImage的使用1、SDWebImage的安装集成有2种方式:(1)直接到github地址下载,链接https://github.com/rs/SDWebImage        (2)用coco...
继续阅读 »

一、SDWebImage的使用

1、SDWebImage的安装集成有2种方式:

(1)直接到github地址下载,链接https://github.com/rs/SDWebImage        

(2)用cocoapods安装,在文件夹生成的podfile文件中添加pod 'SDWebImage' ,终端cd + 文件位置,然后pod install即可

2、UITableView中导入头文件UIImageView+WebCache.h

[cell.imageView sd_setImageWithURL:[NSURL URLWithString:@"http://www.domain.com/path/to/image.jpg"] placeholderImage:[UIImage imageNamed:@"placeholder.png"]];

如果在加载完图片后,需要做些其他操作,可以使用block回调

[cell.imageView sd_setImageWithURL:[NSURL URLWithString:@"http://www.domain.com/path/to/image.jpg"]
placeholderImage:[UIImage imageNamed:@"placeholder.png"]
completed:^(UIImage *image, NSError *error, SDImageCacheType cacheType, NSURL *imageURL) {
... completion code here ...
}];

3、SDWebImageManager的使用

UIImageView(WebCache) 分类的核心在于 SDWebImageManager 的下载和缓存处理,SDWebImageManager将图片下载和图片缓存组合起来了。SDWebImageManager也可以单独使用。

SDWebImageManager *manager = [SDWebImageManager sharedManager];
[manager loadImageWithURL:imageURL
options:0
progress:^(NSInteger receivedSize, NSInteger expectedSize) {
// progression tracking code
}
completed:^(UIImage *image, NSError *error, SDImageCacheType cacheType, BOOL finished, NSURL *imageURL) {
if (image) {
// do something with image
}
}];

4、单独使用SDWebImageDownloader异步下载图片

我们还可以单独使用 SDWebImageDownloader 来下载图片,但是图片内容不会缓存。

SDWebImageDownloader *downloader = [SDWebImageDownloader sharedDownloader];
[downloader downloadImageWithURL:imageURL
options:0
progress:^(NSInteger receivedSize, NSInteger expectedSize) {
// progression tracking code
}
completed:^(UIImage *image, NSData *data, NSError *error, BOOL finished) {
if (image && finished) {
// do something with image
}
}];

5、单独使用SDImageCache异步缓存图片

SDImageCache 支持内存缓存和异步的磁盘缓存(可选),如果你想单独使用 SDImageCache 来缓存数据的话,可以使用单例,也可以创建一个有独立命名空间的 SDImageCache 实例。

添加缓存的方法:

[[SDImageCache sharedImageCache] storeImage:myImage forKey:myCacheKey];

默认情况下,图片数据会同时缓存到内存和磁盘中,如果你想只要内存缓存的话,可以使用下面的方法:

[[SDImageCache sharedImageCache] storeImage:myImage forKey:myCacheKey toDisk:NO];

读取缓存时可以使用 queryDiskCacheForKey:done: 方法,图片缓存的 key 是唯一的,通常就是图片的 absolute URL。

SDImageCache *imageCache = [[SDImageCache alloc] initWithNamespace:@"myNamespace"];
[imageCache queryDiskCacheForKey:myCacheKey done:^(UIImage *image) {
// image is not nil if image was found
}];

6、自定义缓存key

有时候,一张图片的 URL 中的一部分可能是动态变化的(比如获取权限上的限制),所以我们只需要把 URL 中不变的部分作为缓存用的 key。

SDWebImageManager.sharedManager.cacheKeyFilter = ^(NSURL *url) {
url = [[NSURL alloc] initWithScheme:url.scheme host:url.host path:url.path];
return [url absoluteString];
};

二、使用过程中常见问题

问题 1:使用 UITableViewCell 中的 imageView 加载不同尺寸的网络图片时会出现尺寸缩放问题。

解决方案: 

自定义 UITableViewCell,重写 -layoutSubviews 方法,调整位置尺寸; 
或者直接弃用 UITableViewCell 的 imageView,自己添加一个 imageView 作为子控件。

问题 2:图片刷新问题:SDWebImage 在进行缓存时忽略了所有服务器返回的 caching control 设置,并且在缓存时没有做时间限制,这也就意味着图片 URL 必须是静态的了,要求服务器上一个 URL 对应的图片内容不允许更新。但是如果存储图片的服务器不由自己控制,也就是说 图片内容更新了,URL 却没有更新,这种情况怎么办?

解决方案:在调用 sd_setImageWithURL: placeholderImage: options:方法时设置 options 参数为 SDWebImageRefreshCached,这样虽然会降低性能,但是下载图片时会照顾到服务器返回的 caching control。

问题 3:在加载图片时,如何添加默认的 progress indicator ? 

解决方案:在调用 -sd_setImageWithURL:方法之前,先调用下面的方法:

[imageView sd_setShowActivityIndicatorView:YES]; 

[imageView sd_setIndicatorStyle:UIActivityIndicatorViewStyleGray];

问题4:如果在加载图片的过程中出现程序报错(App Transport Security has blocked a cleartext HTTP (http://) resource load since it is insecure. Temporary exceptions can be configured via your app's Info.plist file.)

你需要操作如下--------
(1)、在Info.plist中添加 NSAppTransportSecurity 类型 Dictionary ;

(2)、在 NSAppTransportSecurity 下添加 NSAllowsArbitraryLoads 类型Boolean ,值设为 YES;

三、SDWebImage底层原理


1)当我门需要获取网络图片的时候,我们首先需要的便是URL,获得URL后我们SDWebImage实现的并不是直接去请求网路,而是检查图片缓存中有没有和URl相关的图片,如果有则直接返回image,如果没有则进行下一步。

2)当图片缓存中没有图片时,SDWebImage依旧不会直从网络上获取,而是检查沙盒中是否存在图片,如果存在,则把沙盒中对应的图片存进image缓存中,然后按着第一步的判断进行。

3)如果沙盒中也不存在,则显示占位图,然后根据图片的下载队列缓存判断是否正在下载,如果下载则等待,避免二次下载。如果不存则创建下载队列,下载完毕后将下载操作从队列中清除,并且将image存入图片缓存中。

4)刷新UI(当然根据实际情况操作)将image存入沙盒缓存。

四、SDWebImage源码实现步骤

常见的四种加载方式

1、无占位图直接加载(如果缓存中存在改图片则直接获取无需重新下载增加磁盘缓存)

- (void)sd_setImageWithURL:(nullable NSURL *)url {
[self sd_setImageWithURL:url placeholderImage:nil options:0 progress:nil completed:nil];
}

2、有占位图直接加载(如果URL加载不到则展示占位图,如果缓存中存在改图片则直接获取无需重新下载增加磁盘缓存)

- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder {
[self sd_setImageWithURL:url placeholderImage:placeholder options:0 progress:nil completed:nil];
}

3、有占位图直接加载,并且实现图片加载完之后的Block可以继续完成下一步操作(如果URL加载不到则展示占位图,如果缓存中存在改图片则直接获取无需重新下载增加磁盘缓存)

- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder completed:(nullable SDExternalCompletionBlock)completedBlock {
[self sd_setImageWithURL:url placeholderImage:placeholder options:0 progress:nil completed:completedBlock];
}

4、可以选择options的形式加载图片,(如果URL加载不到则展示占位图,如果缓存中存在改图片则直接获取无需重新下载增加磁盘缓存)

- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder options:(SDWebImageOptions)options {
[self sd_setImageWithURL:url placeholderImage:placeholder options:options progress:nil completed:nil];
}

/*使用可更换optionsType的加载方式

-------------Options 枚举下的加载方式-----------
SDWebImageRetryFailed 默认情况下,当URL无法下载时,URL就会被列入黑名单,这样库就不会继续尝试了。此标记禁用此黑名单。
SDWebImageLowPriority 默认情况下,图像下载是在UI交互过程中启动的,这标志禁用该特性,导致在UIScrollView减速方面延迟下载。
SDWebImageCacheMemoryOnly 此标记禁用磁盘缓存
SDWebImageProgressiveDownload 此标志可以进行渐进式下载,在下载过程中,图像会逐步显示,就像浏览器所做的那样。默认情况下,图像只显示一次完全下载。
SDWebImageRefreshCached 即使缓存了映像,也要尊重HTTP响应缓存控制,并在需要的情况下从远程位置刷新映像。磁盘缓存将由NSURLCache来处理,而不是使用SDWebImage,这会导致轻微的性能下降。这个选项有助于处理在同一个请求URL后面更改的图像,例如Facebook图形api概要图。如果刷新了缓存的图像,那么完成块就会被缓存的图像和最后的图像再次调用一次。只有当你不能用嵌入的缓存破坏参数使你的url静态时,才使用这个标志。
SDWebImageContinueInBackground 在iOS 4+中,如果应用程序进入后台,可以继续下载图片。这是通过请求系统在后台获得额外的时间来完成请求完成的。如果后台任务过期,操作将被取消。
SDWebImageHandleCookies 通过设置NSMutableURLRequest来处理存储在NSHTTPCookieStore中的cookie。HTTPShouldHandleCookies =是的;
SDWebImageAllowInvalidSSLCertificates 启用不受信任的SSL证书。用于测试目的。在生产中使用谨慎。
SDWebImageHighPriority 默认情况下,图像按顺序装载在队列中。这个标志把它们移到队列的前面。
SDWebImageDelayPlaceholder 默认情况下,在图像加载时加载占位符图像。此标志将延迟加载占位符图像,直到图像完成加载。
SDWebImageTransformAnimatedImage 我们通常不会在动画图像上调用transformdownloade昏暗委托方法,因为大多数转换代码会把它搞砸。无论如何,使用这个标志来转换它们。* /
SDWebImageAvoidAutoSetImage 默认情况下,图像会在下载后添加到imageView中。但是在某些情况下,我们想要在设置图像之前有手(例如,应用一个过滤器或将它添加到交叉衰减动画中)使用这个标记如果你想在成功完成时手工设置图像
SDWebImageScaleDownLargeImages 默认情况下,图像会被解码,以尊重它们原来的大小。在iOS上,这一标志将把图像缩小到与设备受限内存兼容的大小。*如果“SDWebImageProgressiveDownload”标志设置禁用缩减。
*/

以上四个常用方法,点击进去查看内部实现代码时,你会发现所有方法都指向------>


源码注释解释的含义是

用url、占位符和自定义选项设置imageView图像。下载是异步的和缓存的。
@param url是图像的url。
@param占位符将首先设置的图像,直到图像请求完成。
@param选择在下载图像时使用的选项。
@参见SDWebImageOptions用于可能的值。
@param progressBlock在下载@note时,在后台队列
@param completedBlock的后台进程中执行进程块,该块是在操作完成时被调用的。这个块没有返回值,并将所请求的UIImage作为第一个参数。在出现错误时,图像参数为nil,第二个参数可能包含一个NSError。第三个参数是一个布尔值,指示是否从本地缓存或网络检索图像。第四个参数是原始图像url。

下面是图解(上面展示了每句话的备注)

1、设置展位图,并且取消当前下载任务


2、创建一个新的下载操作


3、下载操作代码(判断流是否存在,如果不存在则将其存在失效列表中,防止重复下载无效流)-----在这里他对NSString和NSURL的转换做了判断。原因是(非常常见的错误是使用NSString对象而不是NSURL发送URL。出于某种奇怪的原因,Xcode不会对这种类型的不匹配发出任何警告。在这里,我们通过允许url作为NSString传递来确保这个错误。)括号当中是文档给出的解释,所以这里做了强制转换。


4、利用唯一生成的key,到缓存--->内存---->磁盘中分别寻找。


5、寻找的顺序 缓存---->磁盘---->在没有就下载


下载流程之后就是清理缓存(种类) 1、清理所有内存缓存镜像 2、清理所有磁盘缓存镜像3、清理过期的缓存映像从磁盘中删除

/*
异步清除所有磁盘缓存映像。非阻塞方法-立即返回。@param完成一个应该在缓存过期后执行的块(可选)

注意:这里要注意[[SDImageCache sharedImageCache] clearDisk];方法会报错,下面clearDiskOnCompletion的方法会替代上面的方法
*/
[[SDImageCache sharedImageCache] clearDiskOnCompletion:^{

}];

/*
Clear all memory cached images --->清除所有缓存镜像
*/
[[SDImageCache sharedImageCache] clearMemory];

/*
异步将所有过期的缓存映像从磁盘中删除。非阻塞方法-立即返回。@param completionBlock在缓存过期后执行(可选)--->故名思义他是不能删除你当前缓存的大小的
*/
[[SDImageCache sharedImageCache] deleteOldFilesWithCompletionBlock:^{

}];

五、总结

SDWebImage加载图片的流程:
1. 入口 setImageWithURL:placeholderImage:options: 会先把 placeholderImage显示,然后 SDWebImageManager 根据 URL 开始处理图片。

2. 进入 SDWebImageManager-downloadWithURL:delegate:options:userInfo:,交给 SDImageCache 从缓存查找图片是否已经下载 queryDiskCacheForKey:delegate:userInfo:.

3. 先从内存图片缓存查找是否有图片,如果内存中已经有图片缓存,SDImageCacheDelegate回调 imageCache:didFindImage:forKey:userInfo: 到 SDWebImageManager。

4. SDWebImageManagerDelegate 回调 webImageManager:didFinishWithImage: 到 UIImageView+WebCache等前端展示图片。

5. 如果内存缓存中没有,生成 NSInvocationOperation添加到队列开始从硬盘查找图片是否已经缓存。

6. 根据 URLKey在硬盘缓存目录下尝试读取图片文件。这一步是在 NSOperation 进行的操作,所以回主线程进行结果回调 notifyDelegate:。

7. 如果上一操作从硬盘读取到了图片,将图片添加到内存缓存中(如果空闲内存过小,会先清空内存缓存)。SDImageCacheDelegate回调 imageCache:didFindImage:forKey:userInfo:。进而回调展示图片。

8. 如果从硬盘缓存目录读取不到图片,说明所有缓存都不存在该图片,需要下载图片,回调 imageCache:didNotFindImageForKey:userInfo:。

9. 共享或重新生成一个下载器 SDWebImageDownloader 开始下载图片。

10. 图片下载由 NSURLConnection来做,实现相关 delegate 来判断图片下载中、下载完成和下载失败。

11. connection:didReceiveData: 中利用 ImageIO做了按图片下载进度加载效果。

12. connectionDidFinishLoading: 数据下载完成后交给 SDWebImageDecoder 做图片解码处理。

13. 图片解码处理在一个 NSOperationQueue完成,不会拖慢主线程 UI。如果有需要对下载的图片进行二次处理,最好也在这里完成,效率会好很多。

14. 在主线程 notifyDelegateOnMainThreadWithInfo: 宣告解码完成,imageDecoder:didFinishDecodingImage:userInfo: 回调给 SDWebImageDownloader。

15. imageDownloader:didFinishWithImage: 回调给 SDWebImageManager告知图片下载完成

16. 通知所有的 downloadDelegates下载完成,回调给需要的地方展示图片。

17. 将图片保存到 SDImageCache中,内存缓存和硬盘缓存同时保存。写文件到硬盘也在以单独 NSInvocationOperation 完成,避免拖慢主线程。

18. SDImageCache 在初始化的时候会注册一些消息通知,在内存警告或退到后台的时候清理内存图片缓存,应用结束的时候清理过期图片。

19. SDWI 也提供了 UIButton+WebCache 和 MKAnnotationView+WebCache,方便使用。

20. SDWebImagePrefetcher 可以预先下载图片,方便后续使用。



原文链接:https://blog.csdn.net/qq_16146389/article/details/88355852


收起阅读 »

一文读懂 View & Window 机制(二)

一文读懂 View & Window 机制(一)六、DecorView DecorView 是 FrameLayout 的子类,其 onResourcesLoaded 方法在拿到 PhoneWindow 传递过来的 layoutResource 后,就...
继续阅读 »

一文读懂 View & Window 机制(一)

六、DecorView


DecorView 是 FrameLayout 的子类,其 onResourcesLoaded 方法在拿到 PhoneWindow 传递过来的 layoutResource 后,就会生成对应的 View 并添加为自己的 childView,就像普通的 ViewGroup 通过 addView 方法来添加 childView 一样,该 childView 就对应 mContentRoot,我们可以在 Activity 中通过(window.decorView as ViewGroup).getChildAt(0)来获取到 mContentRoot


所以 DecorView 可以看做是 Activity 中整个视图树的根布局


public class DecorView extends FrameLayout implements RootViewSurfaceTaker, WindowCallbacks {

@UnsupportedAppUsage
private PhoneWindow mWindow;

ViewGroup mContentRoot;

DecorView(Context context, int featureId, PhoneWindow window,
WindowManager.LayoutParams params) {
···
}

void onResourcesLoaded(LayoutInflater inflater, int layoutResource) {
if (mBackdropFrameRenderer != null) {
loadBackgroundDrawablesIfNeeded();
mBackdropFrameRenderer.onResourcesLoaded(
this, mResizingBackgroundDrawable, mCaptionBackgroundDrawable,
mUserCaptionBackgroundDrawable, getCurrentColor(mStatusColorViewState),
getCurrentColor(mNavigationColorViewState));
}
mDecorCaptionView = createDecorCaptionView(inflater);
final View root = inflater.inflate(layoutResource, null);
if (mDecorCaptionView != null) {
if (mDecorCaptionView.getParent() == null) {
addView(mDecorCaptionView,
new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));
}
mDecorCaptionView.addView(root,
new ViewGroup.MarginLayoutParams(MATCH_PARENT, MATCH_PARENT));
} else {
// Put it below the color views.
addView(root, 0, new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));
}
mContentRoot = (ViewGroup) root;
initializeElevation();
}

}
复制代码

七、ActivityThread


完成以上步骤后,此时其实还只是完成了 Activity 整个视图树的加载工作,虽然 Activity 的 attach方法已经创建了 Window 对象,但还需要将 DecorView 提交给 WindowManager 后才能正式将视图树展示到屏幕上


DecorView 具体的提交时机还需要看 ActivityThread 的 handleResumeActivity 方法,该方法用于回调 Activity 的 onResume 方法,里面就会回调到 Activity 的makeVisible 方法,从方法名就可以猜出来makeVisible就用于令 Activity 变为可见状态


	@Override
public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward, String reason) {
···
r.activity.makeVisible();
···
}
复制代码

makeVisible 方法会判断当前 Activity 是否已经将 DecorView 提交给 WindowManager 了,如果还没的话就进行提交,最后将 DecorView 的可见状态设为 VISIBLE,至此才建立起 Activity 和 WindowManager 之间的关联关系,Activity 也才正式变为可见状态


    void makeVisible() {
if (!mWindowAdded) {
ViewManager wm = getWindowManager();
wm.addView(mDecor, getWindow().getAttributes());
mWindowAdded = true;
}
mDecor.setVisibility(View.VISIBLE);
}
复制代码

八、做下总结


对以上流程做下总结



  1. 每个 Activity 内部都包含一个 Window 对象,该对象的具体实现类是 PhoneWindow。Activity 的 setContentViewfindViewById 等操作都会交由 Window 来实现,Window 是 Activity 和整个 View 系统交互的入口

  2. PhoneWindow 根据 theme 和 features 得知 Activity 的基本视图属性,由此来选择合适的根布局文件 layoutResource,每种 layoutResource虽然在布局结构上略有不同,但是均会包含一个 ID 名为content的 FrameLayout,ContentParent 即该 FrameLayout。我们可以通过 Window.ID_ANDROID_CONTENT来拿到该 ID,也可以在 Activity 中通过 findViewById<View>(Window.ID_ANDROID_CONTENT) 来获取到ContentParent

  3. PhoneWindow 并不直接管理视图树,而是交由 DecorView 去管理。DecorView 会根据layoutResource来生成对应的 rootView 并将开发者指定的 ContentView 添加为ContentParent的 childView,所以可以将 DecorView 看做是视图树的根布局。正因为如此,Activity 的 findViewById 操作实际上会先交由 Window,Window 再交由 DecorView 去完成,因为 DecorView 才是实际持有 ContentView 的容器类

  4. PhoneWindow 是 Window 这个抽象类的的唯一实现类,Activity 和 Dialog 内部其实都是使用 PhoneWindow 来加载视图树,因此 PhoneWindow 成为了上层类和视图树系统之间的交互入口,从而也将 Activity 和 Dialog 的共同视图逻辑给抽象出来了,减轻了上层类的负担,这也是 Window 机制存在的好处之一

  5. Activity 的视图树是在makeVisible 方法里提交给 WindowManager 的,之后 WindowManagerImpl 会通过 ViewRootImpl 来完成整个视图树的绘制流程,至此 Activity 才对用户可见

  6. View 通过 Canvas 绘制自身,定义了具体的 UI 效果。View 和 ViewGroup 共同组成一个具体的视图树,视图树的根布局则是 DecorView,DecorView 的存在使得视图树有了一个统一的容器,有利于统一系统的主题样式并对所有 childView 进行统一管理。Activity 通过 Window 和视图树进行交互,将具体的视图树处理逻辑抽取给 PhoneWindow 实现,减轻了自身负担。PhoneWindow 拿到 DecorView 后,又通过 ViewRootImpl 来对 DecorView 进行管理,由其来完成整个视图树的 Measure、Layout、Draw 流程。当整个视图树绘制完成后,就将 DecorView 提交给 WindowManager,从而将 Activity 显示到屏幕上


九、一个 Demo


这里我也提供一个自定义 Window 的 Demo,实现了基本的拖拽移动和点击事件,代码点击这里:AndroidOpenSourceDemo



十、一文系列


最近比较倾向于只用一篇文章来写一个知识点,也懒得总是想文章标题,就一直沿用一开始用的一文读懂XXX,写着写着也攒了蛮多篇文章了,之前也已经写了几篇关于 View 系统的文章,希望对你有所帮助 😇😇


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

一文读懂 View & Window 机制(一)

Android 系统中,Window 在代码层次上是一个抽象类,在概念上表示的是一个窗口。Android 中所有的视图都是通过 Window 来呈现的,例如 Activity、Dialog 和 Toast 等,它们实际上都是挂载在 Window 上的。大部分情...
继续阅读 »

Android 系统中,Window 在代码层次上是一个抽象类,在概念上表示的是一个窗口。Android 中所有的视图都是通过 Window 来呈现的,例如 Activity、Dialog 和 Toast 等,它们实际上都是挂载在 Window 上的。大部分情况下应用层开发者很少需要来和 Window 打交道,Activity 已经隐藏了 Window 的具体实现逻辑了,但我觉得来了解 Window 机制的一个比较大的好处是可以加深我们对 View 绘制流程以及事件分发机制的了解,这两个操作就涉及到我们的日常开发了,实现自定义 View 和解决 View 的滑动冲突时都需要我们掌握这方面的知识点,而这两个操作和 Window 机制有很大的关联。视图树只有被挂载到 Window 后才会触发视图树的绘制流程,之后视图树才有机会接收到用户的触摸事件。所以说,视图树被挂载到了 Window 上是 Activity 和 Dialog 等视图能够展示到屏幕上且和用户做交互的前置条件


本文就以 Activity 为例子,展开讲解 Activity 是如何挂载到 Window 上的,基于 Android API 30 进行分析,希望对你有所帮助 😇😇


一、Window


Window 存在的意义是什么呢?


大部分情况下,用户都是在和应用的 Activity 做交互,应用在 Activity 上接收用户的输入并在 Activity 上向用户做出交互反馈。例如,在 Activity 中显示了一个 Button,当用户点击后就会触发 OnClickListener,这个过程中用户就是在和 Activity 中的视图树做交互,此时还没有什么问题。可是,当需要在 Activity 上弹出 Dialog 时,系统需要确保 Dialog 是会覆盖在 Activity 之上的,有触摸事件时也需要确保 Dialog 是先于 Activity 接收到的;当启动一个新的 Activity 时又需要覆盖住上一个 Activity 显示的 Dialog;在弹出 Toast 时,又需要确保 Toast 是覆盖在 Dialog 之上的


这种种要求就涉及到了一个层次管理问题,系统需要对当前屏幕上显示的多个视图树进行统一管理,这样才能来决定不同视图树的显示层次以及在接收触摸事件时的优先级。系统就通过 Window 这个概念来实现上述目的


想要在屏幕上显示一个 Window 并不算多复杂,代码大致如下所示


	private val windowManager by lazy {
context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
}

private val floatBallView by lazy {
FloatBallView(context)
}

private val floatBallWindowParams: WindowManager.LayoutParams by lazy {
WindowManager.LayoutParams().apply {
width = FloatBallView.VIEW_WIDTH
height = FloatBallView.VIEW_HEIGHT
gravity = Gravity.START or Gravity.CENTER_VERTICAL
flags =
WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
type = if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
WindowManager.LayoutParams.TYPE_SYSTEM_ALERT
} else {
WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY
}
}
}

fun showFloatBall() {
windowManager.addView(floatBallView, floatBallWindowParams)
}
复制代码

显示一个 Window 最基本的操作流程有:



  1. 声明希望显示的 View,即本例子中的 floatBallView,其承载了我们希望用户看到的视图界面

  2. 声明 View 的位置参数和交互逻辑,即本例子中的 floatBallWindowParams,其规定了 floatBallView 在屏幕上的位置,以及和用户之间的交互逻辑

  3. 通过 WindowManager 来添加 floatBallView,从而将 floatBallView 挂载到 Window 上,WindowManager 是外界访问 Window 的入口


当中,WindowManager.LayoutParams 的 flags 属性就用于控制 Window 的显示特性和交互逻辑,常见的有以下几个:




  1. WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE。表示当前 Window 不需要获取焦点,也不需要接收各种按键输入事件,按键事件会直接传递给下层具有焦点的 Window




  2. WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL。表示当前 Window 区域的单击事件希望自己处理,其它区域的事件则传递给其它 Window




  3. WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED。表示当前 Window 希望显示在锁屏界面




此外,WindowManager.LayoutParams 的 type 属性就用于表示 Window 的类型。Window 有三种类型:应用 Window、子 Window、系统 Window。应用类Window 对应 Activity。子 Window 具有依赖关系,不能单独存在,需要附属在特定的父 Window 之中,比如 Dialog 就是一个子 Window。系统 Window 是需要声明权限才能创建的 Window,比如 Toast 和 statusBar 都是系统 Window


从这也可以看出,系统 Window 是处于最顶层的,所以说 type 属性也用于控制 Window 的显示层级,显示层级高的 Window 就会覆盖在显示层级低的 Window 之上。应用 Window 的层级范围是 1~99,子 Window 的层级范围是 1000~1999,系统 Window 的层级范围是 2000~2999。如果想要让我们创建的 Window 位于其它 Window 之上,那么就需要使用比较大的层级值了,但想要显示自定义的系统级 Window 的话就必须向系统动态申请权限


WindowManager.LayoutParams 内就声明了这些层级值,我们可以择需选取。例如,系统状态栏本身也是一个 Window,其 type 值就是 TYPE_STATUS_BAR


    public static class LayoutParams extends ViewGroup.LayoutParams implements Parcelable {

public int type;

//应用 Window 的开始值
public static final int FIRST_APPLICATION_WINDOW = 1;
//应用 Window 的结束值
public static final int LAST_APPLICATION_WINDOW = 99;

//子 Window 的开始值
public static final int FIRST_SUB_WINDOW = 1000;
//子 Window 的结束值
public static final int LAST_SUB_WINDOW = 1999;

//系统 Window 的开始值
public static final int FIRST_SYSTEM_WINDOW = 2000;
//系统状态栏
public static final int TYPE_STATUS_BAR = FIRST_SYSTEM_WINDOW;
//系统 Window 的结束值
public static final int LAST_SYSTEM_WINDOW = 2999;

}
复制代码

二、WindowManager


每个 Window 都会关联一个 View,想要显示 Window 也离不开 WindowManager,WindowManager 就提供了对 View 进行操作的能力。WindowManager 本身是一个接口,其又继承了另一个接口 ViewManager,WindowManager 最基本的三种操作行为就由 ViewManager 来定义,即添加 View、更新 View、移除 View


public interface ViewManager {
public void addView(View view, ViewGroup.LayoutParams params);
public void updateViewLayout(View view, ViewGroup.LayoutParams params);
public void removeView(View view);
}
复制代码

WindowManager 的实现类是 WindowManagerImpl,其三种基本的操作行为都交由了 WindowManagerGlobal 去实现,这里使用到了桥接模式


public final class WindowManagerImpl implements WindowManager {

private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();

@Override
public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
applyDefaultToken(params);
mGlobal.addView(view, params, mContext.getDisplayNoVerify(), mParentWindow,
mContext.getUserId());
}

@Override
public void updateViewLayout(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
applyDefaultToken(params);
mGlobal.updateViewLayout(view, params);
}

@Override
public void removeView(View view) {
mGlobal.removeView(view, false);
}

}
复制代码

这里主要看下 WindowManagerGlobal 是如何实现 addView 方法的即可


首先,WindowManagerGlobal 会对入参参数进行校验,并对 LayoutParams 做下参数调整。例如,如果当前要显示的是子 Window 的话,那么就需要使其 LayoutParams 遵循父 Window 的要求才行


	public void addView(View view, ViewGroup.LayoutParams params,
Display display, Window parentWindow, int userId) {
if (view == null) {
throw new IllegalArgumentException("view must not be null");
}
if (display == null) {
throw new IllegalArgumentException("display must not be null");
}
if (!(params instanceof WindowManager.LayoutParams)) {
throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
}

final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;
if (parentWindow != null) {
parentWindow.adjustLayoutParamsForSubWindow(wparams);
} else {
// If there's no parent, then hardware acceleration for this view is
// set from the application's hardware acceleration setting.
final Context context = view.getContext();
if (context != null
&& (context.getApplicationInfo().flags
& ApplicationInfo.FLAG_HARDWARE_ACCELERATED) != 0) {
wparams.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
}
}
···
}
复制代码

之后就会为当前的视图树(即 view)构建一个关联的 ViewRootImpl 对象,通过 ViewRootImpl 来绘制视图树并完成 Window 的添加过程。ViewRootImpl 的 setView方法会触发启动整个视图树的绘制流程,即完成视图树的 Measure、Layout、Draw 流程,具体流程可以看我的另一篇文章:一文读懂 View 的 Measure、Layout、Draw 流程


	public void addView(View view, ViewGroup.LayoutParams params,
Display display, Window parentWindow, int userId) {
···

ViewRootImpl root;
View panelParentView = null;

···

root = new ViewRootImpl (view.getContext(), display);

view.setLayoutParams(wparams);

mViews.add(view);
mRoots.add(root);
mParams.add(wparams);

// do this last because it fires off messages to start doing things
try {
//启动和 view 关联的整个视图树的绘制流程
root.setView(view, wparams, panelParentView, userId);
} catch (RuntimeException e) {
// BadTokenException or InvalidDisplayException, clean up.
if (index >= 0) {
removeViewLocked(index, true);
}
throw e;
}
}
复制代码

ViewRootImpl 内部最终会通过 WindowSession 来完成 Window 的添加过程,mWindowSession 是一个Binder对象,真正的实现类是 Session,也就是说,Window 的添加过程涉及到了 IPC 调用。后面就比较复杂了,能力有限就不继续看下去了


        mOrigWindowType = mWindowAttributes.type;
mAttachInfo.mRecomputeGlobalAttributes = true;
collectViewAttributes();
adjustLayoutParamsForCompatibility(mWindowAttributes);
res = mWindowSession.addToDisplayAsUser(
mWindow, mSeq, mWindowAttributes,
getHostVisibility(), mDisplay.getDisplayId(), userId, mTmpFrame,
mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
mAttachInfo.mDisplayCutout, inputChannel,
mTempInsets, mTempControls
);
setFrame(mTmpFrame);
复制代码

需要注意的是,这里所讲的视图树代表的是很多种不同的视图形式。我们知道,在启动一个 Activity 或者显示一个 Dialog 的时候,都需要为它们指定一个布局文件,布局文件会通过 LayoutInflater 加载映射为一个具体的 View 对象,即最终 Activity 和 Dialog 都会被映射为一个 View 类型的视图树,它们都会通过 WindowManager 的 addView 方法来显示到屏幕上,WindowManager 对于 Activity 和 Dialog 来说具有统一的操作行为入口


三、Activity & Window


这里就以 Activity 为例子来展开讲解 Window 相关的知识点,所以也需要先对 Activity 的组成结构做个大致的介绍。Activity 和 Window 之间的关系可以用以下图片来表示





  1. 每个 Activity 均包含一个 Window 对象,即 Activity 和 Window 是一对一的关系




  2. Window 是一个抽象类,其唯一的实现类是 PhoneWindow




  3. PhoneWindow 内部包含一个 DecorView,DecorView 是 FrameLayout 的子类,其内部包含一个 LinearLayout,LinearLayout 中又包含两个自上而下的 childView,即 ActionBar 和 ContentParent。我们平时在 Activity 中调用的 setContentView 方法实际上就是在向 ContentParent 执行 addView 操作




Window 这个抽象类里定义了多个和 UI 操作相关的方法,我们平时在 Activity 中调用的setContentViewfindViewById方法都会被转交由 Window 来实现,Window 是 Activity 和视图树系统交互的入口。例如,其 getDecorView() 方法就用于获取内嵌的 DecorView,findViewById() 方法就会将具体逻辑转交由 DecorView 来实现,因为 DecorView 才是真正包含 contentView 的容器类


public abstract class Window {

public Window(Context context) {
mContext = context;
mFeatures = mLocalFeatures = getDefaultFeatures(context);
}

public abstract void setContentView(@LayoutRes int layoutResID);

@Nullable
public <T extends View> T findViewById(@IdRes int id) {
return getDecorView().findViewById(id);
}

public abstract void setTitle(CharSequence title);

public abstract @NonNull View getDecorView();

···

}
复制代码

四、Activity # setContentView


每个 Activity 内部都包含一个 Window 对象 mWindow,在 attach 方法中完成初始化,这说明 Activity 和 Window 是一对一的关系。mWindow 对象对应的是 PhoneWindow 类,这也是 Window 的唯一实现类


public class Activity extends ContextThemeWrapper implements LayoutInflater.Factory2,
Window.Callback, KeyEvent.Callback,
OnCreateContextMenuListener, ComponentCallbacks2,
Window.OnWindowDismissedCallback,
AutofillManager.AutofillClient, ContentCaptureManager.ContentCaptureClient {

@UnsupportedAppUsage
private Window mWindow;

@UnsupportedAppUsage
private WindowManager mWindowManager;

@UnsupportedAppUsage
final void attach(Context context, ActivityThread aThread,
Instrumentation instr, IBinder token, int ident,
Application application, Intent intent, ActivityInfo info,
CharSequence title, Activity parent, String id,
NonConfigurationInstances lastNonConfigurationInstances,
Configuration config, String referrer, IVoiceInteractor voiceInteractor,
Window window, ActivityConfigCallback activityConfigCallback, IBinder assistToken) {
attachBaseContext(context);

mFragments.attachHost(null /*parent*/);

//初始化 mWindow
mWindow = new PhoneWindow(this, window, activityConfigCallback);
mWindow.setWindowControllerCallback(mWindowControllerCallback);
mWindow.setCallback(this);
mWindow.setOnWindowDismissedCallback(this);
mWindow.getLayoutInflater().setPrivateFactory(this);
···
}

public void setContentView(@LayoutRes int layoutResID) {
getWindow().setContentView(layoutResID);
initWindowDecorActionBar();
}

}
复制代码

Activity 的attach 方法又是在 ActivityThread 的 performLaunchActivity 方法中被调用的,在通过反射生成 Activity 实例后就会调用attach 方法,且可以看到该方法的调用时机是早于 Activity 的 onCreate 方法的。所以说,在生成 Activity 实例后不久其 Window 对象就已经被初始化了,而且早于各个生命周期回调函数


	private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
···
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
r.intent.prepareToEnterProcess();
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to instantiate activity " + component
+ ": " + e.toString(), e);
}
}

···

activity.attach(appContext, this, getInstrumentation(), r.token,
r.ident, app, r.intent, r.activityInfo, title, r.parent,
r.embeddedID, r.lastNonConfigurationInstances, config,
r.referrer, r.voiceInteractor, window, r.configCallback,
r.assistToken);

···

if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
return activity;
}
复制代码

此外,从 Activity 的setContentView 的方法签名来看,具体逻辑都交由了 Window 的同名方法来实现,传入的 layoutResID 就是我们希望在屏幕上呈现的布局,那么 PhoneWindow 自然就需要去加载该布局文件生成对应的 View。而为了能够有一个对 View 进行统一管理的入口,View 应该要包含在一个指定的 ViewGroup 中才行,该 ViewGroup 指的就是 DecorView


下面就再来看下 PhoneWindow 是如何处理这一个流程的


五、PhoneWindow # setContentView


PhoneWindow 的 setContentView 方法的逻辑可以总结为:



  1. PhoneWindow 内部包含一个 DecorView 对象 mDecor。DecorView 是 FrameLayout 的子类,其内部包含两个我们经常会接触到的 childView:actionBar 和 contentParent,actionBar 即 Activity 的标题栏,contentParent 即 Activity 的视图内容容器

  2. 如果 mContentParent 为 null 的话则调用 installDecor() 方法来初始化 DecorView,从而同时初始化 mContentParent;不为 null 的话则移除 mContentParent 的所有 childView,为 layoutResID 腾出位置(不考虑转场动画,实际上最终的操作都一样)

  3. 通过LayoutInflater.inflate生成 layoutResID 对应的 View,并将其添加到 mContentParent 中,从而将我们的目标视图挂载到一个统一的容器中(不考虑转场动画,实际上最终的操作都一样)

  4. 当 ContentView 添加完毕后会回调 Callback.onContentChanged 方法,我们可以通过重写 Activity 的该方法从而得到布局内容改变的通知


所以说,Activity 的 setContentView 方法实际上就是在向 DecorView 的 mContentParent 执行 addView 操作,所以该方法才叫setContentView而非setView


public class PhoneWindow extends Window implements MenuBuilder.Callback {

private DecorView mDecor;

ViewGroup mContentParent;

@Override
public void setContentView(int layoutResID) {
// Note: FEATURE_CONTENT_TRANSITIONS may be set in the process of installing the window
// decor, when theme attributes and the like are crystalized. Do not check the feature
// before this happens.
if (mContentParent == null) {
installDecor();
} else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
mContentParent.removeAllViews();
}

if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
final Scene newScene = Scene.getSceneForLayout(mContentParent, layoutResID,
getContext());
transitionTo(newScene);
} else {
//将 layoutResID 对应的 View 添加到 mContentParent 中
mLayoutInflater.inflate(layoutResID, mContentParent);
}

mContentParent.requestApplyInsets();
final Callback cb = getCallback();
if (cb != null && !isDestroyed()) {
//回调通知 contentView 发生变化了
cb.onContentChanged();
}
mContentParentExplicitlySet = true;
}

private void installDecor() {
mForceDecorInstall = false;
if (mDecor == null) {
mDecor = generateDecor(-1);
mDecor.setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
mDecor.setIsRootNamespace(true);
if (!mInvalidatePanelMenuPosted && mInvalidatePanelMenuFeatures != 0) {
mDecor.postOnAnimation(mInvalidatePanelMenuRunnable);
}
} else {
mDecor.setWindow(this);
}
if (mContentParent == null) {
mContentParent = generateLayout(mDecor);

// Set up decor part of UI to ignore fitsSystemWindows if appropriate.
mDecor.makeFrameworkOptionalFitsSystemWindows();

final DecorContentParent decorContentParent = (DecorContentParent) mDecor.findViewById(
R.id.decor_content_parent);

if (decorContentParent != null) {
mDecorContentParent = decorContentParent;
···
} else {
···
}
···
}
}

}
复制代码

mContentParent 通过 generateLayout 方法来完成初始化,该方法主要完成的操作有两个:



  1. 读取我们为 Activity 设置的 theme 属性,以此配置基础的 UI 风格。例如,如果我们设置了 <item name="windowNoTitle">true</item>的话,那么就会执行 requestFeature(FEATURE_NO_TITLE) 来隐藏标题栏

  2. 根据 features 来选择合适的布局文件,得到 layoutResource。之所以会有多种布局文件,是因为不同的 Activity 会有不同的显示要求,有的要求显示 title,有的要求显示 leftIcon,而有的可能全都不需要,为了避免控件冗余就需要来选择合适的布局文件。而虽然每种布局文件结构上略有不同,但均会包含一个 ID 名为content的 FrameLayout,mContentParent 就对应该 FrameLayout。DecorView 会拿到 layoutResource 并生成对应的 View 对象(对应 DecorView 中的 mContentRoot),并将其添加为mContentParent的 childView


	protected ViewGroup generateLayout(DecorView decor) {
// Apply data from current theme.

TypedArray a = getWindowStyle();

···

//第一步
if (a.getBoolean(R.styleable.Window_windowNoTitle, false)) {
requestFeature(FEATURE_NO_TITLE);
} else if (a.getBoolean(R.styleable.Window_windowActionBar, false)) {
// Don't allow an action bar if there is no title.
requestFeature(FEATURE_ACTION_BAR);
}

···

// Inflate the window decor.

//第二步
int layoutResource;
int features = getLocalFeatures();
// System.out.println("Features: 0x" + Integer.toHexString(features));
···
//交由 DecorView 去生成 layoutResource 对应的 View
mDecor.onResourcesLoaded(mLayoutInflater, layoutResource);

//正常来说每种 layoutResource 都会包含一个 ID 为 ID_ANDROID_CONTENT 的 ViewGroup
//如果找不到的话就直接抛出异常
ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT);
if (contentParent == null) {
throw new RuntimeException("Window couldn't find content container view");
}

···
return contentParent;
}
复制代码


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

iOS -AFN实现原理&&面试

AFNetworking是封装的NSURLSession的网络请求。AFNetworking由五个模块组成:分别由NSURLSession,Security,Reachability,Serialization,UIKit五部分组成NSURLSession:网...
继续阅读 »

AFNetworking是封装的NSURLSession的网络请求。

AFNetworking由五个模块组成:

分别由NSURLSession,Security,Reachability,Serialization,UIKit五部分组成

NSURLSession:网络通信模块(核心模块) 对应 AFNetworking中的 AFURLSessionManager和对HTTP协议进行特化处理的AFHTTPSessionManager,AFHTTPSessionManager是继承于AFURLSessionmanager的
Security:网络通讯安全策略模块  对应 AFSecurityPolicy
Reachability:网络状态监听模块 对应AFNetworkReachabilityManager
Seriaalization:网络通信信息序列化、反序列化模块 对应 AFURLResponseSerialization
UIKit:对于IOSUIKit的扩展库

网络请求的过程:

创建NSURLSessionConfig对象--用创建的config对象配置初始化NSURLSession--创建NSURLSessionTask对象并resume执行,用delegate或者block回调返回数据。

AFURLSessionManager封装了上述网络交互功能

AFURLSessionManager请求过程

1.初始化AFURLSessionManager。

2.获取AFURLSessionManager的Task对象

3.启动Task

AFURLSessionManager会为每一个Task创建一个AFURLSessionmanagerTaskDelegate对象,manager会让其处理各个Task的具体事务,从而实现了manager对多个Task的管理

初始化好manager后,获取一个网络请求的Task,生成一个Task对象,并创建了一个AFURLSessionmanagerTaskDelegate并将其关联,设置Task的上传和下载delegate,通过KVO监听download进度和upload进度

NSURLSessionDelegate的响应

因为AFURLSessionmanager所管理的AFURLSession的delegate指向其自身,因此所有的NSURLSessiondelegate的回调地址都是AFURLSessionmanager,而AFURLSessionmanager又会根据是否需要具体处理会将AFdelegate所响应的delegate,传递到对应的AFdelegate去

面试相关:

AFN调用流程分析:

AFHTTPSessionManager: 发起网络请求(例如GET);
AFHTTPSessionManager内部调用dataTaskWithHTTPMethod:方法(内部处理requestSerializer);
dataTaskWithHTTPMethod内部调用父类AFURLSessionManager的dataTaskWithRequest: uploadProgress: downloadProgress: completionHandler方法;
AFURLSessionManager中的dataTaskWithRequest方法内部设置全局session和创建task;
AFURLSessionManager中的dataTaskWithRequest方法内部给task设置delegate(AFURLSessionManagerTaskDelegate);
taskDelegate代理的初始化: 绑定task / 存储task下载的数据 / 下载或上传进度 / 进度与task同步(KVO)
task对应的AFURLSessionManagerTaskDelegate实现对进度处理、Block调用、Task完成返回数据的拼装的功能等;
setDelegate: forTask: 加锁设置通过一个字典处理Task与之代理方法关联; 添加对Task开始、重启、挂起状态的通知的接收.
[downloadTask resume]后执行开始, 走代理回调方法(内部其实是NSURLSession的各种代理的实现);
task完成后走URLSession: task: didCompleteWithError: 回调对返回的数据进行封装;
同时移除对应的task; removeDelegateForTask: 加锁移除8中的字典和通知;

AFN请求过程梳理

首先我们是初始化了AFHTTPSessionManager类(往往创建单例)初始化时候指定请求回调的代理是父类(AFURLSessionManager)。之后当我们发出一个请求后,先创建一个AFURLSessionManagerTaskDelegate对象来保存请求结果回调。并把该对象放到一个全局字典中来保存(以task.taskIdentifier为key),再启动请求。当AFURLSessionManager类收到了请求结果后根据task.taskIdentifier从全局字典中取出当前请求的AFURLSessionManagerTaskDelegate对象。然后调用AFURLSessionManagerTaskDelegate的对象方法处理请求,完成回调。之后再从全局字典中移除该AFURLSessionManagerTaskDelegate对象。

AFN是怎样来解决循环引用的

首先我们用AFN时候往往是用单例,因此调用类不会直接持有该AFHTTPSessionManager对象。
该AFHTTPSessionManager对象持有block,该AFHTTPSessionManager对象持有全局字典,该全局字典持有AFURLSessionManagerTaskDelegate对象,该AFURLSessionManagerTaskDelegate对象持有block,这是一个循环引用。
当AFURLSessionManagerTaskDelegate对象block进行回调后,从全局字典中移除该对象。从而打破引用环。

1、AFN2.x为什么添加一条常驻线程?

AFN2.0里面把每一个网络请求的发起和解析都放在了一个线程里执行。正常来说,一个线程执行完任务后就退出了。开启runloop是为了防止线程退出。一方面避免每次请求都要创建新的线程;另一方面,因为connection的请求是异步的,如果不开启runloop,线程执行完代码后不会等待网络请求完的回调就退出了,这会导致网络回调的代理方法不执行。
这是一个单例,用NSThread创建了一个线程,并且为这个线程添加了一个runloop,并且加了一个NSMachPort,来防止runloop直接退出。 这条线程就是AF用来发起网络请求,并且接受网络请求回调的线程,仅仅就这一条线程

2、AFN3.x为什么不再需要常驻线程?

NSURLConnection的一大痛点就是:发起请求后,这条线程并不能随风而去,而需要一直处于等待回调的状态。
苹果也是明白了这一痛点,从iOS9.0开始 deprecated 了NSURLConnection。 替代方案就是NSURLSession。

3、为什么AF3.0中需要设置self.operationQueue.maxConcurrentOperationCount = 1;而AF2.0却不需要?

功能不一样:AF3.0的operationQueue是用来接收NSURLSessionDelegate回调的,鉴于一些多线程数据访问的安全性考虑,设置了maxConcurrentOperationCount = 1来达到串行回调的效果。
而AF2.0的operationQueue是用来添加operation并进行并发请求的,所以不要设置为1。

AFNetworking3.0

在AFNetworking 3.0之前,底层是通过封装NSURLConnection来实现的。
在AFNetworking 3.0之后,也就是在iOS 9.0 之后,NSURLConnection被弃用,苹果推荐使用NSURLSession来管理网络请求,所以AFNetworking 3.0之后,底层是通过封装NSURLSession来实现的。

从AFNetworking 3.0中之后,下面三个方法被弃用了。
AFURLConnectionOperation
AFHTTPRequestOperation
AFHTTPRequestOperationManager

依次被下面三个类代替了,同时请求方法也跟着改变了,所以AFNetworking 3.0以后发生了很大的变化。
AFURLSessionManager
AFHTTPSessionManager
AFNetworkReachabilityManager

参考链接:https://blog.csdn.net/songzhuo1991/article/details/104883981

参考链接:https://blog.csdn.net/weixin_39638526/article/details/111748124

收起阅读 »

Android修炼系列(三),一个对象在JVM的生死存亡

当我们new了一个对象,会发生什么呢?来段代码: public class Tested { public static int T = 10; public int c = 1; } 复制代码 类初始化 在编译期,编译器会将 Tested.j...
继续阅读 »

当我们new了一个对象,会发生什么呢?来段代码:


public class Tested {
public static int T = 10;
public int c = 1;
}
复制代码

类初始化


在编译期,编译器会将 Tested.java类转换成 Tested.class 字节码文件。当虚拟机接收到new 字节码指令时,如果此时类还未被初始化,则虚拟机会先进行类的初始化过程。



在类加载完成后。虚拟机会为new Tested() 的Tested对象,在java堆中分配内存。而对象所需要的内存大小在类加载完成后就被确定了。


指针碰撞


如果 java 中的内存是规整的,即使用过的放在一边,空闲的在另一边,中间放着指针作为分界点的指示器。那所分配的内存就仅仅是将指针像空闲空间挪动一段与对象大小相等的距离。这种方式内称为指针碰撞。


空闲列表


如果 java 中的内存是不工整的,使用过的和空闲的内存相互交错,那么虚拟机就必须维护一个列表记录哪些内存是可用的。在分配的时候从列表中找到一块足够大的空间给对象示例,并更新表的记录。这种分配方式称为空闲列表。


对象初始化


当我们的对象内存被分配完毕后,虚拟机就会对对象进行初始化操作。



此时Tested 对象在我们眼里就算出生了,在虚拟机眼里就是真正可用的了。可对象的生命并不是无穷的,它也会经历自己的死亡。


可达性分析


在主流实现中,我们通过可达性分析来判断一个对象是否存活。实现思路是:通过一系列被称为 “GC Roots” 的对象作为起始点,从这些节点开始像下搜索,搜索所走的路径被称为引用链,当一个对象到GC Roots没有任何引用链相连,则证明此对象是不可用的。见图:


在这里插入图片描述


即使 Obj5 与 Obj4 由于与 GC Roots 没有引用链相连,所以我们称 GC Roots 到对象 Obj4 和 Obj5 不可达。所以 Obj4 和 Obj5 就是可回收的。


既然Obj4 和 Obj5 是可回收的,那么是否一定会被回收呢?不一定。此时虚拟机会进行第一次的标记过程。因为 java 内能够重写 finalize() 方法(在这里只是分析特例,不推荐在任何情况下使用此方法),当对象重写了此方法,并且 finalize() 方法还未被虚拟机调用,那么虚拟机就会将此对象放入一个专门的F-Queue队列,由一个单独的 Finalizer 线程去执行它,如果队列中对象的 finalize() 方法在虚拟机第二次标记之前执行,并在此次执行过程中又将自己与GC Roots 引用链相连,那么虚拟机在进行第二次标记时,就会将该对象从 F-Queue队列移除,否则就宣告该对象死亡。注意:finalize() 方法只会被执行一次,所以一个对象一生只有一次机会进入F-Queue队列,有机会逃脱本此死亡。


如果对象已经宣告死亡了,那么虚拟机怎么来回收它吗?


标记-清除算法


这是最基础的收集算法,主要分为标记和清除两个阶段。首先标记出所以需要回收的对象,在标记完成后统一回收所有被标记的对象。可以参考上面的空闲列表。其有两点不足:


a. 效率问题,标记和清除两个过程效率都不高。


b. 空间问题,因为堆中的内存不是规整的,已使用的和空闲的内存相互交错,这也就导致了每次GC回收后,产生大量的内存碎片,而当再次分配一个大对象时,如果无法找到足够的连续内存,又会再此触发GC回收。


复制算法


复制算法是将堆内存分成大小相等的两块,每次只使用其中一块,这样内存就是规整的了,参考指针碰撞。每当一块内存使用完了,就将该块内存中存活的对象复制到另一边,随后将该块内存一次清理掉。


现在的虚拟机都采用这种方式来回收新生代,只是并不是按照1:1的比例来划分内存,而是将内存分为一块较大的 Eden 空间,和两块较小的 Survivor 空间(HotSpot虚拟机默认Eden:Survivor = 8 :1)。每次只使用 Eden 和 其中一块 Survivor 空间,当回收时,将 Eden 空间和当前正使用的 Survivor 空间内存活的对象复制到另一块空闲的 Survivor空间,随后清空 Eden 和 刚才用过的 Survivor 内存。


注意:由于我们无法保证每次 存活的对象所占内存一直都不大于 Survivor 内存值,所以就会有溢出风险。所以在 分代收集算法 中,虚拟机会将内存先划分为一块新生代内存和一块为老年代内存。而在新生代内存中,会采用这种8:1:1的内存分配方式,如果溢出了,就将该情况下的存活对象全部放在老年代内存里,说白了就是一种兜底策略。这里要注意的是,不是溢出的那部分,而是全部的存活对象。


标记-整理算法


标记-整理算法中的标记过程,与标记-清除算法中的标记过程一样,不同的是,当标记完成并清理回收完对象后,会将当前不连续的碎片内存就行整理,即存活的对象都移到一端,来保证接下来要分配的内存的规整性。我们的 分代收集算法 中的老年代内存块,就是采用的该算法(当然也可以是标记-清除算法,不同虚拟机的策略不同)。所以就不再对分代收集算法就行赘述了。



好了,本文到这里,关于“对象”的生命周期的讲解就结束了。如果本文对你有用,来点个赞吧,大家的肯定也是阿呆i坚持写作的动力。



参考
1、周志明,深入理解JAVA虚拟机:机械工业出版社


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

Android修炼系列(二),Class类加载过程与类加载器

在说类加载器和双亲委派模型之前,我们先来梳理下Class类文件的加载过程,JAVA虚拟机为了保证 实现语言的无关性,是将虚拟机只与“Class 文件”字节码 这种特定形式的二进制文件格式 相关联,而不是与实现语言绑定。类加载过程Class类...
继续阅读 »


在说类加载器和双亲委派模型之前,我们先来梳理下Class类文件的加载过程,JAVA虚拟机为了保证 实现语言的无关性,是将虚拟机只与“Class 文件”字节码 这种特定形式的二进制文件格式 相关联,而不是与实现语言绑定。

类加载过程

Class类从被加载到虚拟机内存开始,到卸载出内存为止,其生命周期包括:加载(Loading)、验证(Verification)、准备(Preparation)、解析(Resolution)、初始化(Initialization)、使用(Using)、卸载(Unloading)7个阶段。其中加载过程见下:

在这里插入图片描述

加载阶段

加载阶段做了什么?过程见下图。其中类的全限定名是Class文件(JAVA由编译器自动生成)内的代表常量池内的16进制值所代表的特定符号引用。因为Class文件格式有其自己的一套规范,如第1-4字节代表魔数,第5-6字节代表次版本,第7-8字节代表主版本号等等。

说白了就是,虚拟机不关心我们的这种“特定二进制流”从哪里来的,从本地加载也好,从网上下载的也罢,都没关系。虚拟机要做的就是将该二进制流写在自己的内存中并生成相应的Class对象(并不是在堆中)。在这个阶段,我们能够通过我们自定义类加载器来控制二进制流的获取方式。

验证阶段

验证阶段,正因为加载阶段虚拟机不介意二进制的来源,所以就可能存在着影响虚拟机正常运行的安全隐患。所以虚拟机对于该二进制流的校验工作非常重要。校验方式包括但不限于:

准备阶段

准备阶段在此阶段将正式为类变量分配内存并设置变量的初始化值。注意的是,类变量是指 static 的静态变量,是分配在方法区之中的,而不像对象变量,分配在堆中。还有一点需要注意,final 常量在此阶段就已经被赋值了。如下:

    public static int SIZE = 10; // 初始化值 == 0
public static final int SIZE = 10; // 初始化值 == 10
复制代码

解析阶段

解析阶段是将常量池内的符号引用替换为直接引用的过程。符号引用就是上文说的Class文件格式标准所规定的特定字面量,而直接引用就是我们说的指针,内存引用等概念

初始化阶段

到了初始化阶段,就开始真正执行我们的字节码程序了。也可以理解成:类初始化阶段就是虚拟机内部执行类构造 < clinit >() 方法的过程。注意,这个类构造方法可不是虚拟机内部生成的,而是我们的编译器自动生成的,是编译器自动收集类中的所有类变量的 赋值动作 和静态语句块(static{}块)中的语句合并产生的,具体分析见下。

注意,这里说的是类变量赋值动作,即static 并且具有赋值操作,如果无赋值操作,那么在准备阶段进行的方法区初始化就算完成了。为何还要加上static{} 呢?我们可以把static{} 理解成:是由多个静态初始化动作组织成的一个特殊的“静态子句”,与其他的静态初始化动作一样。这也是为何 static {} 只会执行一遍并在对象构造方法之前执行的原因。如下代码:

public class Tested {
public static int T;
// public static int V; // 无赋值,不在类构造中再次初始化
public int c = 1; // 不会在类构造中

static {
T = 10;
}
}
复制代码

还有一点,编辑器收集类变量的顺序,也就是虚拟机在此初始化阶段的执行顺序,这个顺序就是变量在类中语句定义的先后顺序,如上面的:语句 2 : T 在 6 : T 之前,这是两个独立的语句。类构造< clinit >的其他特点如下:

编译期的< clinit >

我们将流程回溯到编译期阶段,以刚刚的Tested 类代码为例。通过 javap -c /Tested.class (注意:/../Tested 绝对路径),获取Class文件:

public class com.tencent.lo.Tested {
public static int T;

public int c;

public com.tencent.lo.Tested();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: aload_0
5: iconst_1
6: putfield #2 // Field c:I
9: return

static {};
Code:
0: bipush 10
2: putstatic #3 // Field T:I
5: return
}
复制代码

在Class 文件中我们能很明显的看到 invokespecial 对应的对象构造 "< init >" : () V ,那为什么没有看到< clinit > 类构造方法呢?其实上面的 static {} 就是。我们来看下OpenJDK源码 Constants接口,此接口定义了在编译器中所用到的常量,这是一个自动生成的类。

public interface Constants extends RuntimeConstants {
public static final boolean tracing = true;

Identifier idClassInit = Identifier.lookup("<clinit>");
Identifier idInit = Identifier.lookup("<init>");
}
复制代码

MemberDefinition类 中,判断是否为类构造器字符:

    public final boolean isInitializer() {
return getName().equals(idClassInit); // 类构造
}
public final boolean isConstructor() {
return getName().equals(idInit); // 对象构造
}
复制代码

而在MemberDefinition 的 toString() 方法中,我们能够看到,当类构造时,会输出特定字符,而不会像对象构造那样输出规范的字符串。

    public String toString() {
Identifier name = getClassDefinition().getName();
if (isInitializer()) { // 类构造
return isStatic() ? "static {}" : "instance {}";
} else if (isConstructor()) { // 对象构造
StringBuffer buf = new StringBuffer();
buf.append(name);
buf.append('(');
Type argTypes[] = getType().getArgumentTypes();
for (int i = 0 ; i < argTypes.length ; i++) {
if (i > 0) {
buf.append(',');
}
buf.append(argTypes[i].toString());
}
buf.append(')');
return buf.toString();
} else if (isInnerClass()) {
return getInnerClass().toString();
}
return type.typeString(getName().toString());
}
复制代码

类加载器

“虚拟机将类加载阶段中的“通过一个全限定名来获取描述此类的二进制字节流”这个动作放到了外部来实现,以便开发者可以自己决定如何获取所需的类文件,而实现这个动作的代码模块就被称为类加载器。对于任意一个类来说,只有在类加载器相同的情况下比较两者是否相同才有意义,否则即使是同个文件,在不同加载器下,在虚拟机看来其仍然是不同的,是两个独立的类。我们可以将类加载器分为三类”:

双亲委派

而所谓的双亲委派模型就是:“如果一个类加载器收到类加载的请求,它首先不会自己去尝试加载这个类,而是把加载的操作委托给父类加载器去完成,每一层次加载器都是如此,因此所有的加载请求都会传送到顶层的启动类加载器中,只有当父加载器反馈自己无法完成这个加载请求时(它的搜索范围没有找到所需的类,因为上面所说的启动类加载器和扩展类加载器,只能加载特定目录之下的,或被-x参数所指定的类库),子类才会尝试自己加载”。注意这里说的父类只是形容层次结构,其并不是直接继承关系,而是通过组合方式来复用父类的加载器的。

在这里插入图片描述

“双亲委派的好处就是,使加载器也具备了优先级的层次结构。例如,java.lang.Object存放在< JAVA_HOME>\lib 下的rt.jar包内,无论哪个类加载器要加载这个类,最终都会委派给最顶层的启动类加载器,所以保证了Object类在各类加载器环境中都是同一个类。相反,如果没有双亲委派模型,如果用户编写了一个java.lang.Object类,并放在程序的ClassPath下,那么系统将会出现多个不同的Object类”。

为何?因为每个加载器各自为政,不会委托给父构造器,如上面所说,只要加载器不同,即使类Class文件相同,其也是独立的。

试想如果自己在项目中编写了一个java.lang.Object 类(当然不能放入rt.jar类库中替换掉同名Object文件,这样做没有意义,如果虚拟机加载校验能通过的话,只是相当于改了源码嘛),我们通过自定义的构造器来加载这个类可以吗?理论上来说,虽然这两个类都是java.lang.Object,但由于构造器不同,对于虚拟机来说这是不同的Class文件,当然可以。但是实际上呢?来段代码见下:

    public void loadPathName(String classPath) throws ClassNotFoundException {
new ClassLoader() {
@Override
public Class<?> loadClass(String name) throws ClassNotFoundException {
InputStream is = getClass().getResourceAsStream(name);
if (is == null)
return super.loadClass(name);
byte[] b;
try {
b = new byte[is.available()];
is.read(b);
} catch (Exception e) {
return super.loadClass(name);
}
return defineClass(name, b, 0, b.length);
}
}.loadClass(classPath);
}
复制代码

实际的执行逻辑是 defineClass 方法。可以发现,自定义加载器是无法加载以 java. 开头的系统类的。

    protected final Class<?> defineClass(String name, byte[] b, int off, int len,
ProtectionDomain protectionDomain)
throws ClassFormatError {

protectionDomain = preDefineClass(name, protectionDomain);
... // 略

return c;
}

private ProtectionDomain preDefineClass(String name, ProtectionDomain pd) {
if (!checkName(name))
throw new NoClassDefFoundError("IllegalName: " + name);
// 在这里能看到系统类,自定义的加载器是不能加载的
if ((name != null) && name.startsWith("java.")) {
throw new SecurityException
("Prohibited package name: " +
name.substring(0, name.lastIndexOf('.')));
}
... // 略

return pd;
}
复制代码

如果你用AS直接查看,你会发现,defineClass 内部是没有具体实现的,源码见下。可这并不代表android 的 defineClass 方法实现与 java 不同,因为都是引用的 java.lang 包下的ClassLoader 类,逻辑肯定都是一样的。之所以看到的源码不一样,这是由于SDK和JAVA源码包的区别导致的。SDK内的源码是谷歌提供给我们方便开发查看的,并不完全等同于源码。

    protected final Class<?> defineClass(String name, byte[] b, int off, int len)
throws ClassFormatError
{
throw new UnsupportedOperationException("can't load this type of class file");
}
复制代码

好了,本文到这里就结束了,关于类加载过程的讲解也应该够用了。如果本文对你有用,来点个赞吧,大家的肯定也是阿呆i坚持写作的动力。

参考 1、周志明,深入理解JAVA虚拟机:机械工业出版社

收起阅读 »

iOS -YYModel的底层实现原理

一. YYModel逻辑结构 实际使用时,需要对其遍历,取出容器中得字典,然后继续字典转模型(YYModel的核心是通过runtime获取结构体中得Ivars的值,将此值定义为key,然后给key赋value值,所以我们需要自己遍历容器(N...
继续阅读 »

一. YYModel逻辑结构 


实际使用时,需要对其遍历,取出容器中得字典,然后继续字典转模型
(YYModel的核心是通过runtime获取结构体中得Ivars的值,将此值定义为key,然后给key赋value值,所以我们需要自己遍历容器(NSArray,NSSet,NSDictionary),获取每一个值,然后KVC进行处理)。

1.Model 属性名和 JSON 中的 Key 不相同

// JSON:
{
"n":"Harry Pottery",
"p": 256,
"ext" : {
"desc" : "A book written by J.K.Rowing."
},
"ID" : 100010
}

// Model:
@interface Book : NSObject
@property NSString *name;
@property NSInteger page;
@property NSString *desc;
@property NSString *bookID;
@end
@implementation Book
//返回一个 Dict,将 Model 属性名对映射到 JSON 的 Key。
+ (NSDictionary *)modelCustomPropertyMapper {
return @{@"name" : @"n",
@"page" : @"p",
@"desc" : @"ext.desc",
@"bookID" : @[@"id",@"ID",@"book_id"]};
}
@end

你可以把一个或一组 json key (key path) 映射到一个或多个属性。如果一个属性没有映射关系,那默认会使用相同属性名作为映射。
在 json->model 的过程中:如果一个属性对应了多个 json key,那么转换过程会按顺序查找,并使用第一个不为空的值。

在 model->json 的过程中:如果一个属性对应了多个 json key (key path),那么转换过程仅会处理第一个 json key (key path);如果多个属性对应了同一个 json key,则转换过过程会使用其中任意一个不为空的值。

2.Model 包含其他 Model

// JSON
{
"author":{
"name":"J.K.Rowling",
"birthday":"1965-07-31T00:00:00+0000"
},
"name":"Harry Potter",
"pages":256
}

// Model: 什么都不用做,转换会自动完成
@interface Author : NSObject
@property NSString *name;
@property NSDate *birthday;
@end
@implementation Author
@end

@interface Book : NSObject
@property NSString *name;
@property NSUInteger pages;
@property Author *author; //Book 包含 Author 属性
@end
@implementation Book
@end

3.容器类属性

@class Shadow, Border, Attachment;

@interface Attributes
@property NSString *name;
@property NSArray *shadows; //Array
@property NSSet *borders; //Set
@property NSMutableDictionary *attachments; //Dict
@end

@implementation Attributes
// 返回容器类中的所需要存放的数据类型 (以 Class 或 Class Name 的形式)。
+ (NSDictionary *)modelContainerPropertyGenericClass {
return @{@"shadows" : [Shadow class],
@"borders" : Border.class,
@"attachments" : @"Attachment" };
}
@end

在实际使用过过程中,[Shadow class]Border.class@"Attachment"没有明显的区别。
这里仅仅是创建作者有说明,实际使用时,需要对其遍历,取出容器中得字典,然后继续字典转模型。

YYModel的核心是通过runtime获取结构体中得Ivars的值,将此值定义为key,然后给keyvalue值,所以我们需要自己遍历容器(NSArrayNSSetNSDictionary),获取每一个值,然后KVC)。

具体的代码实现如下:

NSDictionary *json =[self getJsonWithJsonName:@"ContainerModel"];
ContainerModel *containModel = [ContainerModel yy_modelWithDictionary:json];
NSDictionary *dataDict = [containModel valueForKey:@"data"];
//定义数组,接受key为list的数组
self.listArray = [dataDict valueForKey:@"list"];
//遍历数组
[self.listArray enumerateObjectsUsingBlock:^(id _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
NSDictionary *listDict = obj;
//获取数组中得字典
List *listModel = [List yy_modelWithDictionary:listDict];
//获取count 和 id
NSString *count = [listModel valueForKey:@"count"];
NSString *id = [listModel valueForKey:@"id"];

4.黑名单与白名单

@interface User
@property NSString *name;
@property NSUInteger age;
@end

@implementation Attributes
// 如果实现了该方法,则处理过程中会忽略该列表内的所有属性
+ (NSArray *)modelPropertyBlacklist {
return @[@"test1", @"test2"];
}
// 如果实现了该方法,则处理过程中不会处理该列表外的属性。
+ (NSArray *)modelPropertyWhitelist {
return @[@"name"];
}
@end

5.数据校验与自定义转换

实际这个分类的目的比较简单和明确。
就是对判断是否为时间戳,然后对时间戳进行处理,调用
_createdAt = [NSDate dateWithTimeIntervalSince1970:timestamp.floatValue];
获取时间。

// JSON:
{
"name":"Harry",
"timestamp" : 1445534567 //时间戳
}

// Model:
@interface User
@property NSString *name;
@property NSDate *createdAt;
@end

@implementation User
// JSON 转为 Model 完成后,该方法会被调用。
// 你可以在这里对数据进行校验,如果校验不通过,可以返回 NO,则该 Model 会被忽略。
// 你也可以在这里做一些自动转换不能完成的工作。
- (BOOL)modelCustomTransformFromDictionary:(NSDictionary *)dic {
NSNumber *timestamp = dic[@"timestamp"];
if (![timestamp isKindOfClass:[NSNumber class]]) return NO;
_createdAt = [NSDate dateWithTimeIntervalSince1970:timestamp.floatValue];
return YES;
}

// Model 转为 JSON 完成后,该方法会被调用。
// 你可以在这里对数据进行校验,如果校验不通过,可以返回 NO,则该 Model 会被忽略。
// 你也可以在这里做一些自动转换不能完成的工作。
- (BOOL)modelCustomTransformToDictionary:(NSMutableDictionary *)dic {
if (!_createdAt) return NO;
dic[@"timestamp"] = @(n.timeIntervalSince1970);
return YES;
}
@end

  • 需要注意的时,如果用插件,对时间戳类型或默认创建为NSUInteger类型,需要将其更改为NSDate类型。

6.Coding/Copying/hash/equal/description

以下方法都是YYModel的简单封装,实际使用过程和系统方法区别不大。对其感兴趣的可以点进方法内部查看。

@interface YYShadow :NSObject 
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) CGSize size;
@end

@implementation YYShadow
// 直接添加以下代码即可自动完成
- (void)encodeWithCoder:(NSCoder *)aCoder {
[self yy_modelEncodeWithCoder:aCoder];
}
- (id)initWithCoder:(NSCoder *)aDecoder {
self = [super init];
return [self yy_modelInitWithCoder:aDecoder];
}
- (id)copyWithZone:(NSZone *)zone {
return [self yy_modelCopy];
}
- (NSUInteger)hash {
return [self yy_modelHash];
}
- (BOOL)isEqual:(id)object {
return [self yy_modelIsEqual:object];
}
- (NSString *)description {
return [self yy_modelDescription];
}
@end


原文链接:https://blog.csdn.net/huhui168/article/details/80541387

收起阅读 »

Android修炼系列(一),写一篇易懂的动态代理讲解

在说动态代理之前,先来简单看下代理模式。代理是最基本的设计模式之一。它能够插入一个用来替代“实际”对象的“代理”对象,来提供额外的或不同的操作。这些操作通常涉及与“实际”对象的通信,因此“代理”对象通常充当着中间人的角色。 代理模式 代理对象为“实际”对象提供...
继续阅读 »

在说动态代理之前,先来简单看下代理模式。代理是最基本的设计模式之一。它能够插入一个用来替代“实际”对象的“代理”对象,来提供额外的或不同的操作。这些操作通常涉及与“实际”对象的通信,因此“代理”对象通常充当着中间人的角色。


代理模式


代理对象为“实际”对象提供一个替身或占位符以控制对这个“实际”对象的访问。被代理的对象可以是远程的对象,创建开销大的对象或需要安全控制的对象。来看下类图:


代理模式


再来看下类图对应代码,这是IObject接口,真实对象RealObj和代理对象ObjProxy都实现此接口:


/**
* 为实际对象Tested和代理对象TestedProxy提供对外接口
*/
public interface IObject {
void request();
}
复制代码

RealObj是实际处理request() 逻辑的对象,但是出于设计的考量,需要对RealObj内部的方法调用进行控制访问


public class RealObject implements IObject {

@Override
public void request() {
// 模拟一些操作
}
}
复制代码

ObjProxy是RealObj的代理类,其同样实现了IObject接口,所以具有相同的对外方法。客户端与RealObj的所有交互,都必须通过ObjProxy。


public class ObjProxy implements IObject {
IObject realT;

public ObjProxy(IObject t) {
realT = t;
}

@Override
public void request() {
if (isAllow()) realT.request();
}

private boolean isAllow() {
return true;
}
}
复制代码

番外


代理模式和装饰者模式不管是在类图,还是在代码实现上,几乎是一样的,但我们为何还要进行划分呢?其实学设计模式,不能拘泥于格式,不能死记形式,重要的是要理解模式背后的意图,意图只有一个,但实现的形式却可能多种多样。这也就是为何那么多变体依然属于xx设计模式的原因。


代理模式的意图是替代真正的对象以实现访问控制,而装饰者模式的意图是为对象加入额外的行为。


动态代理


Java的动态代理可以动态的创建代理并动态的处理所代理方法的调用,在动态代理上所做的所以调用都会被重定向到单一的调用处理器上,它的工作是揭示调用的类型并确定相应的策略。类图见下:


动态代理


还以上面的代码为例,这是对外的接口IObject:


public interface IObject {
void request();
}
复制代码

这是 InvocationHandler 的实现类,类图中 Proxy 的方法调用都会被系统传入此类,即 invoke 方法,而 ObjProxyHandler 又持有着 RealObject 实例,所以 ObjProxyHandler 是“真正”对 RealObject 对象进行访问控制的代理类。


public class ObjProxyHandler implements InvocationHandler {
IObject realT;

public ObjProxyHandler(IObject t) {
realT = t;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// request方法时,进行校验
if (method.getName().equals("request") && !isAllow())
return null;
return method.invoke(realT, args);
}

private boolean isAllow() {
return false;
}
}
复制代码

RealObj是实际处理request() 逻辑的对象。


public class RealObject implements IObject {
@Override
public void request() {
// 模拟一些操作
}
}
复制代码

动态代理的使用方法如下:我们通过 Proxy.newProxyInstance 静态方法来创建代理,其参数如下,一个类加载器、一个代理实现的接口列表、一个 InvocationHandler 的接口实现。


    public void startTest() {
IObject proxy = (IObject) Proxy.newProxyInstance(
IObject.class.getClassLoader(),
new Class[]{IObject.class},
new ObjProxyHandler(new RealObject()));
proxy.request(); // ObjProxyHandler的invoke方法会被调用
}
复制代码

Proxy源码


来看下Proxy 源码,当我们 newProxyInstance(...) 时,首先系统会进行判空处理,之后获取我们实际的 Proxy 代理类 Class 对象,再通过一个参数的构造方法生成我们的代理对象 p(p : 返回值),这里能看出来 p 是持有我们的对象 h 的。注意 cons.setAccessible(true) 表示,即使是 cl 是私有构造,也可以获得对象。源码见下:


public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);

final Class<?>[] intfs = interfaces.clone();

/*
* Look up or generate the designated proxy class.
*/
Class<?> cl = getProxyClass0(loader, intfs);
...
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
cons.setAccessible(true);
// END Android-removed: Excluded AccessController.doPrivileged call.
}
return cons.newInstance(new Object[]{h});
...
}
复制代码

其中 getProxyClass0(...) 是用来检查并获取实际代理对象的。首先会有一个65535的接口限制检测,随后从代理缓存proxyClassCache 中获取代理类,如果给定的接口不存在,则通过 ProxyClassFactory 新建。见下:


    private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}

// If the proxy class defined by the given loader implementing
// the given interfaces exists, this will simply return the cached copy;
// otherwise, it will create the proxy class via the ProxyClassFactory
return proxyClassCache.get(loader, interfaces);
}
复制代码

存放代理 Proxy.class 的缓存 proxyClassCache,是一个静态常量,所以在我们类加载时,其就已经被初始化完毕了。见下:


private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
复制代码

Proxy 提供的 getInvocationHandler(Object proxy)方法和 invoke(...) 方法很重要。分别为获取当前代理关联的调用处理器对象 InvocationHandler,并将当前Proxy方法调用 调度给 InvocationHandler。是不是与上面的代理思维很像,至于这两个方法何时被调用的,推测是写在了本地方法内,当我们调用proxy.request 方法时(系统创建Proxy时,会自动 implements 用户传递的接口,可以为多个),系统就会调用Proxy invoke 方法,随后proxy 将方法调用传递给 InvocationHandler。


public static InvocationHandler getInvocationHandler(Object proxy)
throws IllegalArgumentException
{
/*
* Verify that the object is actually a proxy instance.
*/
if (!isProxyClass(proxy.getClass())) {
throw new IllegalArgumentException("not a proxy instance");
}
final Proxy p = (Proxy) proxy;
final InvocationHandler ih = p.h;

return ih;
}

// Android-added: Helper method invoke(Proxy, Method, Object[]) for ART native code.
private static Object invoke(Proxy proxy, Method method, Object[] args) throws Throwable {
InvocationHandler h = proxy.h;
return h.invoke(proxy, method, args);
}
复制代码

ProxyClassFactory


重点是ProxyClassFactory 类,这里的逻辑不少,所以我将ProxyClassFactory 单独抽出来了。能看到,首先其会检测当前interface 是否已被当前类加载器所加载。


        Class<?> interfaceClass = null;
try {
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
复制代码

之后会进行判断是否为接口。这也是我们说的第二个参数为何不能传基类或抽象类的原因。


        if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
复制代码

之后判断当前 interface 是否已经存在于缓存cache内了。


        if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
复制代码

检测非 public 修饰符的 interface 是否在是同一个包名,如果不是则抛出异常


    for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) {
accessFlags = Modifier.FINAL;
String name = intf.getName();
int n = name.lastIndexOf('.');
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxyPkg == null) {
proxyPkg = pkg;
} else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException(
"non-public interfaces from different packages");
}
...

复制代码

检验通过后,会 getMethods(...) 获取接口内的全部方法。


随后会对methords进行一个排序。具体的代码我就不贴了,排序规则是:如果方法相等(返回值和方法签名一样)或同是一个接口内方法,则当前顺序不变,如果两个方法所在的接口存在继承关系,则父类在前,子类在后。


之后 validateReturnTypes(...) 判断 methords 是否存在方法签名相同并且返回值类型也相同的methord,如果有则抛出异常。


之后通过 deduplicateAndGetExceptions(...) 方法,将 methords 方法内的相同方法的父类方法剔除掉,并将 methord 保存在数组中。


转成一维数组和二维数组,Method[] methodsArray,Class< ? >[][] exceptionsArray,随后给当前代理类命名:包名 + “$Proxy” + num


最后调用系统提供的 native 方法 generateProxy(...) 。这是真正的代理类创建方法。感兴趣的可以查看下java_lang_reflect_Proxy.cc源码
class_linker.cc源码


        List<Method> methods = getMethods(interfaces);
Collections.sort(methods, ORDER_BY_SIGNATURE_AND_SUBTYPE);
validateReturnTypes(methods);
List<Class<?>[]> exceptions = deduplicateAndGetExceptions(methods);

Method[] methodsArray = methods.toArray(new Method[methods.size()]);
Class<?>[][] exceptionsArray = exceptions.toArray(new Class<?>[exceptions.size()][]);

/*
* Choose a name for the proxy class to generate.
*/
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;

return generateProxy(proxyName, interfaces, loader, methodsArray,
exceptionsArray);
复制代码


好了,本文到这里就结束了,关于动态代理的讲解也应该够用了。如果本文对你有用,来点个赞吧,大家的肯定也是阿呆i坚持写作的动力。



参考
1、Head First 设计模式:中国电力出版社


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

研究Android音视频-2-MediaCodec使用:YUV码流编码位MP4的示例

本文解决的问题 查看编解码器 录制YUV文件 将YUV文件编码为MP4视频格式 官方的示意图 数据流 input:给解码器输入需要解码或需要编码的数据流 output:解码器输出解码好或编码好的数据给客户端 MediaCodec内部采用异步的方式处理数...
继续阅读 »

本文解决的问题



  1. 查看编解码器

  2. 录制YUV文件

  3. 将YUV文件编码为MP4视频格式


官方的示意图


数据流


input:给解码器输入需要解码或需要编码的数据流


output:解码器输出解码好或编码好的数据给客户端



MediaCodec内部采用异步的方式处理数据,将处理好的数据写入缓冲区,客户端从缓冲区取数据使用,使用后必须手动释放缓冲区,否则无法继续处理数据



状态



  • Stopped

    • Error

    • Uninitialized:新建MediaCodec后,会进入该状态

    • Configured:调用configured方法后,进入该状态



  • Executing

    • Flushed:调用start方法后,进入该状态

    • Running:调用dequeueInputBuffer方法后,进入该状态

    • End of Stream



  • Released


功能描述


打印设备支持的编解码选项


val mediaCodecList = MediaCodecList(MediaCodecList.REGULAR_CODECS)//创建查看设备可以使用的编解码器
val mediaCodecList = MediaCodecList(MediaCodecList.ALL_CODECS)//创建查看所有编解码器

fun printCodecInfo() {
val mediaCodecList = MediaCodecList(MediaCodecList.REGULAR_CODECS)//创建查看设备可以使用的编解码器
val codecInfos = mediaCodecList.codecInfos
codecInfos.forEach { codecInfo ->
if (codecInfo.isEncoder)
println(
"encoder name: ${codecInfo.name} \n" +
" canonicalName: ${codecInfo.canonicalName} \n" +
" isAlias: ${codecInfo.isAlias} \n" +
" isSoftwareOnly: ${codecInfo.isSoftwareOnly} \n" +
" supportedTypes: ${
codecInfo.supportedTypes.map {
println("encoder: $it")
}
} \n" +
" isVendor: ${codecInfo.isVendor} \n" +
" isHardwareAccelerated: ${codecInfo.isHardwareAccelerated}" +
""
)
}

codecInfos.forEach { codecInfo ->
if (!codecInfo.isEncoder)
println(
"decoder name: ${codecInfo.name} \n" +
" canonicalName: ${codecInfo.canonicalName} \n" +
" isAlias: ${codecInfo.isAlias} \n" +
" isSoftwareOnly: ${codecInfo.isSoftwareOnly} \n" +
" supportedTypes: ${
codecInfo.supportedTypes.map {
println("decoder: $it")
}
} \n" +
" isVendor: ${codecInfo.isVendor} \n" +
" isHardwareAccelerated: ${codecInfo.isHardwareAccelerated}" +
""
)
}
}

/*
打印示例
"video/avc":H.264硬件编码器
encoder name: OMX.qcom.video.encoder.avc
canonicalName: OMX.qcom.video.encoder.avc
isAlias: false
isSoftwareOnly: false
supportedTypes: [kotlin.Unit]
isVendor: true
isHardwareAccelerated: true
"video/hevc":H.265软解编码器
encoder name: c2.android.hevc.encoder
canonicalName: c2.android.hevc.encoder
isAlias: false
isSoftwareOnly: true
supportedTypes: [kotlin.Unit]
isVendor: false
isHardwareAccelerated: false
*/

/*查找指定的编解码器*/
val codec = findCodec("video/avc", false, true)//查找H.264硬解码器
fun findCodec(
mimeType: String,
isEncoder: Boolean,
isHard: Boolean = true
): MediaCodecInfo? {
val mediaCodecList = MediaCodecList(MediaCodecList.REGULAR_CODECS)
val codecInfos = mediaCodecList.codecInfos
return codecInfos.find {
it.isEncoder == isEncoder && !it.isSoftwareOnly == isHard && hasThisCodec(
it,
mimeType
)
}
}
private fun hasThisCodec(codecInfo: MediaCodecInfo, mimeType: String): Boolean {
return codecInfo.supportedTypes.find { it.equals(mimeType) } != null
}
复制代码

录制yuv文件


打开Camera,通过回调流保存原始YUV数据。简单存几秒即可,1080p下存了225帧,存储占用1080*1920*225*3/2=667.4M字节


示例工程: 地址


示例代码:


 val fos = FileOutputStream("$filesDir/test.yuv")
cameraView = findViewById(R.id.cameraview)
cameraView.cameraParams.facing = Camera.CameraInfo.CAMERA_FACING_BACK
cameraView.cameraParams.isFilp = false
cameraView.cameraParams.isScaleWidth = true
cameraView.cameraParams.previewSize.previewWidth = 1920
cameraView.cameraParams.previewSize.previewHeight = 1080
cameraView.addPreviewFrameCallback(object : PreviewFrameCallback {
override fun analyseData(data: ByteArray): Any {
fos.write(data)
return 0
}

override fun analyseDataEnd(t: Any) {}
})
addLifecycleObserver(cameraView)
复制代码

YUV视频流编码为h.264码流并通过MediaMuxer保存为mp4文件


编码流程:



  1. 查询编码队列是否空闲

  2. 将需要编码的数据复制到编码队列

  3. 查询编码完成队列是否有完成的数据

  4. 将已编码完成的数据复制到cpu内存


单线程示例代码:


//TODO YUV视频流编码为H.264/H.265码流并通过MediaMuxer保存为mp4文件
fun convertYuv2Mp4(context: Context) {
val yuvPath = "${context.filesDir}/test.yuv"
val saveMp4Path = "${context.filesDir}/test.mp4"
File(saveMp4Path).deleteOnExit()

val mime = "video/avc" //若设备支持H.265也可以使用'video/hevc'编码器
val format = MediaFormat.createVideoFormat(mime, 1920, 1080)
format.setInteger(
MediaFormat.KEY_COLOR_FORMAT,
MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Flexible
)
//width*height*frameRate*[0.1-0.2]码率控制清晰度
format.setInteger(MediaFormat.KEY_BIT_RATE, 1920 * 1080 * 3)
format.setInteger(MediaFormat.KEY_FRAME_RATE, 30)
//每秒出一个关键帧,设置0为每帧都是关键帧
format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1)
format.setInteger(
MediaFormat.KEY_BITRATE_MODE,
MediaCodecInfo.EncoderCapabilities.BITRATE_MODE_CBR//遵守用户设置的码率
)

//定义并启动编码器
val videoEncoder = MediaCodec.createEncoderByType(mime)
videoEncoder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
videoEncoder.start()

// 当前编码帧信息
val bufferInfo = MediaCodec.BufferInfo()

//定义混合器:输出并保存h.264码流为mp4
val mediaMuxer =
MediaMuxer(
"${context.filesDir}/test.mp4",
MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4
);
var muxerTrackIndex = -1
val byteArray = ByteArray(1920 * 1080 * 3 / 2)
var read = 0
var inputEnd = false//数据读取完毕,并且全部都加载至编码器
var pushEnd = false //数据读取完毕,并且成功发出eof信号
val presentTimeUs = System.nanoTime() / 1000


//从文件中读取yuv码流,模拟输入流
FileInputStream("${context.filesDir}/test.yuv").use { fis ->
loop1@ while (true) {
//step1 将需要编码的数据逐帧送往编码器
if (!inputEnd) {
//step1.1 查询编码器队列是否空闲
val inputQueueIndex = videoEncoder.dequeueInputBuffer(30);
if (inputQueueIndex > 0) {
read = fis.read(byteArray)
if (read == byteArray.size) {
//默认从Camera中保存的YUV NV21,编码后颜色成反,手动转为NV12后,颜色正常
val convertCost = measureTimeMillis {
val start = 1920 * 1080
val end = 1920 * 1080 / 4 - 1
for (i in 0..end) {
val temp = byteArray[2 * i + start]
byteArray[2 * i + start] = byteArray[2 * i + start + 1]
byteArray[2 * i + start + 1] = temp
}
}
//step1.2 将数据送往编码器,presentationTimeUs为送往编码器的跟起始值的时间差,单位为微妙
val inputBuffer =
videoEncoder.getInputBuffer(inputQueueIndex)
inputBuffer?.clear()
inputBuffer?.put(byteArray)
videoEncoder.queueInputBuffer(
inputQueueIndex,
0,
byteArray.size,
System.nanoTime() / 1000 - presentTimeUs,
0
)
} else {
inputEnd = true//文件读取结束标记
}
}
}

//step2 将结束标记传给编码器
if (inputEnd && !pushEnd) {
val inputQueueIndex = videoEncoder.dequeueInputBuffer(30);
if (inputQueueIndex > 0) {
val pts: Long = System.nanoTime() / 1000 - presentTimeUs
videoEncoder.queueInputBuffer(
inputQueueIndex,
0,
byteArray.size,
pts,
MediaCodec.BUFFER_FLAG_END_OF_STREAM
)
pushEnd = true
println("数据输入完成,成功发出eof信号")
}
}

//step3 从编码器中取数据,不及时取出,缓冲队列被占用,编码器将阻塞不进行编码工作
val outputQueueIndex = videoEncoder.dequeueOutputBuffer(bufferInfo, 30)
when (outputQueueIndex) {
MediaCodec.INFO_OUTPUT_FORMAT_CHANGED -> {
//step3.1 标记新的解码数据到来,在此添加视频轨道到混合器
muxerTrackIndex = mediaMuxer.addTrack(videoEncoder.outputFormat)
mediaMuxer.start()
}
MediaCodec.INFO_TRY_AGAIN_LATER -> {
}
else -> {
when (bufferInfo.flags) {
MediaCodec.BUFFER_FLAG_CODEC_CONFIG -> {
// SPS or PPS, which should be passed by MediaFormat.
}
MediaCodec.BUFFER_FLAG_END_OF_STREAM -> {
bufferInfo.set(0, 0, 0, bufferInfo.flags)
videoEncoder.releaseOutputBuffer(outputQueueIndex, false)
println("数据解码并获取完成,成功发出eof信号")
break@loop1
}
else -> {
mediaMuxer.writeSampleData(
muxerTrackIndex,
videoEncoder.getOutputBuffer(outputQueueIndex)!!,
bufferInfo
)
}
}
videoEncoder.releaseOutputBuffer(outputQueueIndex, false)
}
}
}

//释放应该释放的具柄
mediaMuxer.release()
videoEncoder.stop()
videoEncoder.release()
}
}
复制代码


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

Android选择图片库-TakePhoto

TakePhoto是一款用于在Android设备上获取照片(拍照或从相册、文件中选择)、裁剪图片、压缩图片的开源工具库,目前最新版本4.1.0。 3.0以下版本及API说明,详见TakePhoto2.0+。TakePhoto交流平台:QQ群:556387607...
继续阅读 »

TakePhoto是一款用于在Android设备上获取照片(拍照或从相册、文件中选择)、裁剪图片、压缩图片的开源工具库,目前最新版本4.1.0。 3.0以下版本及API说明,详见TakePhoto2.0+

TakePhoto交流平台:QQ群:556387607(群1,未满)

V4.0

  • 支持通过相机拍照获取图片
  • 支持从相册选择图片
  • 支持从文件选择图片
  • 支持批量图片选取
  • 支持图片压缩以及批量图片压缩
  • 支持图片裁切以及批量图片裁切
  • 支持照片旋转角度自动纠正
  • 支持自动权限管理(无需关心SD卡及摄像头权限等问题)
  • 支持对裁剪及压缩参数个性化配置
  • 提供自带裁剪工具(可选)
  • 支持智能选取及裁剪异常处理
  • 支持因拍照Activity被回收后的自动恢复
  • 支持Android8.1
  • +支持多种压缩工具
  • +支持多种图片选择工具

目录

安装说明

Gradle:

    compile 'com.jph.takephoto:takephoto_library:4.1.0'

Maven:

<dependency>
<groupId>com.jph.takephoto</groupId>
<artifactId>takephoto_library</artifactId>
<version>4.1.0</version>
<type>pom</type>
</dependency>

使用说明

使用TakePhoto有以下两种方式:

方式一:通过继承的方式

  1. 继承TakePhotoActivityTakePhotoFragmentActivityTakePhotoFragment三者之一。
  2. 通过getTakePhoto()获取TakePhoto实例进行相关操作。
  3. 重写以下方法获取结果
 void takeSuccess(TResult result);
void takeFail(TResult result,String msg);
void takeCancel();

此方式使用简单,满足的大部分的使用需求,具体使用详见simple。如果通过继承的方式无法满足实际项目的使用,可以通过下面介绍的方式。

方式二:通过组装的方式

可参照:TakePhotoActivity,以下为主要步骤:

1.实现TakePhoto.TakeResultListener,InvokeListener接口。

2.在 onCreate,onActivityResult,onSaveInstanceState方法中调用TakePhoto对用的方法。

3.重写onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults),添加如下代码。

  @Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
//以下代码为处理Android6.0、7.0动态权限所需
TPermissionType type=PermissionManager.onRequestPermissionsResult(requestCode,permissions,grantResults);
PermissionManager.handlePermissionsResult(this,type,invokeParam,this);
}

4.重写TPermissionType invoke(InvokeParam invokeParam)方法,添加如下代码:

 @Override
public TPermissionType invoke(InvokeParam invokeParam) {
TPermissionType type=PermissionManager.checkPermission(TContextWrap.of(this),invokeParam.getMethod());
if(TPermissionType.WAIT.equals(type)){
this.invokeParam=invokeParam;
}
return type;
}

5.添加如下代码获取TakePhoto实例:

   /**
* 获取TakePhoto实例
* @return
*/
public TakePhoto getTakePhoto(){
if (takePhoto==null){
takePhoto= (TakePhoto) TakePhotoInvocationHandler.of(this).bind(new TakePhotoImpl(this,this));
}
return takePhoto;
}

自定义UI

TakePhoto不仅支持对相关参数的自定义,也支持对UI的自定义,下面就像大家介绍如何自定义TakePhoto的相册与裁剪工具的UI。

自定义相册

如果TakePhoto自带相册的UI不符合你应用的主题的话,你可以对它进行自定义。方法如下:

自定义Toolbar

在“res/layout”目录中创建一个名为“toolbar.xml”的布局文件,内容如下:

<?xml version="1.0" encoding="utf-8"?>
<android.support.v7.widget.Toolbar xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="?attr/actionBarSize"
app:theme="@style/CustomToolbarTheme"
android:background="#ffa352">
</android.support.v7.widget.Toolbar>

在“toolbar.xml”文件中你可以指定TakePhoto自带相册的主题以及Toolbar的背景色。

自定义状态栏

在“res/values”目录中创建一个名为“colors.xml”的资源文件,内容如下:

<?xml version="1.0" encoding="utf-8"?>
<resources>
<color name="multiple_image_select_primaryDark">#212121</color>
</resources>

通过上述方式便可以自定义状态栏的颜色。

自定义提示文字

在“res/values”目录的“string.xml”文件冲添加如下代码:

<resources>    
<string name="album_view">选择图片</string>
<string name="image_view">单击选择</string>
<string name="add">确定</string>
<string name="selected">已选</string>
<string name="limit_exceeded">最多能选 %d 张</string>
</resources>

重写上述代码,便可以自定义TakePhoto自带相册的提示文字。

自定义裁切工具

在“res/layout”目录中创建一个名为“crop__activity_crop.xml”与“crop__layout_done_cancel.xml”的布局文件,内容如下:

crop__activity_crop.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent">
<com.soundcloud.android.crop.CropImageView
android:id="@+id/crop_image"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:layout_alignParentTop="true"
android:background="@drawable/crop__texture"
android:layout_above="@+id/done_cancel_bar" />
<include
android:id="@+id/done_cancel_bar"
android:layout_alignParentBottom="true"
layout="@layout/crop__layout_done_cancel"
android:layout_height="50dp"
android:layout_width="match_parent" />
</RelativeLayout>

crop__layout_done_cancel.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
style="@style/Crop.DoneCancelBar">
<FrameLayout
android:id="@+id/btn_cancel"
style="@style/Crop.ActionButton">
<TextView style="@style/Crop.ActionButtonText.Cancel" />
</FrameLayout>
<FrameLayout
android:id="@+id/btn_done"
style="@style/Crop.ActionButton">
<TextView style="@style/Crop.ActionButtonText.Done" />
</FrameLayout>
</LinearLayout>

重写上述代码,便可以自定义TakePhoto裁切工具的UI。

API

获取图片

TakePhoto提供拍照,从相册选择,从文件中选择三种方式获取图片。

API:

/**
* 从文件中获取图片(不裁剪)
*/
void onPickFromDocuments();
/**
* 从相册中获取图片(不裁剪)
*/
void onPickFromGallery();
/**
* 从相机获取图片(不裁剪)
* @param outPutUri 图片保存的路径
*/
void onPickFromCapture(Uri outPutUri);
/**
* 图片多选
* @param limit 最多选择图片张数的限制
**/
void onPickMultiple(int limit);

以上三种方式均提供对应的裁剪API,详见:裁剪图片
注:
由于不同Android Rom厂商对系统有不同程度的定制,有可能导致某种选择图片的方式不支持,所以为了提高TakePhoto的兼容性,当某种选的图片的方式不支持时,TakePhoto会自动切换成使用另一种选择图片的方式进行图片选择。

裁剪图片

API

TakePhoto支持对图片进行裁剪,无论是拍照的照片,还是从相册、文件中选择的图片。你只需要调用TakePhoto的相应方法即可:

/**
* 从相机获取图片并裁剪
* @param outPutUri 图片裁剪之后保存的路径
* @param options 裁剪配置
*/
void onPickFromCaptureWithCrop(Uri outPutUri, CropOptions options);
/**
* 从相册中获取图片并裁剪
* @param outPutUri 图片裁剪之后保存的路径
* @param options 裁剪配置
*/
void onPickFromGalleryWithCrop(Uri outPutUri, CropOptions options);
/**
* 从文件中获取图片并裁剪
* @param outPutUri 图片裁剪之后保存的路径
* @param options 裁剪配置
*/
void onPickFromDocumentsWithCrop(Uri outPutUri, CropOptions options);
/**
* 图片多选,并裁切
* @param limit 最多选择图片张数的限制
* @param options 裁剪配置
* */
void onPickMultipleWithCrop(int limit, CropOptions options);

对指定图片进行裁剪

另外,TakePhoto也支持你对指定图片进行裁剪:

/**
* 裁剪图片
* @param imageUri 要裁剪的图片
* @param outPutUri 图片裁剪之后保存的路径
* @param options 裁剪配置
*/
void onCrop(Uri imageUri, Uri outPutUri, CropOptions options)throws TException;
/**
* 裁剪多张图片
* @param multipleCrop 要裁切的图片的路径以及输出路径
* @param options 裁剪配置
*/
void onCrop(MultipleCrop multipleCrop, CropOptions options)throws TException;

CropOptions

CropOptions是用于裁剪的配置类,通过它你可以对图片的裁剪比例,最大输出大小,以及是否使用TakePhoto自带的裁剪工具进行裁剪等,进行个性化配置。

Usage:

 CropOptions cropOptions=new CropOptions.Builder().setAspectX(1).setAspectY(1).setWithOwnCrop(true).create();  
getTakePhoto().onPickFromDocumentsWithCrop(imageUri,cropOptions);
//
getTakePhoto().onCrop(imageUri,outPutUri,cropOptions);

注:
由于不同Android Rom厂商对系统有不同程度的定制,有可能系统中没有自带或第三方的裁剪工具,所以为了提高TakePhoto的兼容性,当系统中没有自带或第三方裁剪工具时,TakePhoto会自动切换到使用TakePhoto自带的裁剪工具进行裁剪。

另外TakePhoto4.0+支持指定使用TakePhoto自带相册,如:takePhoto.setTakePhotoOptions(new TakePhotoOptions.Builder().setWithOwnGallery(true).create()); 详情可参考:Demo

压缩图片

你可以选择是否对图片进行压缩处理,你只需要告诉它你是否要启用压缩功能以及CompressConfig即可。

API

 /**
* 启用图片压缩
* @param config 压缩图片配置
* @param showCompressDialog 压缩时是否显示进度对话框
* @return
*/
void onEnableCompress(CompressConfig config,boolean showCompressDialog);

Usage:

TakePhoto takePhoto=getTakePhoto();
takePhoto.onEnableCompress(compressConfig,true);
takePhoto.onPickFromGallery();

如果你启用了图片压缩,TakePhoto会使用CompressImage对图片进行压缩处理,CompressImage目前支持对图片的尺寸以及图片的质量进行压缩。默认情况下,CompressImage开启了尺寸与质量双重压缩。

对指定图片进行压缩

另外,你也可以对指定图片进行压缩:
Usage:

new CompressImageImpl(compressConfig,result.getImages(), new CompressImage.CompressListener() {
@Override
public void onCompressSuccess(ArrayList<TImage> images) {
//图片压缩成功
}
@Override
public void onCompressFailed(ArrayList<TImage> images, String msg) {
//图片压缩失败
}
}).compress();

CompressConfig

CompressConfig是用于图片压缩的配置类,你可以通过CompressConfig.Builder对图片压缩后的尺寸以及质量进行相关设置。如果你想改变压缩的方式可以通过CompressConfig.Builder进行相关设置。
Usage:

CompressConfig compressConfig=new CompressConfig.Builder().setMaxSize(50*1024).setMaxPixel(800).create();

指定压缩工具

使用TakePhoto压缩工具进行压缩:

CompressConfig config=new CompressConfig.Builder()
.setMaxSize(maxSize)
.setMaxPixel(width>=height? width:height)
.create();
takePhoto.onEnableCompress(config,showProgressBar);

使用Luban进行压缩:

LubanOptions option=new LubanOptions.Builder()
.setGear(Luban.CUSTOM_GEAR)
.setMaxHeight(height)
.setMaxWidth(width)
.setMaxSize(maxSize)
.create();
CompressConfig config=CompressConfig.ofLuban(option);
takePhoto.onEnableCompress(config,showProgressBar);

详情可参考Demo:CustomHelper.java


原文链接:https://github.com/crazycodeboy/TakePhoto

代码下载:TakePhoto-master.zip

收起阅读 »

iOS-数据结构初探

数据结构的分类数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成 简单来说:数据结构是以某种特定的布局方式存储数据的容器。这种“布局方式”决定了数据结构对于某些操作是高效的,而对于其他操作则是低效的。首先我们需要理解各种数...
继续阅读 »

数据结构的分类

数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成

简单来说:数据结构是以某种特定的布局方式存储数据的容器。这种“布局方式”决定了数据结构对于某些操作是高效的,而对于其他操作则是低效的。首先我们需要理解各种数据结构,才能在处理实际问题时选取最合适的数据结构。

常用的数据结构有:数组,栈,链表,队列,树,图,堆,散列表等

1、数组

数组是可以再内存中连续存储多个元素的结构,在内存中的分配也是连续的,数组中的元素通过数组下标进行访问,数组下标从0开始

NSArray *array = [NSArray arrayWithObjects:@"1",@"2",@"3",@"4", nil];
// NSArray *array = @[@"1",@"2",@"3",@"4"];
NSLog(@"%@",array[0]);

优点:

  • 1、按照索引查询元素速度快
  • 2、按照索引遍历数组方便

缺点:

  • 1、数组的大小固定后就无法扩容了
  • 2、数组只能存储一种类型的数据
  • 3、添加,删除的操作慢,因为要移动其他的元素。

适用场景:

  • 频繁查询,对存储空间要求不大,很少增加和删除的情况。

2、栈

栈是一种特殊的线性表,仅能在线性表的一端操作,栈顶允许操作,栈底不允许操作。栈的特点是:先进后出,或者说是后进先出,从栈顶放入元素的操作叫入栈,取出元素叫出栈

线性表是最基本、最简单、也是最常用的一种数据结构。线性表(linear list)是数据结构的一种,一个线性表是n个具有相同特性的数据元素的有限序列。

线性表中数据元素之间的关系是一对一的关系,即除了第一个和最后一个数据元素之外,其它数据元素都是首尾相接的(注意,这句话只适用大部分线性表,而不是全部。比如,循环链表逻辑层次上也是一种线性表(存储层次上属于链式存储),但是把最后一个数据元素的尾指针指向了首位结点)

3、队列

队列与栈一样,也是一种线性表,不同的是,队列可以在一端添加元素,在另一端取出元素,也就是:先进先出。从一端放入元素的操作称为入队,取出元素为出队


4、链表

链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构,操作复杂。由于不必须按顺序存储,链表在插入的时候可以达到O(1)的复杂度,比另一种线性表顺序表快得多,但是查找一个节点或者访问特定编号的节点则需要O(n)的时间,而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。

根据指针的指向,链表能形成不同的结构,例如单链表双向链表循环链表等。




双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。


链表的优点:

  • 链表是很常用的一种数据结构,不需要初始化容量,可以任意加减元素;
  • 添加或者删除元素时只需要改变前后两个元素结点的指针域指向地址即可,所以添加,删除很快;

缺点:

  • 因为含有大量的指针域,占用空间较大;
  • 查找元素需要遍历链表来查找,非常耗时。

适用场景:

  • 数据量较小,需要频繁增加,删除操作的场景

5、树

树是一种数据结构,它是由n(n>=1)个有限节点组成一个具有层次关系的集合。把它叫做 “树” 是因为它看起来像一棵倒挂的树,也就是说它是根朝上,而叶朝下的。它具有以下的特点:

  • 每个节点有零个或多个子节点;
  • 没有父节点的节点称为根节点;
  • 每一个非根节点有且只有一个父节点
  • 除了根节点外,每个子节点可以分为多个不相交的子树;

在日常的应用中,我们讨论和用的更多的是树的其中一种结构,就是二叉树


二叉树是树的特殊一种,具有如下特点:

  • 1、每个结点最多有两颗子树,结点的度最大为2。
  • 2、左子树和右子树是有顺序的,次序不能颠倒。
  • 3、即使某结点只有一个子树,也要区分左右子树。

二叉树是一种比较有用的折中方案,它添加,删除元素都很快,并且在查找方面也有很多的算法优化,所以,二叉树既有链表的好处,也有数组的好处,是两者的优化方案,在处理大批量的动态数据方面非常有用。

二叉树有很多扩展的数据结构,包括平衡二叉树红黑树B+树等,这些数据结构二叉树的基础上衍生了很多的功能,在实际应用中广泛用到,例如mysql的数据库索引结构用的就是B+树,还有HashMap的底层源码中用到了红黑树。这些二叉树的功能强大,但算法上比较复杂,想学习的话还是需要花时间去深入的。

6、散列表

散列表,也叫哈希表,是根据关键码值 (key和value) 直接进行访问的数据结构,通过keyvalue来映射到集合中的一个位置,这样就可以很快找到集合中的对应元素。

记录的存储位置=f(key)

  • 这里的对应关系f 成为散列函数,又称为哈希 (hash函数),而散列表就是把Key通过一个固定的算法函数既所谓的哈希函数转换成一个整型数字
  • 然后就将该数字对数组长度进行取余,取余结果就当作数组的下标
  • 将value存储在以该数字为下标的数组空间里
  • 这种存储空间可以充分利用数组的查找优势来查找元素,所以查找的速度很快。

哈希表在应用中也是比较常见的,就如Java中有些集合类就是借鉴了哈希原理构造的,例如HashMapHashTable等,利用hash表的优势,,对于集合的查找元素时非常方便的,然而,因为哈希表是基于数组衍生的数据结构,在添加删除元素方面是比较慢的,所以很多时候需要用到一种数组链表来做,也就是拉链法。拉链法是数组结合链表的一种结构,较早前的hashMap底层的存储就是采用这种结构,直到jdk1.8之后才换成了数组加红黑树的结构.iOSweak表(弱引用表)就是典型的哈希表


  • 左边很明显是个数组,数组的每个成员包括一个指针,指向一个链表的头,
  • 当然这个链表可能为空,也可能元素很多。
  • 我们根据元素的一些特征把元素分配到不同的链表中去,
  • 也是根据这些特征,找到正确的链表,再从链表中找出这个元素。
哈希表的应用场景很多,当然也有很多问题要考虑,比如哈希冲突的问题,如果处理的不好会浪费大量的时间,导致应用崩溃。

7、堆

堆是一种比较特殊的数据结构,可以被看做一棵树的数组对象,具有以下的性质:

  • 堆中某个节点的值总是不大于或不小于其父节点的值;
  • 堆总是一棵完全二叉树。

将根节点最大的堆叫做最大堆或大根堆,根节点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆斐波那契堆等。



堆的定义如下:n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时,称之为堆。

(ki <= k2i,ki <= k2i+1)或者(ki >= k2i,ki >= k2i+1), (i = 1,2,3,4…n/2),
满足前者的表达式的成为小顶堆,满足后者表达式的为大顶堆,这两者的结构图可以用完全二叉树排列出来

8、图

图型结构也称图案,指个体目标重复排列的空间形式。图案反映了地物的空间分布特征,它可以是自然的,也可以是人为构造的 [1] 图形结构,简称“图”,是一种复杂的数据结构。图形结构中,每个结点的前驱结点数和后续结点数可以任意多个。


数据元素间的关系是任意的。其他数据结构(如树、线性表等)都有明确的条件限制,而图形结构中任意两个数据元素间均可相关联。常用来研究生产流程、施工计划、各种网络建设等问题。


转自:https://www.jianshu.com/p/4013774d929d
收起阅读 »

面试之链表

前言这一篇博客是很早之前写的,是关于一些链表和二叉树面试相关的问题,算是整理吧,网上这部分的答案也很多,希望能给大家一些帮助。注意:本文中一些异常情况都是没有做处理的,例如NULL等等,只是给出了基本的解决方案.大家参考一下.链表部分问题:定义并且创建一个链表...
继续阅读 »

前言
这一篇博客是很早之前写的,是关于一些链表和二叉树面试相关的问题,算是整理吧,网上这部分的答案也很多,希望能给大家一些帮助。
注意:本文中一些异常情况都是没有做处理的,例如NULL等等,只是给出了基本的解决方案.大家参考一下.

链表部分
问题:定义并且创建一个链表.
解题方案:
我们首先要如何定义一个结构体,下面的构造方案我是使用的递归的形式来构造一个结构体,注意不要忘记分配内存.其他的方面都比较简单,难度较低.
代码示例:

#include <stdio.h>

typedef struct ListNode {
int data;
struct ListNode*nextNode;
}ListNode;

ListNode* createListNodeAction(int *listArray, int index, int length) {
ListNode *listNode = (ListNode *) malloc(sizeof (ListNode) );
ListNode *nextNode = NULL;
int i = listArray[index];
listNode->data = i;
if (index != length - 1) {
nextNode = (ListNode*) malloc(sizeof (ListNode));
nextNode = createListNodeAction(listArray, index + 1, length);
}
listNode->nextNode = nextNode;
return listNode;
}

问题:不通过遍历删除链表中的非尾节点.

解题方案:
首先我们要知道我们如何通过遍历删除链表中的某个节点? 通过遍历我们可以知道要删除的链表节点前驱(也就是前一个节点),然后我们把前驱的nextNode指向要删除的节点的nextNode,释放要删除的节点即可.示意图如下所示.


那么我们对于上面的那个题目,我们该如何解决呢?由于前驱不通过遍历我们是拿不到的,所以我们只能通过覆盖的形式,用nextNode节点的属性覆盖掉需要删除的节点,然后释放nextNode节点,这样就完成了删除工作,由于前驱的nextNode指针属性不通过遍历修改不了,所以不能删除尾节点.否则就会有野指针问题出现.

void deleteListNodeNotTail(ListNode *deleteNode) {

ListNode *deleteNextNode = deleteNode->nextNode;
deleteNode->data = deleteNextNode->data;
deleteNode->nextNode = deleteNextNode->nextNode;
free(deleteNextNode);
}

问题:只遍历一次就找到链表中的中间节点.

解题方案:
撇开题目不谈,我们首先要清楚如何确定链表中的中间节点?由于链表没有长度的属性,所以暴力法的做法就是先遍历一次确定链表的长度,然后再次遍历链表找到中间节点.时间复杂度为O(logn+n).
那么如何通过一次遍历来找到链表中的中间节点呢?我们的解决方案是我们需要一快一慢两个移动节点fathNode和slowNode,fathNode的偏移速度是slowNode的两倍,,所以当fathNode == NULL,slowNode正好处于中心节点上.时间复杂度为O(logn).
代码示例:

ListNode* getListHalfNode(ListNode *listNode) {

ListNode *fathNode = listNode->nextNode;
ListNode *slowNode = listNode;

while (fathNode) {
fathNode = fathNode->nextNode->nextNode;
slowNode = slowNode->nextNode;
}
return slowNode;
}

问题:如何找到单向链表中的倒数第i个节点(i >= 1).

解题方案:
暴力法该如何解决这种问题呢?我们先遍历一遍确定链表的长度length,再次遍历链表取得下标位置在length-1-k的节点就是我们要的节点.时间复杂度为O(logn+n).
那没有有没有优化方式呢?这是有的,仍然借助上一个问题的解决方案,我们需要一快一慢两个移动节点fathNode和slowNode,fathNode先偏移i个位置,然后两个节点同时进行移动,所以当fathNode == NULL,slowNode正好处于倒数.时间复杂度为O(2logn).
代码示例:

ListNode* getListNodeWithLast(ListNode *listNode,int i) {

ListNode *fathNode = listNode;
ListNode *slowNode = listNode;

while (i) {
fathNode = fathNode->nextNode;
i--;
}

while (fathNode) {
fathNode = fathNode->nextNode;
slowNode = slowNode->nextNode;
}
return slowNode;
}

问题:删除倒数第i个结点(i>=1),不能用替换删除法.

解题方案:
上面我们已经了解了替换删除法,不需要知道前驱,我们就可以使用覆盖替换的方式删除节点,而这次我们可以是知道前驱节点的,而且结合上一次的快慢节点的方式,我们只需要先找到前驱节点即可.也就是fathNode节点需要先移动i + 1 次,具体代码如下所示.
代码示例:

void deleteListNodeWithLast(ListNode *listNode,int i) {

ListNode *fathNode = listNode;
ListNode *slowNode = listNode;

while (i + 1) {
fathNode = fathNode->nextNode;
i--;
}

while (fathNode) {
fathNode = fathNode->nextNode;
slowNode = slowNode->nextNode;
}

ListNode *deleteNode = slowNode->nextNode;
ListNode *deleteNextNode = deleteNode->nextNode;
slowNode->nextNode = deleteNextNode;
free(deleteNode);
}

问题:约瑟夫问题

约瑟夫环(约瑟夫问题)是一个数学的应用问题:已知n个人(以编号1,2,3…n分别表示)围坐在一张圆桌周围。从编号为k的人开始报数,数到m的那个人出列;他的下一个人又从1开始报数,数到m的那个人又出列;依此规律重复下去,直到圆桌周围的人全部出列。通常解决这类问题时我们把编号从0~n-1,最后结果+1即为原问题的解。
解题方案:
使用链表该如何解决约瑟夫问题呢?我们需要把链表做成一个环,也就是我们需要遍历一遍找到尾节点,并且制定尾节点的nextNode指针指向链表的第一个节点,这样我们就把链表做成了一个环.
然后我们假设每i次删除一个节点,这样返回的删除,直到只剩最后一个节点就是我们要求的解.
代码示例:

ListNode* JocephCircle(ListNode *firstNode, int k) {

ListNode *endNode = firstNode;
ListNode *resultNode = firstNode;
ListNode *deleteNode = NULL;

// 做环
while (endNode->nextNode) {
endNode = endNode->nextNode;
}
endNode->nextNode = firstNode;

// 自身的nextNode指向自身的时候,就只剩下一个元素了
while (resultNode->nextNode != resultNode) {

//删除节点 ,先找到前驱节点,然后找到删除节点
//由于先执行赋值操作,再进行i-1操作,所以k-1,由于是找删除节点的前驱节点,所以还需要-1.
int i = (k-1)-1;
while (i) {
resultNode = resultNode->nextNode;
i--;
}

// 重新指向并且释放删除节点
deleteNode = resultNode->nextNode;
resultNode->nextNode = resultNode->nextNode->nextNode;
free(deleteNode);
resultNode = resultNode->nextNode;
}

return resultNode;
}

问题:单链表的冒泡排序问题

解题方案:
仿照普通的数组遍历,这里两个while进行实现简单的冒泡排序.判断条件为nextNode节点是否为NULL,即可知道是否已经到达了单链表的尾节点.这个问题如果不做任何优化的话就如同下面代码演示的即可.其他优化方式就不过多阐述,上网查询即可.
代码示例:

void sortNodeListAction(ListNode *firstNode) {

ListNode *nowNode = firstNode;
ListNode *exchangeNode = (ListNode *)malloc(sizeof(ListNode));

while (nowNode->nextNode) {
ListNode *nowNextNode = nowNode;
while (nowNextNode) {
if (nowNextNode->data < nowNode->data) {
exchangeNode->data = nowNextNode->data;
nowNextNode->data = nowNode->data;
nowNode->data = exchangeNode->data;
}
nowNextNode = nowNextNode->nextNode;
if (!nowNextNode) {
continue;
}
}
nowNode = nowNode->nextNode;
}
free(exchangeNode);
}

问题:判断链表是否带环;若带环,求环的长度和入口点

解题方案:
这里我们要首先明白什么叫做带环,如下图所示,不管是哪种表现形式,我们都说当前链表是带环的链表.


我们了解了什么叫链表带环.在代码中,我们该如何判断当前的链表是否带环呢?网上有一种方案就是使用快慢节点解决,设置fathNode和slowNode,fathNode的偏移速度是slowNode的两倍,所以当fathNode == NULL,那么可以断定链表不带环,假设在某一个时刻fathNode==slowNode,说明两个节点重合,也就是说链表带环.
那么带环的链表我们该如何判断其环的长度呢?首先我们要知道fathNode偏移速度是slowNode的两倍,也就是说相同时间内,fathNode偏移距离是slowNode的2倍.
我们要说明两个节点交汇的情况,两者的情况肯定是慢节点在换上走不到一圈就会进行交汇,有人会问这是为什么呢?因为fathNode偏移速度是slowNode的两倍,所以在两者起点相同的情况下slowNode走完一圈fathNode走完两圈内,两者是必然相交的.
根据上面的两种情形,如下图所示.当两点相交时,我们有以下的结论,fathNode走过的路程为L + (C + A) + A,slowNode走过的路程为L + A, 我们得出 (L + A) x 2 = L + (C + A) + A;所以L = C.这时候我们继续定义一个新的节点enterNode从头开始出发,slowNode同时出发,两者速度相同,同时L = C;所以我们知道两者相交的节点必然是环的入口点.这时候enterNode再走到b点,就可以计算出环的长度了.

代码示例:

// 判断是否有环
bool isExistLoop(ListNode* firstNode) {
ListNode *fastNode;
ListNode * slowNode;
fastNode = slowNode = firstNode;
while (slowNode != NULL && fastNode -> next != NULL) {
slowNode = slowNode -> next ;
fastNode = fastNode -> next -> next ;
if (slowNode == fastNode)
return true ;
}
return false ;
}
// 判断环的长度
int getLoopLength(ListNode* firstNode){
ListNode* slowNode = firstNode;
ListNode* fastNode = firstNode;
while ( fastNode && fastNode ->next ){
slowNode = slowNode->next;
fastNode = fastNode->next->next;
if ( slowNode== fastNode) {
break;
}
}
slowNode= slowNode->next;
fastNode = fastNode->next->next;
int length = 1;
while ( fastNode != slowNode)
{
slowNode = slowNode->next;
fastNode = fastNode->next->next;
length ++;
}
return length;
}
// 找到环中的相遇节点
ListNode* getMeetingNode(ListNode* firstNode) {
ListNode* fastNode;
ListNode* slowNode;
slowNode = fastNode = firstNode;
while (slowNode != NULL && fastNode-> next != NULL) {
slowNode = slowNode-> next ;
fastNode = fastNode-> next -> next ;
if (slowNode == fastNode)
return slowNode;
}

//到达末尾仍然没有相遇,则不存在环
return NULL ;
}
// 找出环的入口节点
ListNode* getEntryNodeOfLoop(ListNode* firstNode) {
ListNode* meetingNode = getMeetingNode(firstNode); // 先找出环中的相遇节点
if (meetingNode == NULL)
return NULL;
ListNode* p1 = meetingNode;
ListNode* p2 = pHead;
while (p1 != p2) {
p1 = p1->next;
p2 = p2->next;
}
return p1;
}

如果可以使用字典或者集合的话,那就更简单了;数组也是可以解决,但是效率不是太高.需要多次遍历.

总结

OK,写到这里基本上就结束了,先整理这些后期会持续更新,欢迎大家指导批评,谢谢。。。

转自:https://www.jianshu.com/p/cf89d05c8f30

收起阅读 »

Flutter集成到Swift老项目 使用pod接入flutter

Xcode:Version 11.3.1 (11C504)Swift:5.0iOS项目地址Flutter项目创建cd some/path/flutter create --template module flutter_yyframework文件路径如下:cd...
继续阅读 »

Xcode:Version 11.3.1 (11C504)
Swift:5.0
iOS项目地址
Flutter项目创建

cd some/path/
flutter create --template module flutter_yyframework

文件路径如下:


cd 到你要混编的项目(YYFramework)同一个路径下 ,执行如下:

flutter create -t module flutter_yyframework

Podfile 文件

#注意路径和文件夹名字正确无误 最后有一个反斜杠
flutter_application_path = '/Users/houjianan/Documents/GitHub/iOS/flutter_yyframework/'
load File.join(flutter_application_path, 'YYFramework', 'Flutter', 'podhelper.rb')

target 'YYFramework' do
install_all_flutter_pods(flutter_application_path)

end

注:YYFramework 是iOS项目的文件名
添加好之后

pod install

注意,如下错误:[!] InvalidPodfilefile: No such file or directory @ rb_sysopen - ./flutter_yyframework/.ios/Flutter/podhelper.rb.
需要在flutter_yyframework文件夹下执行以下命令,把.ios和.android等flutter配置生成出来。(打开模拟器。链接真机都可以。)

open -a Simulator
flutter run

注意,如下错误是因为路径不对。

[!] Invalid `Podfile` file: cannot load such file -- path/to/flutter_yyframework/.ios/Flutter/podhelper.rb.

# from /Users/houjianan/Documents/GitHub/iOS/YYFramework/Podfile:7
# -------------------------------------------
# flutter_application_path = 'path/to/flutter_yyframework/'
> load File.join(flutter_application_path, '.ios', 'Flutter', 'podhelper.rb')
#
# -------------------------------------------
houjianan:YYFramework> pod install
Analyzing dependencies
Downloading dependencies
Installing Flutter (1.0.0)
Installing FlutterPluginRegistrant (0.0.1)
Installing flutter_yyframework (0.0.1)
Generating Pods project
Integrating client project
Pod installation complete! There are 42 dependencies from the Podfile and 51 total pods installed.
houjianan:YYFramework>

iOS Swift代码

//
// AppDelegate.swift
// YYFramework
//
// Created by houjianan on 2018/8/11.
// Copyright © 2018年 houjianan. All rights reserved.
//

import UIKit
import SwiftTheme
import PLShortVideoKit
import Flutter
import FlutterPluginRegistrant // Used to connect plugins.

@UIApplicationMain
// 集成FlutterAppDelegate之后代理方法要override
class AppDelegate: FlutterAppDelegate {

lazy var flutterEngine = FlutterEngine(name: "my flutter engine")

override func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
print(NSHomeDirectory())
flutter_run()
return true
}

}
//
// AppDelegate+Flutter.swift
// YYFramework
//
// Created by houjianan on 2020/1/20.
// Copyright © 2020 houjianan. All rights reserved.
//

import Foundation
import Flutter
import FlutterPluginRegistrant // Used to connect plugins.

extension AppDelegate {

func flutter_run() {
flutterEngine.run()
GeneratedPluginRegistrant.register(with: self.flutterEngine)
}
}
//
// GAFlutterRooterViewController.swift
// YYFramework
//
// Created by houjianan on 2020/1/20.
// Copyright © 2020 houjianan. All rights reserved.
//

import UIKit
import Flutter

class GAFlutterRooterViewController: UIViewController {

override func viewDidLoad() {
super.viewDidLoad()

}

@IBAction func bAction(_ sender: Any) {
let flutterEngine = (UIApplication.shared.delegate as! AppDelegate).flutterEngine
let flutterViewController = FlutterViewController(engine: flutterEngine, nibName: nil, bundle: nil)
present(flutterViewController, animated: true, completion: nil)
}

@IBAction func cAction(_ sender: Any) {
let flutterViewController = FlutterViewController(project: nil, nibName: nil, bundle: nil)

flutterViewController.setInitialRoute("MyApp")

let channel = FlutterMethodChannel(name: "com.pages.your/native_get", binaryMessenger: flutterViewController as! FlutterBinaryMessenger)
channel.setMethodCallHandler { (call, result) in
print("method = ", call.method, "arguments = ", call.arguments ?? "argumentsNULL", result)

let method = call.method
if method == "FlutterPopIOS" {
print("FlutterPopIOS:返回来传的参数是 == ", call.arguments ?? "argumentsNULL")
self.navigationController?.popViewController(animated: true)
} else if method == "FlutterCickedActionPushIOSNewVC" {
print("FlutterCickedActionPushIOSNewVC:返回来传的参数是 == ", call.arguments ?? "argumentsNULL")
let vc = GAVerificationCodeViewController(nibName: "GAVerificationCodeViewController", bundle: nil)
self.navigationController?.pushViewController(vc, animated: true)
} else if method == "FlutterGetIOSArguments" {
let dic = ["a":"value"]
print("传参给Flutter:", dic)
result(dic)
} else {

}

}
self.navigationController?.pushViewController(flutterViewController, animated: true)
}
}

Flutter代码

import 'package:flutter/services.dart';
import 'package:flutter/material.dart';
import 'package:bot_toast/bot_toast.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {

@override
Widget build(BuildContext context) {
return BotToastInit(
child: MaterialApp(
title: 'Flutter Demo',
theme: ThemeData(
primarySwatch: Colors.blue,
),
navigatorObservers: [BotToastNavigatorObserver()],
home: MyHomePage(title: '1235777'),
),
);
}
}


class MyHomePage extends StatefulWidget {
MyHomePage({Key key, this.title}) : super(key: key);

final String title;

@override
_MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
int _counter = 0;
String _textString = "00";

void _incrementCounter() {
setState(() {
_counter++;
});
}

// 创建一个给native的channel (类似iOS的通知)
static const MethodChannel methodChannel = MethodChannel('com.pages.your/native_get');

_iOSPushToVC() async {
await methodChannel.invokeMethod('FlutterPopIOS', '参数');
}

void _backAction() {
_iOSPushToVC();
}

void _pushIOSNewVC() async {
Map<String, dynamic> map = {"code": "200", "data":[1,2,3]};

await methodChannel.invokeMethod('FlutterCickedActionPushIOSNewVC', map);
}

Future<void> _FlutterGetIOSArguments(para) async {
BotToast.showText(text:"_FlutterGetIOSArguments");
try {
final result = await methodChannel.invokeMethod('FlutterGetIOSArguments', para);


BotToast.showText(text:result["a"]);
_textString = result["a"];
} on PlatformException catch (error) {
print(error);
}
}

@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text(widget.title),
),
body: Center(
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
Text(
'You have pushed the button this many times1:',
),
Text(
'$_counter',
style: Theme.of(context).textTheme.display1,
),
FloatingActionButton(
onPressed: _backAction,
child: Icon(Icons.accessibility),
),
FloatingActionButton(
onPressed: _pushIOSNewVC,
child: Icon(Icons.accessibility),
),
FloatingActionButton(
onPressed:() {
_FlutterGetIOSArguments("flutter传值");
// 刷新界面
setState(() {});
},
child: Icon(Icons.accessibility),
),
Text(_textString),
],
),
),
floatingActionButton: FloatingActionButton(
onPressed: _incrementCounter,
tooltip: 'Increment',
child: Icon(Icons.add),
), // This trailing comma makes auto-formatting nicer for build methods.
);
}
}

官网Integrate a Flutter module into your iOS project
很久之前写的一篇《Flutter和原生iOS交互》

过年了,有点时间玩Flutter!
Flutter统治全世界。

转自:https://www.jianshu.com/p/351bd8ecbc79

收起阅读 »

iOS 音频播放iOS13上远程控制设置控制方法崩溃

使用MPRemoteCommandCenter 处理远程音频事件的播放的时候,有些同学会用[pauseCommand addTarget:self action:@selector(remotePauseEvent)]这个方法来处理,但是在iOS13后苹果官方...
继续阅读 »

使用MPRemoteCommandCenter 处理远程音频事件的播放的时候,
有些同学会用[pauseCommand addTarget:self action:@selector(remotePauseEvent)]这个方法来处理,但是在iOS13后苹果官方在这个方法有要求了,官方文档这么写的

// Target-action style for adding handlers to commands.
// Actions receive an MPRemoteCommandEvent as the first parameter.
// Targets are not retained by addTarget:action:, and should be removed from the
// command when the target is deallocated.
//
// Your selector should return a MPRemoteCommandHandlerStatus value when
// possible. This allows the system to respond appropriately to commands that
// may not have been able to be executed in accordance with the application's
// current state
翻译一下其实意思就是 建议用addTargetWithHandler:(MPRemoteCommandHandlerStatus(^)(MPRemoteCommandEvent *event))handler; 这个方法来为其添加本地事件处理,但是也可以用- (void)addTarget:(id)target action:(SEL)action;方法来处理,用- (void)addTarget:(id)target action:(SEL)action; 方法处理时候需要返回MPRemoteCommandHandlerStatus这个值.

意思就是这样了,根据这样的翻译可以很明确知道该怎么解决,要不换- (void)addTarget:(id)target action:(SEL)action;方法为- (id)addTargetWithHandler:(MPRemoteCommandHandlerStatus(^)(MPRemoteCommandEvent *event))handler;要不就在- (void)addTarget:(id)target action:(SEL)action;的引用方法里添加返回值,例如:

- (MPRemoteCommandHandlerStatus)remotePauseEvent {

return MPRemoteCommandHandlerStatusSuccess;
}

参考至这里


转自:https://www.jianshu.com/p/40cd3e7b05bb

收起阅读 »

iOS _OBJC_CLASS_$_NSEntityDescription报错

最近项目中有使用到,MJ相关系列的库,结果出现了报错,如下:Undefined symbol: _OBJC_CLASS_$_NSEntityDescriptionUndefined symbol: _OBJC_CLASS_$_NSManagedObject通过...
继续阅读 »

最近项目中有使用到,MJ相关系列的库,结果出现了报错,如下:

Undefined symbol: _OBJC_CLASS_$_NSEntityDescription

Undefined symbol: _OBJC_CLASS_$_NSManagedObject


通过网上查资料,才知道,自己缺少了coredata库文件,所以才会报这个错误,在项目的这个地方引入,coredata库,即可解决此问题

引入coredata库

收起阅读 »

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
    来源:掘金
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
    收起阅读 »