android-interview

- 事件分发机制，事件冲突处理

Input Events. https://developer.android.google.cn/guide/topics/ui/ui-events.html

在Android中有几种方法可以截获用户与应用之间的事件。

比起继承view重置view的事件处理方法，view提供了各种event listeners来实现事件处理。

view的event listener中的各种方法:

• onClick()
• onLongClick()
• onFoucusChange()
• onKey()
• onTouch(), a touch event，包括press, release , or any movement getsture
• onCreateContextMenu()

处理Focus

focus的移动按照基于算法进行，算法在给定方向上查找最近的邻居。如果默认的算法无法满足需求，可以在layout的xml文件中指定nextFocusDown, nextFocusLeft, nextFocusRight, nextFocusRight这些属性。

Managing Touch Events in a ViewGroup.

https://developer.android.google.cn/training/gestures/viewgroup.html

在ViewGroup中处理touch事件需要特别小心，因为通常子view是不同touch事件的target而不是view group本身。为了保证每个view正确接收到本应给它的touch事件，重置onInterceptTouchEvent()方法。

在ViewGroup中拦截Touch 事件

当在ViewGoup的surface上检测到了touch事件，则onInterceptTouchEvent方法会被调用，如果该方法返回true，则事件不会继续传递给child，而是传递给parent的onTouchEvent()方法。

onInterceptTouchEvent()方法给了parent一个在传递给child前处理event的机会。

• 返回true，事件交给onTouchEvent方法，之前处理touch event的child view会收到ACTION_CANCEL，该事件中之后的动作会传给parent 的onTouchEvent

• 返回false，则事件仍按照正常的传递流程到target。

处理ACTION_OUTSIDE 事件

如果ViewGroup收到了带有ACTION_OUTSIDE的MotionEvent，那么这个事件默认不会分发给child，可以在相应的Window.Callback中处理该事件，也可以通过重置dispatchTouchEvent(MotionEvent)分发给合适的view。

Understanding Android Input Touch Events

System Framework (dispatchTouchEvent, onInterceptTouchEvent,
onTouchEvent, OnTouchListener.onTouch)

http://codetheory.in/understanding-android-input-touch-events/ 有些地方说得不是很确切

理解事件分发机制是很重要的。

如果在ViewGroup如ScrollView中使用了ViewPager或者ListView（都可以scrollable) ，事件会像变戏法一样。

Touch事件的传播

按下屏幕(ACTION_DOWN)触发一个touch事件后，它会到达Activity.dispatchTouchEvent()方法，该方法将MotionEvent发送给root view(这里我认为是DecorView).

• Activity.dispatchTouchEvent(MotionEvent ev)

  • 发送事件给window的root view
  • 该方法如果返回true，那么ACTION_DOWN之后的事件( MOVE, UP) 它也会消耗掉。如果返回false，那么这些事件就不再到达这个方法。

• ViewGroup.diaptachTouchEvent，

  • root view的dispatchTouchEvent()方法首先会调用onInterceptTouchEvent()方法，查看是否该方法会拦截事件.
  • 如果拦截方法返回false，查找区域包含事件坐标的child, 然后调用child的dispatchTouchEvent，如果返回false则继续找下一个区域包含事件坐标的child。返回true则事件被处理。
    • 如果children都没有处理该事件，则交给ViewGroup的onTouchEvent()方法

  1 2 3 4 5 6

  public boolean dispatchTouchEvent(MotionEvent ev) { 是否因为安全问题过滤掉该事件 ->no: flags定义中是否允许拦截 //requestDisallowInterceptTouchEvent() 方法设置是否允许拦截 ->yes: onInterceptTouchEvent ->no: ... }

  • 如果拦截了，之前处理事件的child会收到ACTION_CANCEL

• View.dispatchTouchEvent()

  • 如果存在listener, 发送事件给View.onTouchListener.onTouch()， 如果消息还没有被消耗，则交给View.onTouchEvent()

dispatchTouchEvent的返回值如何影响分发流程

- Android多线程

AsyncTask

使用FutureTask封装任务，重置了FutureTask的done方法(done方法在FutureTask的run方法中被间接调用)，获取结果并发送消息到定义AsyncTask的线程中 :

1
2
3

Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
		new AsyncTaskResult<Result>(this, result));
message.sendToTarget();

处理消息时会调用消息的handler，因此onPostExecute() 在这个线程中被执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class InternalHandler extends Handler {
    ...
	public void  handleMessage(Message msg) {
            AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
            switch (msg.what) {
                case MESSAGE_POST_RESULT:
                    // There is only one result
             		result.mTask.finish(result.mData[0]); // onPostExecute在该方法中被调用
                	break;
                case MESSAGE_POST_PROGRESS:
                    result.mTask.onProgressUpdate(result.mData);
           			break;
            }
        }
	}
}

AsyncTask默认使用SerialExecutor串行执行任务，可以调用executorOnexecuteOnExecutor(Executor, …)并行运行任务.

Message

使用了消息池，避免重复创建消息。每个消息有一个next域指向下一个消息，从而组成一个单链表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
大专栏  android-interviewline">46

// android 5.1.1
public final class  [More ...] Message implements Parcelable {
  public int what;
  static final int FLAG_IN_USE = 1 << 0;
  private static final int MAX_POOL_SIZE = 50;
  int flagsl;
  Handler target;
  Runnable callback；
  ...
  public static Message  [More ...] obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }
  
    public void recycle() {
        if(isInUse()) {
            if(gCheckRecycle) {
                throw new IllegalStateExectution("This message cannot be recycled because it" 
                        + "is still in use.");
            }
          return;
        }
        recycleUnchecked();
    }
  
    void recycleUnchecked() {
        flags = FLAG_IN_USE;
        ...
        synchronized(sPoolSync) {
            if(sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }
}

- Parcel

Android中新增的几个主要特性

- Loader

https://developer.android.google.cn/guide/components/loaders.html

Android 3.0 中引入了加载器，支持轻松在 Activity 或片段中异步加载数据。 加载器具有以下特征：

• 可用于每个 Activity 和 Fragment。
• 支持异步加载数据。
• 监控其数据源并在内容变化时传递新结果。
• 在某一配置更改后重建加载器时，会自动重新连接上一个加载器的游标。 因此，它们无需重新查询其数据。

相比AsyncTask， Loader使用LoaderManager来管理Loader实例，数据的加载和更新分开实现:

• doInbackground(…)，加载放在Loader中;
• onPostExecute(…)，更新放在LoaderManager.LoaderCallback中

Loader机制

• LoderManager

  • 一种与 Activity 或 Fragment 相关联的的抽象类，用于管理一个或多个 Loader 实例。 这有助于应用管理与 Activity 或 Fragment 生命周期相关联的、运行时间较长的操作。它最常见的用法是与 CursorLoader 一起使用，但应用可自由写入其自己的加载器，用于加载其他类型的数据。

    每个 Activity 或片段中只有一个 LoaderManager。但一个 LoaderManager 可以有多个加载器。

• Loader, 负责加载数据。一种执行异步数据加载的抽象类。这是加载器的基类。 通常会使用 CursorLoader，但也可以实现自己的子类。加载器处于活动状态时，应监控其数据源并在内容变化时传递新结果。

  • AsyncTaskLoader，Loader的子类，提供AsyncTask执行任务，必须要重置的方法是loadInBackground()。
    • mTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void[]) null);
  • CursorLoader, AsyncTaskLoader 的子类，它将查询 ContentResolver 并返回一个 Cursor。此类采用标准方式为查询游标实现 Loader 协议。它是以 AsyncTaskLoader 为基础而构建，在后台线程中执行游标查询，以免阻塞应用的 UI。使用此加载器是从 ContentProvider 异步加载数据的最佳方式，而不用通过片段或 Activity 的 API 来执行托管查询。

• LoaderManager.LoaderCallback， 一种回调接口，用于客户端与 LoaderManager 进行交互。例如，您可使用 onCreateLoader() 回调方法创建新的加载器。

  • onCreateLoader(), 针对指定的 ID 进行实例化并返回新的 Loader
  • onLoadFinished()：将在先前创建的加载器完成加载时调用
  • onLoaderReset()：将在先前创建的加载器重置且其数据因此不可用时调用

加载器（特别是 CursorLoader）在停止运行后，仍需保留其数据。这样，应用即可保留 Activity 或片段的 onStop() 和 onStart() 方法中的数据。当用户返回应用时，无需等待它重新加载这些数据。您可使用 LoaderManager.LoaderCallbacks 方法了解何时创建新加载器，并告知应用何时停止使用加载器的数据。

Loader 与 AsyncTask

Loader提供了LoaderManager与Activity或Fragment关联，Activity/Fragment的生命周期中管理了LoaderManager.当配置发生变化时，Activity会在销毁前保存LoaderManager，并在重建后恢复LoaderManager。

1
2
3
4
5

LoaderManager给Activity提供了管理自己的一些方法；同时主动管理了对应的Loader，它把每一个Loader封装为LoadInfo对象，同时它负责主动调运管理Loader的startLoading()、stopLoading()、,forceLoad()等方法。
由于整个Activity和Fragment主动管理了Loader，所以关于Loader的释放（譬如Cursor要要主动关闭游标的等，文件流要置空等）不需要我们人为处理，Loader会帮我们很好的处理的；同时特别注意，对于CursorLoader，当我们数据源发生变化时Loader框架会通过ContentObserver调用onContentChanged的forceLoad方法重新请求数据进行回调刷新。
作者：Tamic
链接：http://www.jianshu.com/p/385327e35711

而AsyncTask则没有绑定到所在的Activity的生命管理周期中，当配置发生改变时Activity会被销毁，AsyncTask仍然存活，它就可能会对旧的被销毁的Activity执行UI更新，从而引发异常。此外，这也阻止了对旧的Activity进行垃圾回收。

An Loader Example

https://github.com/android-samples/android-loader

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

// Loader负责加载数据
class BigDataLoader extends AsyncTaskLoader<BigData>{
	public BigDataLoader(Context context) {
		super(context);
		Log.d("test", "...BigDataLoader.");
	}
	
	public BigData loadInBackground() {
		// BigData構築
		Log.d("test", "...loadInBackground.");
		BigData data = new BigData();
		data.load();
		return data;
	}
}
// 实现了LoaderCallbacks<>接口，负责创建Loader, loader加载完成后的更新操作
public class MainActivity extends Activity implements LoaderCallbacks<BigData> {
	
	public Loader<BigData> onCreateLoader(int id, Bundle args) {
		Log.d("test", "------------onCreateLoader");
		BigDataLoader loader = new BigDataLoader(this.getApplication());
		loader.forceLoad();
		return loader;
	}
	
	public void onLoadFinished(Loader<BigData> loader, BigData data) {
		Log.d("test", "------------onLoadFinished");
		TextView textView = (TextView)findViewById(R.id.textView1);
		textView.setText(data.at(0));
		ProgressBar progress = (ProgressBar)findViewById(R.id.progressBar1);
		progress.setVisibility(View.GONE);	
	}
	
	public void onLoaderReset(Loader<BigData> loader) {
		Log.d("test", "------------onLoaderReset");
	}
    //---------MainActivity Methods
    public void buttonMethodRestart(View button){
		ProgressBar progress = (ProgressBar)findViewById(R.id.progressBar1);
		progress.setVisibility(View.VISIBLE);
    	getLoaderManager().restartLoader(0, null, this);
    }
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		getLoaderManager().initLoader(0, null, this);
	}

Loader 的实现

Loader

使用了观察者模式，提供registerListener方法

1
2
3
4
5
6
7
8
9
10
11
12
13

public class Loader<D> {
    ...
    public interface OnLoadCompleteListener<D> {
        public void onLoadComplete(Loader<D> loader, D data);
    }
    public void registerListener(int id, OnLoadCompleteListener<D> listener){...}4
    public boolean onStared();
    public boolean onReset();
    public void onStartLoading();
    public void onStopLoading();
    public void onAbandon();
  	...
}

AsyncTaskLoader

使用AsyncTask完成load任务，AsyncTask中的Executor默认是ThreadPoolExecutor。

数据加载完成会调用OnLoadCompleteListener对象的onLoadComplete()方法, 在LoaderManager中，该listener使用了LoaderManager.LoaderCallbacks类型对象。

LoaderManager

管理Loader，提供了一些Activity管理自己的方法。

- Fragment

图片加载框架

http://www.jianshu.com/p/3ac30878c72c

UniversalImageLoader

https://github.com/nostra13/Android-Universal-Image-Loader

• ImageLoader图片加载器，对外的主要 API，采取了单例模式，用于图片的加载和显示。

• Memory Cache, 使用LRU算法，即最近最少使用算法， 使用LinkedHashMap作为存储结构

• DiskCache, 默认使用LruDiskCache算法

• 图片加载过程

  • 1 2 3 4 5 6 7 8 9

    1.判断图片的内存缓存是否存在，若存在直接执行步骤 8； 2.判断图片的磁盘缓存是否存在，若存在直接执行步骤 5； 3.ImageDownloader从网络上下载图片； 4.将图片缓存在磁盘上； 5.ImageDecoder将图片 decode 成 bitmap 对象； 6.BitmapProcessor根据DisplayImageOptions配置对图片进行预处理(Pre-process Bitmap)； 7.将 bitmap 对象缓存到内存中； 8.根据DisplayImageOptions配置对图片进行后处理(Post-process Bitmap)； 9.执行DisplayBitmapTask将图片显示在相应的控件上。

Picasso

https://github.com/square/picasso

Square公司开源的一个Android图片加载框架

使用：

1
2
3
4

Picasso.with(this).load("url").placeholder(R.mipmap.ic_default).into(imageView);
/* 
Picasso.with(Context),单例模式，返回单个Picasso对象, 
Picasso对象的创建 : newBuilder(context).build();

原理

• Downloader
  • DownLoader就是下载用的工具类，在Picasso当中，如果OKHttp可以使用的话，就会默认使用OKHttp，如果无法使用的话，就会使用UrlConnectionDownloader(默认使用HttpURLConnection实现)。

• Cache

  • 默认实现为LruCache，就是使用LinkedHashMap实现的一个Cache类，注意的一个地方就是，在其他的地方，我们一般默认的是限制的capacity，但是这个地方我们是限制的总共使用的内存空间。

• ExecutorService

  默认的实现为PicassoExecutorService，该类也比较简单，其实就是ThreadPoolExecutor，在其功能的基础上继续封装，在其中有一个比较细心的功能就是，Picasso通过PicassoExecutorService设置线程数量，来调整在2G/3G/4G/WiFi不同网络情况下的不同表现。

Glide

https://github.com/facebook/fresco

Google的一位员工基于Picasso实现。

Fresco 是 Facebook 出品。Fresco 将图片放到一个特别的内存区域叫 Ashmem 区，就是属于 Native 堆，图片将不再占用 App 的内存，Java 层对此无能为力，这里是属于 C++ 的地盘，所以能大大的减少 OOM。

推荐在主要都是图片的app中使用，一般的app使用Glide和Picasso就够了

• Fresco在磁盘缓存方面，Picasso 只会缓存原始尺寸的图片，而 Glide 缓存的是多种规格，也就意味着 Glide 会根据你 ImageView 的大小来缓存相应大小的图片尺寸，比如你 ImageView 大小是200200，原图是 400400 ，而使用 Glide 就会缓存 200*200 规格的图
• 最重要的一个特性是 Glide 支持加载 Gif 动态图，而 Picasso 不支持该特性。
• 除此之外，还有很多其他配置选项的增加。

图片缓存

- LruCache

https://developer.android.google.cn/reference/android/util/LruCache.html

Android3.0引入LruCache（Least Recent Used）进行图片缓存。LruCache内部使用LinkedHashMap，持有缓存对象的强引用，没当对象被访问时，便会移到队列的头部，添加对象时如果队列满了，则移除队列尾部的对象从而可以被GC回收。

LruCache的使用，需要重置sizeOf(K, V)方法：

1
2
3
4
5
6

int cacheSize = 4 * 1024 * 1024; // 4MiB
LruCache<String, Bitmap> bitmapCache = new LruCache<String, Bitmap>(cacheSize) {
  protected int sizeOf(String key, Bitmap value) {
    return value.getByteCount();
  }
}

如果缓存的对象还持有其他需要显式释放的资源，重置enteryRemoved(boolean, K, V, V)方法。

LruCache是线程安全的 ，对操使用了同步。

1
2
3
4
5

synchronized (cache) {
  if (cache.get(key) == null) {
    cache.put(key, value);
  }
}

不允许使用Null作为key或者value，从而get，put的返回值没有歧义，null值代表不存在。

- DiskLruCache

LruCache之LruCache分析. http://www.jianshu.com/p/4aaf93a67fc3 .2016

DiskLruCache并不是Android SDK中的类。不明白为啥，官方只进行推荐，为何不加入SDK中.

https://stackoverflow.com/questions/28435860/what-does-oat-mean

We know that Dalvik uses APK, DEX, and ODEX files.And we know this abbreviation means via AOSP source or Developers site.

(like this - https://source.android.com/devices/tech/dalvik/dex-format.html)

• DEX means Dalvik EXcutable file.
• ODEX means Optimized Dalvik EXcutable file.
• APK means Android PacKage.

ART (Android RunTime) uses OAT and ART,

Before AOT came to Android, dexopt was used to optimize DEX to ODEX (optimized DEX) which contains the optimized bytecode.

With AOT, dex2oat is used to optimize and compile DEX into an OAT file which may contain machine code in the ELF format.

oat- It’s Of Ahead Time, a silly reordering of Ahead Of Time.

Android开发——JVM、Dalvik以及ART的区别. http://blog.csdn.net/seu_calvin/article/details/52354964

Dalvik是Google公司自己设计用于Android平台的Java虚拟机。它可以支持已转换为.dex(即Dalvik Executable)格式的Java应用程序的运行，.dex格式是专为Dalvik应用设计的一种压缩格式，适合内存和处理器速度有限的系统。

1. Dalvik与JVM的区别

（1）Dalvik指令集是基于寄存器的架构，执行特有的文件格式——dex字节码（适合内存和处理器速度有限的系统）。而JVM是基于栈的。相对于基于栈的JVM而言，基于寄存器的Dalvik VM实现虽然牺牲了一些平台无关性，但是它在代码的执行效率上要更胜一筹。

（2）每一个Android 的App是独立跑在一个VM中的。因此一个App crash只会影响到自身的VM，不会影响到其他。Dalvik经过优化，允许在有限的内存中同时运行多个虚拟机的实例，并且每一个 Dalvik应用作为一个独立的Linux进程执行。

2. Dalvik与ART的区别

（1）在Dalvik下，应用每次运行都需要通过即时编译器（JIT）将字节码转换为机器码，即每次都要编译加运行，这虽然会使安装过程比较快，但是会拖慢应用的运行效率。而在ART 环境中，应用在第一次安装的时候，字节码就会预编译（AOT）成机器码，这样的话，虽然设备和应用的首次启动（安装慢了）会变慢，但是以后每次启动执行的时候，都可以直接运行，因此运行效率会提高。

（2）ART占用空间比Dalvik大（原生代码占用的存储空间更大，字节码变为机器码之后，可能会增加10%-20%），这也是著名的“空间换时间大法”。

（4）预编译也可以明显改善电池续航，因为应用程序每次运行时不用重复编译了，从而减少了 CPU 的使用频率，降低了能耗。

dex2oat对应用启动性能的影响

http://blog.csdn.net/azhengye/article/details/73000419

chrome启动慢，没有生成odex文件

原来之前的同事在做开机优化时做了一个功能，将非重要应用的dex2oat操作放在了开机之后。可是没有考虑好更新应用时的逻辑处理，导致了问题的发生

Android 平台侧性能优化之应用启动[问题已解决]

http://blog.csdn.net/azhengye/article/details/67054941

systrace位于/platform-tools/systrace目录下

Email启动比参考机慢，参考机采用了后台一直运行的方式，相当于拿app的冷启动比参考机的热启动

为什么安卓手机升级系统后，首次启动会比较慢？

https://zhuanlan.zhihu.com/p/28951050

Android中的设计模式

• Singleton, InputMethodManager
• Adapter， 各种view的adapter, 随处可见，尤其是涉及到数据状态发生变化需要通知的情况下
• 观察者模式，各种listenre
• 责任链模式， 事件处理
• 工厂模式
• 组合模式， View ViewGroup
• 命令模式，把请求封装成对象
• Builder， Dialog

其他

1. 60+ Android Secret Codes 2017 (Hidden Codes …*

   how to use top best **android secret codes 2017 motorola samsung vivo sony mi htc lg zte secret codes for android phone # codes and hacks working all mobile *code** pdf …

   https://safetricks.org/**android**-secret-**codes***2017-10-27*

2. ?