只简述我发现问题的根源,有些是适配了7.0,会报权限失败问题,那是由于没有动态授权导致,接下来我一步一步给大家实现7.0适配,使用的是Kotlin语言

系列文章Android面试攻略——Android基础Android面试攻略——异步消息处理机制Android面试攻略——View相关

RecyclerView:主要是在有限空间,展现大量数据,与ListView,GridView类似:

<uses-permissionandroid:name=”android.permission.CAMERA” />

本篇文章主要涉及Handler、AsyncTask、HandlerThread、IntentService

使用的基本步骤:

dependencies {

compile’com.android.support:recyclerview-v7:25.1.0′

}

只说一个提示:注意设置为android.support.constraint.ConstraintLayout布局为父类布局会有问题,首次加载子空间无法居中等属性无法生效。尴尬。。。

3.1.首先要创建一个class,继承自RecyclerView.ViewHolder。然后再里面对RecyclerView的item布局进行初始化。为Adapter使用做准备。

class MyViewHolder extends RecyclerView.ViewHolder{

TextViewtv;

public MyViewHolder(View itemView) {

super;

tv= itemView.findViewById(R.id.tv_show_message);}}

解释说明:本类在adapter中的onCreateViewHolder方法中被创建,itemView是item的layout布局的View,用来初始化布局中的控件。

3.2创建Adapter实例。

3.2.1Adapter实例要继承自RecyclerView.Adapter<PicturesAdapter.MyViewHolder>并传入上一步创建的ViewHoler的实现类。

3.2.1需要实现的方法说明

class PicturesAdapter extends RecyclerView.Adapter
<PicturesAdapter.MyViewHolder>{

说明:类要继承自RecyclerView.Adapter并要指定泛型为我们之前创建的VIewHolder类
(PicturesAdapter.MyViewHolder是应为我声明的类是内部类,在PicturesAdapter类内)

//方法说明:这个方法是用来创建MyViewHolder类实例,并返回。

//MyViewHolder创建的时候需要传入一个View,就是RecycleView的每个子类的布局试图

public MyViewHolder onCreateViewHolder(ViewGroup parent, intviewType)
{}

//是布局与控件绑定的时候使用,一般又来为控件设置数据,以及监听事件

public void onBindViewHolder(MyViewHolder holder, intposition) {}

//返回item的数量

public int getItemCount() {}

//View Holder类

class MyViewHolder extends RecyclerView.ViewHolder{}}

3.2.3通过setAdapter()方法为RecycleView设置适配器

4.为item添加装饰器

4.1首先要写一个装饰器类,需要继承自RecyclerView.ItemDecoration,然后从写方法

public classDividerItemDecoration extends RecyclerView.ItemDecoration
{

//说明onDrawOver与onDraw只需要实现一个即可

//onDraw是绘制在绘制子控前绘制,也就是说onDraw绘制出来的画面在子控件后面

//onDrawOver绘制出来的画面在子控件前面;

@Override

public void onDrawOver(Canvas c,RecyclerView parent,RecyclerView.State
state) {

super.onDrawOver(c,parent,state);}

@Override

public void onDraw(Canvas c,RecyclerView parent,RecyclerView.State
state) {

//parent通过parent获得子控件的数量

final int childCount = parent.getChildCount();

//循环为子控件绘制装饰,

for(inti =0;i < childCount;i++) {

//通过子控件获得相应左边

//然后就是自定View了,想绘制就绘制什么了

finalView child = parent.getChildAt;

final inttop = child.getTop() -50;

final intbottom = child.getBottom()+50;final intleft =
child.getLeft()-50;

final intright =child.getRight()+50;

//设置画笔属性

Paint
p=newPaint();p.setStyle(Paint.Style.FILL);p.setColor(Color.BLUE);

c.drawRect(left,top,right,bottom,p);}}

@Override

public voidgetItemOffsets(Rect outRect,View view,RecyclerView
parent,RecyclerView.State state) {

super.getItemOffsets(outRect,view,parent,state);

//这个是关键,当我们绘制出来后,能否显示要看这个方法

//方法说明,每个item左上右下向外延伸宽度,用来显示item的装饰器

outRect.set(60,60,60,60);}}

5.设置布局管理器(必须设置否则无法运行)

5.1 LinearLayoutManager 支持横向、纵向的单行或单列显示。

recyclerPictures.setLayoutManager(new
LinearLayoutManager(this,LinearLayoutManager.VERTICAL,false));

参数说明:this:这是一个上下文对象,LinearLayoutManager.VERTICAL:设置横向还是纵向。false:设置开始显示位置是头部还是尾部。

5.2 GridLayoutManager 网格布局管理器

mRecyclerView.setLayoutManager(new
GridLayoutManager(this,2,LinearLayoutManager.VERTICAL,false));

5.3 StaggeredGridLayoutManager 瀑布就式布局管理器

mRecyclerView.setLayoutManager(new
StaggeredGridLayoutManager(2,StaggeredGridLayoutManager.VERTICAL));

说明:2
代表的是两列或则两行,StaggeredGridLayoutManager.VERTICAL代表列表的方向

6.ItemAnimator 子控件删除添加动画:

系统默认动画的使用步骤:

ItemAnimator也是一个抽象类,好在系统为我们提供了一种默认的实现类:

6.1// 设置item动画

mRecyclerView.setItemAnimator(newDefaultItemAnimator;

6.2将这两个方法添加到adapter中

public void addData(int position) {

//进行数据更行

mDatas.add(position,”Insert One”);

//添加元素的时候,进行更新动画与数据更行

notifyItemInserted;

}

public void removeData(int position) {

进行数据更新

mDatas.remove;

//删除元素与动画进行

notifyItemRemoved;

}

在当需要添加或者删除数据的时候调用这个方法就可以实现了。

<uses-permissionandroid:name=”android.permission.READ_EXTERNAL_STORAGE”
/>

当程序第一次启动的时候,Android会同时启动一条主线程( Main
Thread)来负责处理与UI相关的事件,我们叫做UI线程。Android的UI操作并不是线程安全的,意味着如果多个线程并发操作UI线程,可能导致线程安全问题。

<uses-permissionandroid:name=”android.permission.WRITE_EXTERNAL_STORAGE”/>

为了解决Android应用多线程问题—Android平台只允许UI线程修改Activity里的UI组建,就会导致新启动的线程无法改变界面组建的属性值。

<provider

简单的说:当主线程队列处理一个消息超过5秒,android 就会抛出一个
ANP的异常,所以,我们需要把一些要处理比较长的消息,放在一个单独线程里面处理,把处理以后的结果,返回给主线程运行,就需要用的Handler来进行线程建的通信。

android:name=”android.support.v4.content.FileProvider”

handler通过发送和处理Message和Runnable对象来关联相对应的线程的MessageQueue。可以让对应的Message和Runnable在未来的某个时间点进行相应的处理(延时处理:postAtTime()、postDelayed。让自己想要处理的耗时操作放在子线程,让更新ui的操作放在主线程。

android:authorities=”com.wocus.myapplication.fileprovider”
//这里写自己的包名,后面固定

  • 首先声明一个Handler,复写其handleMessage方法

android:exported=”false”

android:grantUriPermissions=”true”>

Handler mHandler = new Handler(){ @Override public void handleMessage(Message msg) { super.handleMessage; if(msg.what == 1) mTextView.setText; } };

<meta-data

  • 在子线程发送消息通知Handler执行操作

android:name=”android.support.FILE_PROVIDER_PATHS”

android:resource=”@xml/filepaths” />

new Thread() { @Override public void run() { super.run(); //do something ... //子线程中通过handler发送消息给handler接收,由handler去更新TextView的值 Message msg = Message.obtain(); msg.what = 1; msg.obj = "需要发送的数据"; mHandler.sendMessage; } }.start();

<provider>

首先我们来想看下Handler的构造方法

提供filepaths源码,在res目录下创建xml文件夹,在里面新建filepaths.xml文件

public Handler();public Handler(Callback callback);public Handler(Looper looper);public Handler(Looper looper, Callback callback);

<resources>

前两个构造方法是没有传递Looper对象的,这两个方法内部会调用另一个构造方法

<paths>

public Handler(Callback callback, boolean async) { if (FIND_POTENTIAL_LEAKS) { final Class<? extends Handler> klass = getClass(); if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass && (klass.getModifiers() & Modifier.STATIC) == 0) { Log.w(TAG, "The following Handler class should be static or leaks might occur: " + klass.getCanonicalName; } } mLooper = Looper.myLooper(); if (mLooper == null) { throw new RuntimeException( "Can't create handler inside thread that has not called Looper.prepare; } mQueue = mLooper.mQueue; mCallback = callback; mAsynchronous = async; }

<external-pathpath=””name=”sdcard_files”/>

可以看到,这个构造方法通过Looper.myLooper()获取了保存在该线程下的mLooper实例对象,再通过mLopper.mQueue获取了MessageQueue。也就是每个Handler
对应一个Looper对象,产生一个MessageQueue
。那其实我们并没有做过Looper的保存操作,为什么这里可以拿到保存的Looper呢?其实,我们这里获取到的Looper,是主线程创建的时候,实现了Looper的两个重要的方法。我们来看下ActivtyThread.class中的源码:

<external-files-pathpath=””name=”camera_has_sdcard”/>

public static final void main(String[] args) { // ----- Looper.prepareMainLooper(); if (sMainThreadHandler == null) { sMainThreadHandler = new Handler(); } ActivityThread thread = new ActivityThread(); thread.attach; if  { Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread")); } Looper.loop(); // ---- }

<files-pathpath=””name=”camera_no_sdcard”/>

首先我们来看Looper.prepareMainLooper(),其内部调用了prepare

<paths/>

private static void prepare(boolean quitAllowed) { if (sThreadLocal.get() != null) { throw new RuntimeException("Only one Looper may be created per thread"); } sThreadLocal.set(new Looper(quitAllowed)); }

<resources/>

该方法保证了Looper的唯一性且会调用Looper构造函数同时实例化出MessageQueue和当前thread.

a.新建3个file对象用于存储读取出来的图片

public static @NonNull MessageQueue myQueue() { return myLooper().mQueue; }private Looper(boolean quitAllowed) { mQueue = new MessageQueue(quitAllowed); mThread = Thread.currentThread(); }

varcamerafile:File?=null//照相机File对象

prepare()方法中通过ThreadLocal对象实现Looper实例与线程的绑定,即保存当前的Looper实例到ThreadLocal当中,Handler中通过Looper.myLooper()将Looper实例从ThreadLocal中取出。

vargalleryfile:File?=null//相册的File对象

public static @Nullable Looper myLooper() { return sThreadLocal.get(); }

varcropfile:File?=null//照相机的File对象

Handler、Looper、MessageQueue都有了,下面该发送消息了,我们看看Handle发送消息的几个方法源码

b.首先在开始调用拍照或者选择图片的时候要动态验证权限

public final boolean sendMessage(Message msg) { return sendMessageDelayed; }public final boolean sendEmptyMessage { return sendEmptyMessageDelayed; }public final boolean sendEmptyMessageDelayed(int what, long delayMillis) { Message msg = Message.obtain(); msg.what = what; return sendMessageDelayed(msg, delayMillis); }public final boolean sendMessageDelayed(Message msg, long delayMillis) { if (delayMillis < 0) { delayMillis = 0; } return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis); }public boolean sendMessageAtTime(Message msg, long uptimeMillis) { MessageQueue queue = mQueue; if (queue == null) { RuntimeException e = new RuntimeException( this + " sendMessageAtTime() called with no mQueue"); Log.w("Looper", e.getMessage; return false; } return enqueueMessage(queue, msg, uptimeMillis); }

@SuppressLint

可以看到,它们最终都调用了sendMessageAtTime()方法,然后返回了enqueueMessage(),我们来看看这个方法的源码

fun requestReadExternalPermission(){

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) { msg.target = this; if (mAsynchronous) { msg.setAsynchronous; } return queue.enqueueMessage(msg, uptimeMillis); }

if(checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE)

在该方法中有两件事需要注意:

!= PackageManager.PERMISSION_GRANTED) {

  1. msg.target = this:该代码将Message的target绑定为当前的Handler
  2. queue.enqueueMessage
    :变量queue表示的是Handler所绑定的消息队列MessageQueue,通过调用queue.enqueueMessage(msg,
    uptimeMillis)我们将Message放入到消息队列中。

if(shouldShowRequestPermissionRationale(Manifest.permission.READ_EXTERNAL_STORAGE))
{

通过下图可以看到完整的方法调用顺序:澳门微尼斯人手机版 1图片来自网络

}else{

消息放入消息队列之后,怎么处理呢?我们最后来看下loop()方法

requestPermissions(arrayOf(Manifest.permission.CAMERA,Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE),0)

public static void loop() { final Looper me = myLooper(); if (me == null) { throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread."); } final MessageQueue queue = me.mQueue; Binder.clearCallingIdentity(); final long ident = Binder.clearCallingIdentity(); for  { Message msg = queue.next(); // might block if (msg == null) { // No message indicates that the message queue is quitting. return; } // This must be in a local variable, in case a UI event sets the logger final Printer logging = me.mLogging; if (logging != null) { logging.println(">>>>> Dispatching to " + msg.target + " " + msg.callback + ": " + msg.what); } final long traceTag = me.mTraceTag; if (traceTag != 0 && Trace.isTagEnabled) { Trace.traceBegin(traceTag, msg.target.getTraceName; } try { msg.target.dispatchMessage; } finally { if (traceTag != 0) { Trace.traceEnd; } } if (logging != null) { logging.println("<<<<< Finished to " + msg.target + " " + msg.callback); } final long newIdent = Binder.clearCallingIdentity(); if (ident != newIdent) { Log.wtf(TAG, "Thread identity changed from 0x" + Long.toHexString + " to 0x" + Long.toHexString + " while dispatching to " + msg.target.getClass().getName() + " " + msg.callback + " what=" + msg.what); } msg.recycleUnchecked(); } }

}

首先looper对象不能为空,就是说loop()方法调用必须在prepare()方法的后面。Looper一直在不断的从消息队列中通过MessageQueue的next方法获取Message,然后通过代码msg.target.dispatchMessage让该msg所绑定的Handler(Message.target)执行dispatchMessage方法以实现对Message的处理。Handler的dispatchMessage的源码如下:

}

public void dispatchMessage(Message msg) { if (msg.callback != null) { handleCallback; } else { if (mCallback != null) { if (mCallback.handleMessage { return; } } handleMessage; } }

}

我们可以看到Handler提供了三种途径处理Message,而且处理有前后优先级之分:首先尝试让postXXX中传递的Runnable执行,其次尝试让Handler构造函数中传入的Callback的handleMessage方法处理,最后才是让Handler自身的handleMessage方法处理Message。

//权限回调方法

Callback参数:Callback是Handler中的内部接口,需要实现其内部的handleMessage方法,Callback代码如下:

override funonRequestPermissionsResult(requestCode: Int,permissions:
Array,grantResults: IntArray) {

public interface Callback { public boolean handleMessage(Message msg); }

when(requestCode){

Handler.Callback是用来处理Message的一种手段,如果没有传递该参数,那么就应该重写Handler的handleMessage方法,也就是说为了使得Handler能够处理Message,我们有两种办法:

0->{

  1. 向Hanlder的构造函数传入一个Handler.Callback对象,并实现Handler.Callback的handleMessage方法。
  2. 无需向Hanlder的构造函数传入Handler.Callback对象,但是需要重写Handler本身的handleMessage方法
    。也就是说无论哪种方式,我们都得通过某种方式实现handleMessage方法,这点与Java中对Thread的设计有异曲同工之处。

if(grantResults.size>0

我们知道,在子线程中使用Handler会出错,为什么?Handler本质是从当前的线程中获取到Looper来监听和操作MessageQueue,当其他线程执行完成后回调当前线程。而子线程中并没有预先设置Looper,所以导致Handler调用Looper.myLooper()时找不到Looper对象导致抛出异常。所以,我们如果想在子线程中使用,必须在声明Handler之前,调用Looper.prepare(),然后调用Looper的loop()方法来启动Looper让消息队列转动起来。

&& grantResults[0] == PackageManager.PERMISSION_GRANTED) {

class DownLoadThread implements Runnable { public Handler myHandler; // 实现Runnable接口的线程体 @Override public void run() { /*①、调用Looper的prepare()方法为当前线程创建Looper对象并, 创建Looper对象时,它的构造器会自动的创建相对应的MessageQueue*/ Looper.prepare(); /*.②、创建Handler子类的实例,重写HandleMessage()方法,该方法处理除当前线程以外线程的消息*/ myHandler = new Handler() { @Override public void handleMessage(Message msg) { String ms = ""; if (msg.what == 0x777) { } } }; //③、调用Looper的loop()方法来启动Looper让消息队列转动起来 Looper.loop(); } }

}else{

原因:静态内部类持有外部类的匿名引用,导致外部Activity无法释放。解决办法:1.
Handler内部持有外部Activity的弱引用。2. 把Handler改为静态内部类。3.
在Activity的onDestroy()方法中调用mHandler.removeCallback()。

Toasty.error(baseContext,”授权失败”).show()

AsyncTask本质上就是一个封装了线程池和Handler的异步框架。适用于简单的异步处理。

}

继承AsyncTask类实现自己的类,并重写其中的方法。

}

三个参数

}

public abstract class AsyncTask<Params, Progress, Result> {}

super.onRequestPermissionsResult(requestCode,permissions,grantResults)

Params:
输入参数,对应excute()方法中传递的参数。如果不需要传递参数,则直接设为void即可。

}

Progress:后台任务执行的百分比

c.拍照的代码

Result:返回值类型,和doInBackground()方法的返回值类型保持一致。

/\**

五个方法

* 选择照相机拍照

protected abstract Result doInBackground(Params... params);protected void onPostExecute(Result result) { }protected void onProgressUpdate(Progress... values) { }protected void onPreExecute() { }protected void onCancelled() { }

*/

最少要重写以下这两个方法:

fungetCamera(){

  • doInBackground
    在子线程(其他方法都在主线程执行)中执行比较耗时的操作,不能更新UI,可以在该方法中调用publishProgress(Progress…)来更新任务的进度。Progress方法是AsycTask中一个final方法只能调用不能重写。

  • onPostExecute 使用在doInBackground 得到的结果处理操作UI,
    在主线程执行,任务执行的结果作为此方法的参数返回。
    有时根据需求还要实现以下三个方法:

  • onProgressUpdate(Progress…) 可以使用进度条增加用户体验度。
    此方法在主线程执行,用于显示任务执行的进度。

  • onPreExecute()
    这里是最终用户调用Excute时的接口,当任务执行之前开始调用此方法,可以在这里显示进度对话框。

  • onCancelled() 用户调用取消时,要做的操作

varintent:Intent= Intent(MediaStore.ACTION_IMAGE_CAPTURE)

在主线程中申明该类的对象,调用对象的execute()函数开始执行。

if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){

MyAsyncTask t = new MyAsyncTask();t.execute();

img_paths=SimpleDateFormat(“yyyyMMddHHmmss”).format+”.jpg”

  1. AsyncTask的本质是一个静态的线程池,AsyncTask派生出的子类可以实现不同的异步任务,这些任务都是提交到静态的线程池中执行。
  2. 线程池中的工作线程执行doInBackground方法执行异步任务。
  3. 当任务状态改变后,工作线程会向UI线程发送消息,AsyncTask内部的InternalHandler响应这些消息,并调用相关的回调函数。

varpath:File=
getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM)

camerafile= File(path,img_paths)

  1. AsyncTask不适合特别耗时的任务AsyncTask的生命周期和Activity的生命周期不同步,Activity销毁了但是AsyncTask中的任务还是会继续执行完毕,一个最典型的例子就是Activity的横竖屏切换,AsyncTask中引用的Activity不是当前的Activity,onPostExecute()中执行的仍然是上一个Activity。还有一个原因是因为AsyncTask在执行长时间的耗时任务时也会持有一个Activity对象,即使这个Activity已经不可见了,Android也无法对这个Activity进行回收,导致内存泄露

  2. AsyncTask只能在主线程中创建以及使用AsyncTask被用于执行异步任务,然后更新UI,所以最后的onPostExecute()方法执行在创建该AsyncTask对象的线程中,如果不在主线程中创建以及使用,就达不到更新UI的目的。

  3. 一个AsyncTask对象只能执行一次一个AsyncTask对象只能执行一次,即只能调用一次execute方法,否则会报运行时异常AsyncTask。这是源码注释中写的,但是我查阅资料也没有找到什么具体原因。本人学艺也不精…也就知道了不能重复对一个AsyncTask对象调用execute()方法。

  4. AsyncTask在不同的Android版本下的并行和串行问题关于AsyncTask的并行和串行问题,在不同的API下是有不同的。在Android1.6之前,AsyncTask是串行执行任务的;到了Android1.6时,开始采用线程池来并行执行任务;在Android3.0之后的版本中,AsyncTask又开始用一个线程串行执行任务。虽然Android3.0之后采用串行方式执行任务,但我们可以通过AsyncTask的executeOnExecutor(exe,params),自定义一个线程池来并行执行任务。

if(Build.VERSION.SDK_INT>= Build.VERSION_CODES.N) {//7.0及以上

当我们需要执行耗时操作时,很自然的会想到开启一个子线程,当耗时操作完成之后,线程自动销毁。之后如果我们又需要执行另一个耗时操作,再开启一个子线程,这时就涉及到一个性能问题了。要知道,频繁的创建和销毁线程是很耗费系统资源的,所以,为了解决这个问题,Android给我们提供了HandlerThread这个类。好吧,其实初看这段话,我是没搞懂HandlerThread到底是干啥的,所以我们来看看它的用法先吧。

intent.putExtra(MediaStore.EXTRA_OUTPUT,FileProvider.getUriForFile(this,”com.wocus.myapplication.fileprovider”,camerafile))

HandlerThread的使用十分简单,简单到只有几行代码

intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)

 HandlerThread ht = new HandlerThread("newThread"); ht.start(); mHandler = new Handler(ht.getLooper { @Override public void handleMessage(Message msg) { super.handleMessage; //do something } };

intent.addFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION)

声明一个HandlerThread对象并传入一个字符串参数,然后调用start()方法启动HandlerThread,将HandlerThread里的Looper传入Handler。最后记得在Activity的onDestroy()方法中将HandlerThread关闭

}else{

@Override protected void onDestroy() { super.onDestroy(); //释放资源 ht.quit() ; }

intent.putExtra(MediaStore.EXTRA_OUTPUT,Uri.fromFile(camerafile))

用法很简单,但是为什么要这么用?这样子声明的Handler跟平时我们用的有什么不一样呢,那我们来看看HandlerThread的源码。

}

HandlerThread的源码不多,首先来看下类的继承关系

startActivityForResult(intent,100)

public class HandlerThread extends Thread {}

}else{

HandlerThread 继承自Thread,也就是说HandlerThread
本质就是一个线程类,所以当我们new HandlerThread
()的时候实际上是创建了一个子线程所以之后调用了start()方法启动了该线程,那接下来我们来看下关键的run()方法

Toasty.error(this,”存储卡不可用!”).show()

@Override public void run() { mTid = Process.myTid(); Looper.prepare(); synchronized  { mLooper = Looper.myLooper(); notifyAll(); } Process.setThreadPriority(mPriority); onLooperPrepared(); Looper.loop(); mTid = -1; }

}

run()方法里面调用了Looper.prepare()和Looper.loop(),这个过程是不是很眼熟,我们前面说过了在子线程中使用Handler,需要自己调用这两个方法,而我们在声明Handler时,将这个Looper对象通过getLooper()方法获取到并作为参数传入了进去

}

public Looper getLooper() { if (!isAlive { return null; } // If the thread has been started, wait until the looper has been created. synchronized  { while  && mLooper == null) { try { wait(); } catch (InterruptedException e) { } } } return mLooper; }

d.从相册选择图片的代码

如果你够细心你会发现,run方法里面当mLooper创建完成后有个notifyAll(),getLooper()中有个wait(),这是为什么呢?因为mLooper在一个线程中执行,而我们的handler是在UI线程初始化的,也就是说,我们必须等到mLooper创建完成,才能正确的返回getLooper,notify()就是为了解决这两个线程的同步问题。

/\**

结合前面对Handler的分析,我们知道,当我们需要在子线程与子线程之间进行通信,也就是需要在子线程中使用Handler时,需要手动去操作Looper,这是很不推荐的做法。所以Google官方很贴心的帮我们封装好了一个类,那就是刚才HandlerThread啦。

* 从相册选择照片

最后再来看看quit()方法

*/

public boolean quit() { Looper looper = getLooper(); if (looper != null) { looper.quit(); return true; } return false; }public boolean quitSafely() { Looper looper = getLooper(); if (looper != null) { looper.quitSafely(); return true; } return false; }

fungetGallery(){

两个方法最后都是调用MessageQueue里面的quit方法

img_paths=SimpleDateFormat(“yyyyMMddHHmmss”).format+”.jpg”

void quit(boolean safe) { if (!mQuitAllowed) { throw new IllegalStateException("Main thread not allowed to quit."); } synchronized  { if (mQuitting) { return; } mQuitting = true; if  { removeAllFutureMessagesLocked(); } else { removeAllMessagesLocked(); } nativeWake; } }

varpath:File=
getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM)

当我们调用Looper的quit方法时,实际上执行了MessageQueue中的removeAllMessagesLocked方法,该方法的作用是把MessageQueue消息池中所有的消息全部清空,无论是延迟消息(延迟消息是指通过sendMessageDelayed或通过postDelayed等方法发送的需要延迟执行的消息)还是非延迟消息。

galleryfile= File(path,img_paths)

当我们调用Looper的quitSafely方法时,实际上执行了MessageQueue中的removeAllFutureMessagesLocked方法,通过名字就可以看出,该方法只会清空MessageQueue消息池中所有的延迟消息,并将消息池中所有的非延迟消息派发出去让Handler去处理,quitSafely相比于quit方法安全之处在于清空消息之前会派发所有的非延迟消息。

varintent:Intent= Intent(Intent.ACTION_GET_CONTENT)

无论是调用了quit方法还是quitSafely方法只会,Looper就不再接收新的消息。即在调用了Looper的quit或quitSafely方法之后,消息循环就终结了,这时候再通过Handler调用sendMessage或post等方法发送消息时均返回false,表示消息没有成功放入消息队列MessageQueue中,因为消息队列已经退出了。

intent.addCategory(Intent.CATEGORY_OPENABLE)

  • HandlerThread的本质依然是一个线程类,它继承自Thread。
  • HandlerThread有自己的内部Looper对象,可以进行looper循环。
  • 通过获取HandlerThread的looper对象传递给Handler对象,可以在handleMessage方法中执行异步任务。
  • 优点是不会阻塞,减少了对性能的消耗,缺点是不能同时进行多任务的处理,需要等待进行处理,处理效率低。
  • 与线程池注重并发不同,HandleThread是一个串行队列,HandlerThread背后只有一个线程。

intent.setType(“image/*”)

IntentService是继承并处理异步请求的一个类,在IntentService内有一个工作线程来处理耗时操作,启动IntentService的方式和传统的Service一样,同时,当任务执行完后,IntentService会自动停止,而不需要我们手动去控制或者stopSelf()。另外,可以启动IntentService多次,而每一次耗时操作会以工作队列的方式在IntentService的onHandleIntent回调方法中执行,并且,每次只会执行一个工作线程,执行完第一个再执行第二个。

if(Build.VERSION.SDK_INT>=Build.VERSION_CODES.N){

  • 它本质是一种特殊的Service,继承自Service并且本身就是一个抽象类。
  • 它内部通过HandlerThread和Handler实现异步操作。

intent.putExtra(MediaStore.EXTRA_OUTPUT,FileProvider.getUriForFile(baseContext,”com.wocus.myapplication.fileprovider”,galleryfile))

继承IntentService实现自己类,并重写构造函数和onHandleIntent()方法,onHandleIntent()是个异步方法,可以执行耗时操作。

intent.addFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION)

public class MyIntentService extends IntentService { public static final String INDEX_FLAG = "index_flag"; public static UpdateUI updateUI; public MyIntentService(String name) { super; } public static void setUpdateUI(UpdateUI updateUIInterface) { updateUI = updateUIInterface; } //运行在子线程的方法,intent是从启动该服务的context传过来的 @Override protected void onHandleIntent(Intent intent) { try { Thread.sleep; Message msg = new Message(); msg.what = intent.getIntExtra(INDEX_FLAG, 0); msg.obj = "返回的值" + msg.what; if (updateUI != null) updateUI.updateUI; } catch (InterruptedException e) { e.printStackTrace(); } } public interface UpdateUI { void updateUI(Message message); }}

intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)

Activity中启动该服务并设置回调

startActivityForResult(intent,200)

public class MainActivity extends AppCompatActivity implements MyIntentService.UpdateUI { private static TextView mTextView; private static final Handler mUIHandler = new Handler() { @Override public void handleMessage(Message msg) { mTextView.setText msg.obj); } }; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); mTextView = findViewById(R.id.text); Intent intent = new Intent(this, MyIntentService.class); for (int i = 0; i < 7; i++) { intent.putExtra(MyIntentService.INDEX_FLAG, i); startService; } MyIntentService.setUpdateUI; } @Override public void updateUI(Message message) { mUIHandler.sendMessageDelayed(message, message.what * 1000); }}

}else{

activity中循环启动了7次service,但实际只有一个IntentService实例,IntentService会依次执行这7次操作,然后通过UpdateUI
接口回调结果更新UI。

startActivityForResult(intent,200)

首先,还是看继承关系

}

public abstract class IntentService extends Service {}

}

可以看到,IntentService本质还是个Service,那我们就去看它的onCreate()方法

e.回传方法的代码

 @Override public void onCreate() { super.onCreate(); HandlerThread thread = new HandlerThread("IntentService[" + mName + "]"); thread.start(); mServiceLooper = thread.getLooper(); mServiceHandler = new ServiceHandler(mServiceLooper); }

override funonActivityResult(requestCode: Int,resultCode: Int,data:
Intent?) {

在onCreate()方法中,创建了一个HandlerThread实例对象并将它传入了ServiceHandler对象中,ServiceHandler实际就是一个Handler,所以通过这一步,IntentService具备了进行异步操作的能力。接着我们来看onStart()方法

发表评论

电子邮件地址不会被公开。 必填项已用*标注