摘抄于大学期间记录在QQ空间的一篇自学笔记，当前清理空间，本来想直接删除掉的，但是感觉有些舍不得，因此先搬移过来。
Android导入已有外部数据库
2015.06.26在QQ空间记录：在Android中不能直接打开res aw目录中的数据库文件
而需要在程序第一次启动时将该文件复制到手机内存或SD卡的某个目录中，
然后再打开该数据库文件。复制的基本方法是使用getResources().openRawResource方法获
得res aw目录中资源的 InputStream对象，然后将该InputStream对象中的数据写入其他的目录中
相应文件中。在Android SDK中可以使用SQLiteDatabase.openOrCreateDatabase方法来打开任
意目录中的SQLite数据库文件。
我们平时见到的android数据库操作一般都是在程序开始时创建一个空的数据库，然后再进行相关操作。如果我们需要使用一个已有数据的数据库怎么办呢？
我 们都知道android系统下数据库应该存放在 /data/data/com.*.*(package name)/ 目录下，所以我们需要做的是把已有的数据库传入那个目录下。操作方法是用FileInputStream读取原数据库，再用 FileOutputStream把读取到的东西写入到那个目录。
操作方法：1. 把原数据库包括在项目源码的 res/raw 目录下，然后建立一个DBManager类，代码如下：
java
packagecom.android.ImportDatabase;
importjava.io.File;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.InputStream;
importandroid.content.Context;
importandroid.database.sqlite.SQLiteDatabase;
importandroid.os.Environment;
importandroid.util.Log;
publicclassDBManager {
privatefinalintBUFFER_SIZE =400000;
publicstaticfinalString DB_NAME ="countries.db";//保存的数据库文件名
publicstaticfinalString PACKAGE_NAME ="com.android.ImportDatabase";
publicstaticfinalString DB_PATH ="/data"
+ Environment.getDataDirectory().getAbsolutePath() +"/"
+ PACKAGE_NAME; //在手机里存放数据库的位置
privateSQLiteDatabase database;
privateContext context;
DBManager(Context context) {
this.context = context;
}
publicvoidopenDatabase() {
this.database =this.openDatabase(DB_PATH +"/"+ DB_NAME);
}
privateSQLiteDatabase openDatabase(String dbfile) {
try{
if(!(newFile(dbfile).exists())) { //判断数据库文件是否存在，若不存在则执行导入，否则直接打开数据库
InputStream is =this.context.getResources().openRawResource(
R.raw.countries);//欲导入的数据库
FileOutputStream fos =newFileOutputStream(dbfile);
byte[] buffer =newbyte[BUFFER_SIZE];
intcount =0;
while((count = is.read(buffer)) >0) {
fos.write(buffer,0, count);
}
fos.close();
is.close();
}
SQLiteDatabase db = SQLiteDatabase.openOrCreateDatabase(dbfile,
null);
returndb;
}catch(FileNotFoundException e) {
Log.e("Database","File not found");
e.printStackTrace();
}catch(IOException e) {
Log.e("Database","IO exception");
e.printStackTrace();
}
returnnull;
}
//do something else here<br>
publicvoidcloseDatabase() {
this.database.close();
}
}然后在程序的首个Activity中示例化一个DBManager对象，然后对其执行openDatabase方法就可以完成导入了，可以把一些要 对数据库进行的操作写在DBManager类里，然后通过DBManager类的对象调用；也可以在完成导入之后通过一个SQliteDatabase类 的对象打开数据库，并执行操作。
我的做法是 在程序的首个Activity中导入数据库：
java
packagecom.android.ImportDatabase;
importandroid.app.Activity;
importandroid.content.Intent;
importandroid.os.Bundle;
publicclassRootViewextendsActivity {
publicDBManager dbHelper;
@Override
publicvoidonCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
dbHelper =newDBManager(this);
dbHelper.openDatabase();
dbHelper.closeDatabase();
}
}此时在DDMS中可以查看到，外部数据库已经成功导入
在需要使用数据库的类里：
java
packagecom.android.ImportDatabase;
importjava.util.ArrayList;
importandroid.app.Activity;
importandroid.database.Cursor;
importandroid.database.sqlite.SQLiteDatabase;
importandroid.os.Bundle;
publicclassTaxiActivityextendsActivity {
privateSQLiteDatabase database;
ArrayList<CityClass> CITY;
@Override
publicvoidonCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
database = SQLiteDatabase.openOrCreateDatabase(DBManager.DB_PATH +"/"+ DBManager.DB_NAME,null);
CITY = getCity();
// do something with CITY
database.close();
}
privateArrayList<CityClass> getCity() {
Cursor cur = database.rawQuery("SELECT city.id_city, city.name FROM taxi, city WHERE city.id_city = taxi.id_city GROUP BY city.id_city",null);
if(cur !=null) {
intNUM_CITY = cur.getCount();
ArrayList<CityClass> taxicity =newArrayList<CityClass>(NUM_CITY);
if(cur.moveToFirst()) {
do{
String name = cur.getString(cur.getColumnIndex("name"));
intid = cur.getInt(cur.getColumnIndex("id_city"));
CityClass city =newCityClass("",0);
System.out.println(name); //额外添加一句，把select到的信息输出到Logcat
city.city_name = name;
city.city_id = id;
taxicity.add(city);
}while(cur.moveToNext());
}
returntaxicity;
}else{
returnnull;
}
}
}Android之自定义控件
开发自定义控件的步骤:
- 了解View的工作原理
- 编写继承自View的子类
- 为自定义View类增加属性
- 绘制控件
- 响应用户消息
- 自定义回调函数
1、View结构原理
Android系统的视图结构的设计也采用了组合模式，即View作为所有图形的基类，Viewgroup对View继承扩展为视图容器类。
View定义了绘图的基本操作
基本操作由三个函数完成：measure()、layout()、draw()，其内部又分别包含了onMeasure()、onLayout()、onDraw()三个子方法。具体操作如下：
1.1、measure操作
measure操作主要用于计算视图的大小，即视图的宽度和长度。在view中定义为final类型，要求子类不能修改。measure()函数中又会调用下面的函数：
onMeasure()，视图大小的将在这里最终确定，也就是说measure只是对onMeasure的一个包装，子类可以覆写onMeasure()方法实现自己的计算视图大小的方式，并通过setMeasuredDimension(width, height)保存计算结果。
1.2、layout操作
layout操作用于设置视图在屏幕中显示的位置。在view中定义为final类型，要求子类不能修改。layout()函数中有两个基本操作：
- setFrame（l,t,r,b），l,t,r,b即子视图在父视图中的具体位置，该函数用于将这些参数保存起来；
- onLayout()，在View中这个函数什么都不会做，提供该函数主要是为viewGroup类型布局子视图用的；
1.3、draw操作
draw操作利用前两部得到的参数，将视图显示在屏幕上，到这里也就完成了整个的视图绘制工作。子类也不应该修改该方法，因为其内部定义了绘图的基本操作：
（1）绘制背景；
（2）如果要视图显示渐变框，这里会做一些准备工作；
（3）绘制视图本身，即调用onDraw()函数。在view中onDraw()是个空函数，也就是说具体的视图都要覆写该函数来实现自己的显示（比如TextView在这里实现了绘制文字的过程）。而对于ViewGroup则不需要实现该函数，因为作为容器是"没有内容"的，其包含了多个子view，而子View已经实现了自己的绘制方法，因此只需要告诉子view绘制自己就可以了，也就是下面的dispatchDraw()方法;
（4）绘制子视图，即dispatchDraw()函数。在view中这是个空函数，具体的视图不需要实现该方法，它是专门为容器类准备的，也就是容器类必须实现该方法；
（5）如果需要（应用程序调用了setVerticalFadingEdge或者setHorizontalFadingEdge），开始绘制渐变框；
（6）绘制滚动条；
从上面可以看出自定义View需要最少覆写onMeasure()和onDraw()两个方法。
2、View类的构造方法
创建自定义控件的3种主要实现方式:
1）继承已有的控件来实现自定义控件: 主要是当要实现的控件和已有的控件在很多方面比较类似, 通过对已有控件的扩展来满足要求。
2）通过继承一个布局文件实现自定义控件，一般来说做组合控件时可以通过这个方式来实现。
注意此时不用onDraw方法，在构造广告中通过inflater加载自定义控件的布局文件，再addView(view)，自定义控件的图形界面就加载进来了。
3）通过继承view类来实现自定义控件，使用GDI绘制出组件界面，一般无法通过上述两种方式来实现时用该方式。
3、自定义View增加属性的两种方法：
1）在View类中定义。通过构造函数中引入的AttributeSet 去查找XML布局的属性名称，然后找到它对应引用的资源ID去找值。
案例：实现一个带文字的图片（图片、文字是onDraw方法重绘实现）
java
public class MyView extends View {
private String mtext;
private int msrc;
public MyView(Context context) {
super(context);
}
public MyView(Context context, AttributeSet attrs) {
super(context, attrs);
int resourceId = 0;
int textId = attrs.getAttributeResourceValue(null, "Text",0);
int srcId = attrs.getAttributeResourceValue(null, "Src", 0);
mtext = context.getResources().getText(textId).toString();
msrc = srcId;
}
@Override
protected void onDraw(Canvas canvas) {
Paint paint = new Paint();
paint.setColor(Color.RED);
InputStream is = getResources().openRawResource(msrc);
Bitmap mBitmap = BitmapFactory.decodeStream(is);
int bh = mBitmap.getHeight();
int bw = mBitmap.getWidth();
canvas.drawBitmap(mBitmap, 0,0, paint);
//canvas.drawCircle(40, 90, 15, paint);
canvas.drawText(mtext, bw/2, 30, paint);
}
}
// 布局文件
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
<com.example.myimageview2.MyView
android:id="@+id/myView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
Text="@string/hello_world"
Src="@drawable/xh"/>
</LinearLayout>2）通过XML为View注册属性。与Android提供的标准属性写法一样。
案例: 实现一个带文字说明的ImageView (ImageView+TextView组合，文字说明，可在布局文件中设置位置)
java
public class MyImageView extends LinearLayout {
public MyImageView(Context context) {
super(context);
}
public MyImageView(Context context, AttributeSet attrs) {
super(context, attrs);
int resourceId = -1;
TypedArray typedArray = context.obtainStyledAttributes(attrs,
R.styleable.MyImageView);
ImageView iv = new ImageView(context);
TextView tv = new TextView(context);
int N = typedArray.getIndexCount();
for (int i = 0; i < N; i++) {
int attr = typedArray.getIndex(i);
switch (attr) {
case R.styleable.MyImageView_Oriental:
resourceId = typedArray.getInt(
R.styleable.MyImageView_Oriental, 0);
this.setOrientation(resourceId == 1 ? LinearLayout.HORIZONTAL
: LinearLayout.VERTICAL);
break;
case R.styleable.MyImageView_Text:
resourceId = typedArray.getResourceId(
R.styleable.MyImageView_Text, 0);
tv.setText(resourceId > 0 ? typedArray.getResources().getText(
resourceId) : typedArray
.getString(R.styleable.MyImageView_Text));
break;
case R.styleable.MyImageView_Src:
resourceId = typedArray.getResourceId(
R.styleable.MyImageView_Src, 0);
iv.setImageResource(resourceId > 0 ?resourceId:R.drawable.ic_launcher);
break;
}
}
addView(iv);
addView(tv);
typedArray.recycle();
}
}
// attrs.xml进行属性声明， 文件放在values目录下
<?xml version="1.0" encoding="utf-8"?>
<resources>
<declare-styleable name="MyImageView">
<attr name="Text" format="reference|string"></attr>
<attr name="Oriental" >
<enum name="Horizontal" value="1"></enum>
<enum name="Vertical" value="0"></enum>
</attr>
<attr name="Src" format="reference|integer"></attr>
</declare-styleable>
</resources>
// MainActivity的布局文件：先定义命名空间
// xmlns:uview="http://schemas.android.com/apk/res/com.example.myimageview2"
// com.example.myimageview2为你在manifest中定义的包名）然后可以像使用系统的属性一样使用：uview:Oriental="Vertical"
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:uview="http://schemas.android.com/apk/res/com.example.myimageview2"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity" >
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/hello_world" />
<com.example.myimageview2.MyImageView
android:id="@+id/myImageView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
uview:Text="这是一个图片说明"
uview:Src="@drawable/tw"
uview:Oriental="Vertical">
</com.example.myimageview2.MyImageView>
</LinearLayout>4、控件绘制 onDraw()
5、自定义View的方法
onFinishInflate() 回调方法，当应用从XML加载该组件并用它构建界面之后调用的方法
onMeasure() 检测View组件及其子组件的大小
onLayout() 当该组件需要分配其子组件的位置、大小时
onSizeChange() 当该组件的大小被改变时
onDraw() 当组件将要绘制它的内容时
onKeyDown 当按下某个键盘时
onKeyUp 当松开某个键盘时
onTrackballEvent 当发生轨迹球事件时
onTouchEvent 当发生触屏事件时
onWindowFocusChanged(boolean) 当该组件得到、失去焦点时
onAtrrachedToWindow() 当把该组件放入到某个窗口时
onDetachedFromWindow() 当把该组件从某个窗口上分离时触发的方法
onWindowVisibilityChanged(int): 当包含该组件的窗口的可见性发生改变时触发的方法
Android之VMware加载
参考链接：http://jingyan.baidu.com/article/36d6ed1f24b0c81bce488376.html;
2016.07.05，大家好,今天给大家带来一篇安装安卓虚拟机的教程!好了,现在开始我们的教程!
1、安装准备
- Android 4.3安装镜像（文件名：android-x86-4.3-20130725.iso）
- Oracle VM VirtualBox(文件名:VirtualBox-4.2.16-86992-Win.exe)
- Oracle VM VirtualBox汉化补丁(文件名:VirtualBox-4.2.16汉化补丁.exe)
2、开始安装
打开Oracle VM VirtualBox(Windows Vista及以上用户请使用管理员身份运行),单击"新建", 类型选择BSD,版本选择FreeBSD,名称自定!
选择下一步,默认内存是128MB,个人认为太少,2G物理内存用户推荐850
在选择下一步
,点击创建!个人推荐使用VMDK,VDI也可以,在点击下一步
选择动态分配,点击下一步
默认是2GB,强烈推荐使用8GB!点击创建
完成后会回到主画面
右击你创建的虚拟机,选择设置,点击系统选项卡,去掉软盘的√,在移到最下面!
点击存储选项卡,选择空的光驱,点击设置虚拟CD/DVD驱动器 按钮,选择我们下载的安卓4.3ISO镜像,然后确定退出设置。
在主画面选中你创建的虚拟机,点击上方的启动按钮
之后会弹出一系列的相信,选确定即可!按↓选择最后一个,点击回车进入安装
选OK,按回车进入分区画面
按→选New,按回车
选Primary,按回车设置分区大小,直间回车就行
选Bootable,按回车,在选择Write,回车输入yes再回车,写入分区完毕后,选Quit按回车退出,我们就有了一个分区
选择我们的分区按回车键进入格式化界面,选ext3,按回车进行格式化
一直选择Yes!
选ext3硬盘格式一般不需要设置SD卡,所以直接移除光驱,再重启即可!
3、安装成功
看见安卓启动Logo了,激动有木有
Android常用的开源框架
2016.12.06，在QQ空间记录的一些三方开源框架库，直接参考如下链接：
https://blog.csdn.net/caoyouxing/article/details/42418591
Android之后台运行
2017.01.04，在QQ空间记录的关于后台运行相关总结：
参考：Android 中的 Service 全面总结_android中的service-CSDN博客
http://blog.csdn.net/yyingwei/article/details/8509402http://www.2cto.com/kf/201502/374946.htmlhttp://blog.csdn.net/loongggdroid/article/details/17616509 http://www.2cto.com/kf/201606/519729.html http://blog.csdn.net/lwyygydx/article/details/50716182
1、前台服务
发现在手机休眠一段时间后（1-2小时），后台运行的服务被强行kill掉，有可能是系统回收内存的一种机制，要想避免这种情况可以通过startForeground让服务前台运行，当stopservice的时候通过stopForeground去掉。
以下是android官方描述：
A foreground service is a service that's considered to be something the user is actively aware of and thus not a candidate for the system to kill when low on memory. A foreground service must provide a notification for the status bar, which is placed under the "Ongoing" heading, which means that the notification cannot be dismissed unless the service is either stopped or removed from the foreground.
For example, a music player that plays music from a service should be set to run in the foreground, because the user is explicitly aware of its operation. The notification in the status bar might indicate the current song and allow the user to launch an activity to interact with the music player.
To request that your service run in the foreground, call startForeground(). This method takes two parameters: an integer that uniquely identifies the notification and the Notification for the status bar. For example:
Notification notification = new Notification(R.drawable.icon, getText(R.string.ticker_text), System.currentTimeMillis());Intent notificationIntent = new Intent(this, ExampleActivity.class);PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);notification.setLatestEventInfo(this, getText(R.string.notification_title), getText(R.string.notification_message), pendingIntent);startForeground(ONGOING_NOTIFICATION, notification);
To remove the service from the foreground, call stopForeground(). This method takes a boolean, indicating whether to remove the status bar notification as well. This method does not stop the service. However, if you stop the service while it's still running in the foreground, then the notification is also removed.
Note: The methods startForeground() and stopForeground() were introduced in Android 2.0 (API Level 5). In order to run your service in the foreground on older versions of the platform, you must use the previoussetForeground() method---see the startForeground() documentation for information about how to provide backward compatibility.
For more information about notifications, see Creating Status Bar Notifications.
要想实现需求，我们只需要在onStartCommand里面调用 startForeground，然后再onDestroy里面调用stopForeground即可！
实际情况就譬如手机里面的音乐播放器一样，不管手机如何休眠，只要开始播放音乐了，就不会kill掉这个服务，一旦停止播放音乐，服务就可能被清掉。代码其原理通过发送通知Notification 使其应用挂在屏幕顶端，这样应用切入后台因为屏幕顶端还有通知的存在大大提高应用的优先级避免被系统干掉
java
public void onCreate() {
super.onCreate();
DebugLog.printLogE("BluetoothDeviceService-onCreate");
initBluetooth();
initForeground();
}
/**前台服务初始化*/
private NotificationManager notificationManager;
private Notification notification;
private void initForeground(){
notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE); //获取通知管理器对象
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(BluetoothDeviceService.this);
Intent resultIntent = new Intent(BluetoothDeviceService.this, HomeActivity.class); //构建一个Intent
PendingIntent resultPendingIntent = PendingIntent.getActivity(BluetoothDeviceService.this, 0, resultIntent, PendingIntent.FLAG_UPDATE_CURRENT);//封装一个Intent
mBuilder.setContentIntent(resultPendingIntent); // 设置通知主题的意图
notification = mBuilder.build();
}
/**
* 设置前台服务
* @param isForeground true开始前台服务 false停止前台服务
*/
private void setServiceForeground(boolean isForeground){
if(isForeground) {
notificationManager.notify(1, notification);
startForeground(1, notification);
}else{
notificationManager.cancel(1);
stopForeground(true);
}
}2、Notification
这篇博客讲解一下在Android中使用Notification提示消息给用户，Notification是一种具有全局效果的通知，程序一般通过NotificationManager服务来发送Notification。在本篇博客中，将介绍Notification的常规使用，以及自定义方式的使用，对于每种不同的方式，都提供示例展示效果。
Notification，俗称通知，是一种具有全局效果的通知，它展示在屏幕的顶端，首先会表现为一个图标的形式，当用户向下滑动的时候，展示出通知具体的内容。
注意：因为一些Android版本的兼容性问题，对于Notification而言，Android3.0是一个分水岭，在其之前构建Notification推荐使用Notification.Builder构建，而在Android3.0之后，一般推荐使用NotificationCompat.Builder构建。本文的所有代码环境均在4.3中完成，如果使用4.1一下的设备测试，请注意兼容性问题。
通知一般通过NotificationManager服务来发送一个Notification对象来完成，NotificationManager是一个重要的系统级服务，该对象位于应用程序的框架层中，应用程序可以通过它像系统发送全局的通知。这个时候需要创建一个Notification对象，用于承载通知的内容。但是一般在实际使用过程中，一般不会直接构建Notification对象，而是使用它的一个内部类NotificationCompat.Builder来实例化一个对象（Android3.0之下使用Notification.Builder），并设置通知的各种属性，最后通过NotificationCompat.Builder.build()方法得到一个Notification对象。当获得这个对象之后，可以使用NotificationManager.notify()方法发送通知。
NotificationManager类是一个通知管理器类，这个对象是由系统维护的服务，是以单例模式获得，所以一般并不直接实例化这个对象。在Activity中，可以使用Activity.getSystemService(String)方法获取NotificationManager对象，Activity.getSystemService(String)方法可以通过Android系统级服务的句柄，返回对应的对象。在这里需要返回NotificationManager，所以直接传递Context.NOTIFICATION_SERVICE即可。
虽然通知中提供了各种属性的设置，但是一个通知对象，有几个属性是必须要设置的，其他的属性均是可选的，必须设置的属性如下：
- 小图标，使用setSamllIcon()方法设置。
- 标题，使用setContentTitle()方法设置。
- 文本内容，使用setContentText()方法设置。
更新与移除通知
在使用NotificationManager.notify()发送通知的时候，需要传递一个标识符，用于唯一标识这个通知。对于有些场景，并不是无限的添加新的通知，有时候需要更新原有通知的信息，这个时候可以重写构建Notification，而使用与之前通知相同标识符来发送通知，这个时候旧的通知就被被新的通知所取代，起到更新通知的效果。
对于一个通知，当展示在状态栏之后，但是使用过后，如何取消呢？Android为我们提供两种方式移除通知，一种是Notification自己维护，使用setAutoCancel()方法设置是否维护，传递一个boolean类型的数据。另外一种方式使用NotificationManager通知管理器对象来维护，它通过notify()发送通知的时候，指定的通知标识Id来操作通知，可以使用cancel(int)来移除一个指定的通知，也可以使用cancelAll()移除所有的通知。
3、PendingIntent
pendingIntent字面意义：等待的，未决定的Intent。
要得到一个pendingIntent对象，使用方法类的静态方法 ++getActivity(Context, int, Intent, int),getBroadcast(Context, int, Intent, int),++ ++getService(Context, int, Intent, int) 分别对应着Intent的3个行为，跳转到一个activity组件、打开一个广播组件和打开一个服务组件。++
参数有4个，比较重要的事第三个和第一个，其次是第四个和第二个。可以看到，要得到这个对象，必须传入一个Intent作为参数，必须有context作为参数。
pendingIntent是一种特殊的Intent。主要的区别在于Intent的执行立刻的，而pendingIntent的执行不是立刻的。pendingIntent执行的操作实质上是参数传进来的Intent的操作，但是使用pendingIntent的目的在于它所包含的Intent的操作的执行是需要满足某些条件的。
主要的使用的地方和例子：通知Notificatio的发送，短消息SmsManager的发送和警报器AlarmManager的执行等等。
Android的状态栏通知(Notification)
如果需要查看消息，可以拖动状态栏到屏幕下方即可查看消息。
步骤：
1获取通知管理器NotificationManager，它也是一个系统服务
2建立通知Notification notification = new Notification(icon, null, when);
3为新通知设置参数(比如声音，震动，灯光闪烁)
4把新通知添加到通知管理器
发送消息的代码如下：
//获取通知管理器
NotificationManager mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE)
int icon = android.R.drawable.stat_notify_chat;
long when = System.currentTimeMillis();//通知发生的时间为系统当前时间
//新建一个通知，指定其图标和标题
Notification notification = new Notification(icon, null, when);//第一个参数为图标,第二个参数为短暂提示标题,第三个为通知时间
notification.defaults = Notification.DEFAULT_SOUND;//发出默认声音
notification.flags |= Notification.FLAG_AUTO_CANCEL;//点击通知后自动清除通知
Intent openintent = new Intent(this, OtherActivity.class);
PendingIntent contentIntent = PendingIntent.getActivity(this, 0, openintent, 0);//当点击消息时就会向系统发送openintent意图
notification.setLatestEventInfo(this, "标题", "我是内容", contentIntent);
mNotificationManager.notify(0, notification);//第一个参数为自定义的通知唯一标识
重点是setLatestEventInfo( )方法的最后一个参数！！！！它是一个PendingIntent!!!!!!!!!
这里使用到了PendingIntent(pend本意是待定，不确定的意思)
PendingIntent可以看作是对Intent的包装。PendingIntent主要持有的信息是它所包装的Intent和当前Application的Context。正由于PendingIntent中保存有当前Application的Context，使它赋予带他程序一种执行的Intent的能力，就算在执行时当前Application已经不存在了，也能通过存在PendingIntent里的Context照样执行Intent。
PendingIntent的一个很好的例子：
SmsManager的用于发送短信的方法：
sendTextMessage(destinationAddress, scAddress, text, sentIntent, deliveryIntent);
第一个参数：destinationAddress对方手机号码
第二个参数：scAddress短信中心号码一般设置为空
第三个参数：text短信内容
第四个参数：sentIntent判断短信是否发送成功，如果你没有SIM卡，或者网络中断，则可以通过这个itent来判断。注意强调的是"发送"的动作是否成功。那么至于对于对方是否收到，另当别论
第五个参数：deliveryIntent当短信发送到收件人时，会收到这个deliveryIntent。即强调了"发送"后的结果
就是说是在"短信发送成功"和"对方收到此短信"才会激活 sentIntent和deliveryIntent这两个Intent。这也相当于是延迟执行了Intent
上面两个例子可以理解，PendingIntent就是一个可以在满足一定条件下执行的Intent，它相比于Intent的优势在于自己携带有Context对象，这样他就不必依赖于某个activity才可以存在。
4、APP后台运行点击桌面图标重启APP
在项目中，遇到一个问题百思不得其解，那就是：我在app使用过程中，点击了home键，然后去看看微信之类的其他应用，这个时候再点击app桌面的图标，这个时候app是重新启动的，而不是从上次停止的界面开始的。
对于上面的情况，我觉得既然我的app已经在后台还运行着，为什么就不能继续重上一个界面继续运行，非得从新运行呢。然后我就去查资料解决了这个问题。首先讲讲这个现象的本质。
原因：当点击app桌面图标时，app默认是任务你要新建一个应用，而不会去判断你后台有没有再运行的相同应用。
经过实践我发现：当你点击应用桌面图标，应用会重新创建你的app的启动页，然而，你快速的点击返回按钮，你会发现你会回到上一次退出时的界面。经过查阅资料发现，系统会记录你启动acitivity的启动顺序的栈。并且把当前的启动页放到了最上方，如下图所示：
注意：资料上面说以前启动的activity都是不在了，只是系统记录了他们启动的顺序，然而你按返回键，系统就会自动的重新创建新的activity，加入当app依次启动了1到11的activity，然而，在11这个activity的时候，你点击了home键、或点击了其他软件如微信qq等，这个时候你的app进入后台，1到11的这些activity其实被系统回收了，但是系统记录了这个activity启动顺序的栈，然后当你回到这个应用时，实际上系统是重新创建了Activity11，然后点击返回键，右重新创建了Activity10,就是这样倒序 创建activity的原理。
然而，当你把App放入后台时，这个时候点击了app桌面的启动图标，这个时候系统会默认你开启一个新的应用，但是因为一个软件只能在手机上面运行一个，所以，系统发现你之前的app还在后台，这个时候系统会把新创建的activity放到了之前activity栈的顶部，如上图所示的Activity1
知道了原因之后，我们就好做处理了。
第一步：查看Activity1的启动模式，如果Activity1的启动模式为singleTask
android:launchMode=``"singleTask"//那么必须把他删除掉，或者改为"standard"
第二步：在你的app的AndroidManifest.xml文件的application标签下面设置
android:persistent="true" //持久化为 true；防止你的app挂后台被回收
第三步：在activity1的onCreate方法中设置如下方法：
java
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if ((getIntent().getFlags() & Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT) != 0) {
finish();
return;
}
setContentView(R.layout.activity1_layout);
// Regular activity creation code...
} 其实就是在setContentView()之前设置如下代码：
java
if ((getIntent().getFlags() & Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT) != 0) {
finish();
return;
}用于判断这个Activity的启动标志，看它所在的应用是不是从后台跑到前台的。如果是，则直接把它finish（）掉，然后系统会去Activity启动历史栈查询上一个activity，然后再新建它，所以还原到了我们按home键出去的那个界面。
最后通过多次测试对比发现一般正常情况下是不会出现这种现象的，而这次项目在安装的第一次出现，原来是安装完APP后会弹出完成和打开的对话框，这时打开APP程序退出后台，在点击桌面图标出现重启APP现象，如果点击完成返回到系统桌面点击桌面图标就不会出现这种情况，隐约感觉是不是点击桌面启动APP和其他方式启动APP系统内部处理方式不一样。
5、其他方式实现APP不被后台轻易杀掉
由于各种原因，在开发Android应用时会提出保证自己有一个后台一直运行的需求，如何保证后台始终运行，不被系统因为内存低杀死，不被任务管理器杀死，不被软件管家等软件杀死等等还是一个比较困难的问题。网上也有各种方案，笔者经过自己试验学习尝试总结了3中还可以的方式，记录如下。并不是绝对保证，不过确实提高了存活率不少。
方式一：service绑定通知栏成为前台服务
android中实现后台一般通过service方式，但系统本身会在内存低等情况下杀死service。通过将service绑定到notification，就成为了一个用户可见的前台服务，这样可以大大提高存活率。
具体实现方式为在service中创建一个notification，再调用void android.app.Service.startForeground(int id, Notification notification)方法运行在前台即可。
该方式基本可以保证在正常运行情况下，以及任务栏移除历史任务后（小米、魅族手机除外），service不被杀死。但是360等软件管家依然可以杀死。
方式二：AlarmManager不断启动service
该方式原理是通过定时警报来不断启动service，这样就算service被杀死，也能再启动。同时也可以监听网络切换、开锁屏等广播来启动service。
参考实现方式如下：
java
Intent intent =new Intent(mContext, MyService.class);
PendingIntent sender=PendingIntent
.getService(mContext, 0, intent, 0);
AlarmManager alarm=(AlarmManager)getSystemService(ALARM_SERVICE);
alarm.setRepeating(AlarmManager.RTC_WAKEUP,System.currentTimeMillis(),5*1000,sender);该方式基本可以保证在正常运行情况下，以及任务栏移除历史任务后（小米、魅族手机除外），service不被杀死。但是360等软件管家依然可以杀死。另外还有不断启动的逻辑处理麻烦。
方式三：通过jni调用，在c层启动多进程
该方式主要通过底层启动另外一个进程来实现。笔者猜测系统和三方软件管家杀死应用进程是通过包名相关线程等来遍历关闭。因此在c语言里启动另一个进程可以躲过杀死的命运。
该方式思路是应用通过jni调用c，再c语言中启动一个进程fork()。
该方式基本可以保证在正常运行情况下，以及任务栏移除历史任务后（小米、魅族手机除外），service不被杀死。360等软件管家也不会清理。但是带来了jni交互，稍微有点麻烦。
以上3中方式都逃不过小米、魅族手机的任务栏清理，原因需要进一步学习。
6、使用JNI开启进程方式
开发一个需要常住后台的App其实是一件非常头疼的事情，不仅要应对国内各大厂商的ROM，还需要应对各类的安全管家...虽然不断的研究各式各样的方法，但是效果并不好，比如任务管理器把App干掉，服务就起不来了...
网上搜寻一番后，主要的方法有以下几种方法，但都是治标不治本：
1、提高Service的优先级：这个，也只能说在系统内存不足需要回收资源的时候，优先级较高，不容易被回收，然并卵...
2、提高Service所在进程的优先级：效果不是很明显
3、在onDestroy方法里重启service：这个倒还算挺有效的一个方法，但是，直接干掉进程的时候，onDestroy方法都进不来，更别想重启了
4、broadcast广播：和第3种一样，没进入onDestroy，就不知道什么时候发广播了，另外，在Android4.4以上，程序完全退出后，就不好接收广播了，需要在发广播的地方特定处理
5、放到System/app底下作为系统应用：这个也就是平时玩玩，没多大的实际意义。
6、Service的onStartCommand方法，返回START_STICKY，这个也主要是针对系统资源不足而导致的服务被关闭，还是有一定的道理的。
应对的方法是有，实现起来都比较繁琐。如果你自己可以定制ROM，那就有很多种办法了，比如把你的应用加入白名单，或是多安装一个没有图标的app作为守护进程...但是，哪能什么都是定制的，对于安卓开发者来说，这个难题必须攻破~
那么，有没有办法在一个APP里面，开启一个子线程，在主线程被干掉了之后，子线程通过监听、轮询等方式去判断服务是否存在，不存在的话则开启服务。答案自然是肯定的，通过JNI的方式（NDK编程），fork()出一个子线程作为守护进程，轮询监听服务状态。守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。而守护进程的会话组和当前目录，文件描述符都是独立的。后台运行只是终端进行了一次fork，让程序在后台执行，这些都没有改变。
那么我们先来看看Android4.4的源码，ActivityManagerService（源码/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java）是如何关闭在应用退出后清理内存的：
Process.killProcessQuiet(pid);
应用退出后，ActivityManagerService就把主进程给杀死了，但是，在Android5.0中，ActivityManagerService却是这样处理的：
Process.killProcessQuiet(app.pid);
Process.killProcessGroup(app.info.uid, app.pid);
就差了一句话，却差别很大。Android5.0在应用退出后，ActivityManagerService不仅把主进程给杀死，另外把主进程所属的进程组一并杀死，这样一来，由于子进程和主进程在同一进程组，子进程在做的事情，也就停止了...要不怎么说Android5.0在安全方面做了很多更新呢...
那么，有没有办法让子进程脱离出来，不要受到主进程的影响，当然也是可以的。那么，在C/C++层是如何实现的呢？
Android之蓝牙BLE
2016.06.07学习蓝牙相关android编程，参考链接：Android4.3 蓝牙BLE初步 - 罗斯摩根 - 博客园
1、关键概念：
Generic Attribute Profile (GATT)
通过BLE连接，读写属性类小数据的Profile通用规范。现在所有的BLE应用Profile都是基于GATT的。
Attribute Protocol (ATT)
GATT是基于ATT Protocol的。ATT针对BLE设备做了专门的优化，具体就是在传输过程中使用尽量少的数据。每个属性都有一个唯一的UUID，属性将以characteristics and services的形式传输。
Characteristic
Characteristic可以理解为一个数据类型，它包括一个value和0至多个对次value的描述（Descriptor）。
Descriptor
对Characteristic的描述，例如范围、计量单位等。
Service
Characteristic的集合。例如一个service叫做"Heart Rate Monitor"，它可能包含多个Characteristics，其中可能包含一个叫做"heart rate measurement"的Characteristic。
2、角色和职责：
Android设备与BLE设备交互有两组角色：
中心设备和外围设备（Central vs. peripheral）；
GATT server vs. GATT client.
Central vs. peripheral:
中心设备和外围设备的概念针对的是BLE连接本身。Central角色负责scan advertisement。而peripheral角色负责make advertisement。
GATT server vs. GATT client:
这两种角色取决于BLE连接成功后，两个设备间通信的方式。
举例说明：
现 有一个活动追踪的BLE设备和一个支持BLE的Android设备。Android设备支持Central角色，而BLE设备支持peripheral角 色。创建一个BLE连接需要这两个角色都存在，都仅支持Central角色或者都仅支持peripheral角色则无法建立连接。
当 连接建立后，它们之间就需要传输GATT数据。谁做server，谁做client，则取决于具体数据传输的情况。例如，如果活动追踪的BLE设备需要向 Android设备传输sensor数据，则活动追踪器自然成为了server端；而如果活动追踪器需要从Android设备获取更新信息，则 Android设备作为server端可能更合适。
3、权限及feature：
和经典蓝牙一样，应用使用蓝牙，需要声明BLUETOOTH权限，如果需要扫描设备或者操作蓝牙设置，则还需要BLUETOOTH_ADMIN权限：
<uses-permission android:name="android.permission.BLUETOOTH"/>
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>
除了蓝牙权限外，如果需要BLE feature则还需要声明uses-feature：
<uses-feature android:name="android.hardware.bluetooth_le" android:required="true"/>
按时required为true时，则应用只能在支持BLE的Android设备上安装运行；required为false时，Android设备均可正常安装运行，需要在代码运行时判断设备是否支持BLE feature：
java
// Use this check to determine whether BLE is supported on the device. Then
// you can selectively disable BLE-related features.
if (!getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)) {
Toast.makeText(this, R.string.ble_not_supported, Toast.LENGTH_SHORT).show();
finish();
}4、启动蓝牙：
在使用蓝牙BLE之前，需要确认Android设备是否支持BLE feature(required为false时)，另外要需要确认蓝牙是否打开。
如果发现不支持BLE，则不能使用BLE相关的功能。如果支持BLE，但是蓝牙没打开，则需要打开蓝牙。
打开蓝牙的步骤：
1、获取BluetoothAdapter
BluetoothAdapter是Android系统中所有蓝牙操作都需要的，它对应本地Android设备的蓝牙模块，在整个系统中BluetoothAdapter是单例的。当你获取到它的示例之后，就能进行相关的蓝牙操作了。
获取BluetoothAdapter代码示例如下：
java
// Initializes Bluetooth adapter.
final BluetoothManager bluetoothManager =
(BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
mBluetoothAdapter = bluetoothManager.getAdapter();注：这里通过getSystemService获取BluetoothManager，再通过BluetoothManager获取BluetoothAdapter。BluetoothManager在Android4.3以上支持(API level 18)。
2、判断是否支持蓝牙，并打开蓝牙
获取到BluetoothAdapter之后，还需要判断是否支持蓝牙，以及蓝牙是否打开。
如果没打开，需要让用户打开蓝牙：
java
private BluetoothAdapter mBluetoothAdapter;
...
// Ensures Bluetooth is available on the device and it is enabled. If not,
// displays a dialog requesting user permission to enable Bluetooth.
if (mBluetoothAdapter == null || !mBluetoothAdapter.isEnabled()) {
Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
}5、搜索BLE设备：
通过调用BluetoothAdapter的startLeScan()搜索BLE设备。调用此方法时需要传入 BluetoothAdapter.LeScanCallback参数。
因此你需要实现 BluetoothAdapter.LeScanCallback接口，BLE设备的搜索结果将通过这个callback返回。
由于搜索需要尽量减少功耗，因此在实际使用时需要注意：
1、当找到对应的设备后，立即停止扫描；
2、不要循环搜索设备，为每次搜索设置适合的时间限制。避免设备不在可用范围的时候持续不停扫描，消耗电量。
搜索的示例代码如下：
java
/**
* Activity for scanning and displaying available BLE devices.
*/
public class DeviceScanActivity extends ListActivity {
private BluetoothAdapter mBluetoothAdapter;
private boolean mScanning;
private Handler mHandler;
// Stops scanning after 10 seconds.
private static final long SCAN_PERIOD = 10000;
...
private void scanLeDevice(final boolean enable) {
if (enable) {
// Stops scanning after a pre-defined scan period.
mHandler.postDelayed(new Runnable() {
@Override
public void run() {
mScanning = false;
mBluetoothAdapter.stopLeScan(mLeScanCallback);
}
}, SCAN_PERIOD);
mScanning = true;
mBluetoothAdapter.startLeScan(mLeScanCallback);
} else {
mScanning = false;
mBluetoothAdapter.stopLeScan(mLeScanCallback);
}
...
}
...
}如果你只需要搜索指定UUID的外设，你可以调用 startLeScan(UUID[], BluetoothAdapter.LeScanCallback)方法。
其中UUID数组指定你的应用程序所支持的GATT Services的UUID。
BluetoothAdapter.LeScanCallback的实现示例如下：
java
private LeDeviceListAdapter mLeDeviceListAdapter;
...
// Device scan callback.
private BluetoothAdapter.LeScanCallback mLeScanCallback =
new BluetoothAdapter.LeScanCallback() {
@Override
public void onLeScan(final BluetoothDevice device, int rssi,
byte[] scanRecord) {
runOnUiThread(new Runnable() {
@Override
public void run() {
mLeDeviceListAdapter.addDevice(device);
mLeDeviceListAdapter.notifyDataSetChanged();
}
});
}
};注意：搜索时，你只能搜索传统蓝牙设备或者BLE设备，两者完全独立，不可同时被搜索。
6、连接GATT Server：
两个设备通过BLE通信，首先需要建立GATT连接。这里我们讲的是Android设备作为client端，连接GATT Server。
连接GATT Server，你需要调用BluetoothDevice的connectGatt()方法。此函数带三个参数：Context、autoConnect(boolean)和BluetoothGattCallback对象。调用示例：
mBluetoothGatt = device.connectGatt(this, false, mGattCallback);
函数成功，返回BluetoothGatt对象，它是GATT profile的封装。通过这个对象，我们就能进行GATT Client端的相关操作。BluetoothGattCallback用于传递一些连接状态及结果。
BluetoothGatt常规用到的几个操作示例:
connect() ：连接远程设备。
discoverServices() : 搜索连接设备所支持的service。
disconnect()：断开与远程设备的GATT连接。
close()：关闭GATT Client端。
readCharacteristic(characteristic) ：读取指定的characteristic。
setCharacteristicNotification(characteristic, enabled) ：设置当指定characteristic值变化时，发出通知。
getServices() ：获取远程设备所支持的services。等等。
注：
1、某些函数调用之间存在先后关系。例如首先需要connect上才能discoverServices。
2、 一些函数调用是异步的，需要得到的值不会立即返回，而会在BluetoothGattCallback的回调函数中返回。例如 discoverServices与onServicesDiscovered回调，readCharacteristic与 onCharacteristicRead回调，setCharacteristicNotification与 onCharacteristicChanged回调等。
7、BluetoothGattCallback回调接口：
两个设备通过BLE通信，首先需要建立GATT连接。这里我们讲的是Android设备作为client端，连接GATT Server。
final BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address); //通过MAC地址得到远程BluetoothDevice
if (device == null)return false;
mBluetoothGatt = device.connectGatt(mContext, false, gattCallback); //连接远程BluetoothDevice设置回调gattCallback
if(mBluetoothGatt == null) return false;
回调gattCallback接口方法说明：
java
public abstract class BluetoothGattCallback {
/**
* Callback indicating when GATT client has connected/disconnected to/from a remote
* GATT server.
*
* @param gatt GATT client
* @param status Status of the connect or disconnect operation.
* {@link BluetoothGatt#GATT_SUCCESS} if the operation succeeds.
* @param newState Returns the new connection state. Can be one of
* {@link BluetoothProfile#STATE_DISCONNECTED} or
* {@link BluetoothProfile#STATE_CONNECTED}
*/
public void onConnectionStateChange(BluetoothGatt gatt, int status,
int newState) {
}
/**
* Callback invoked when the list of remote services, characteristics and descriptors
* for the remote device have been updated, ie new services have been discovered.
*
* @param gatt GATT client invoked {@link BluetoothGatt#discoverServices}
* @param status {@link BluetoothGatt#GATT_SUCCESS} if the remote device
* has been explored successfully.
*/
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
}
/**
* Callback reporting the result of a characteristic read operation.
*
* @param gatt GATT client invoked {@link BluetoothGatt#readCharacteristic}
* @param characteristic Characteristic that was read from the associated
* remote device.
* @param status {@link BluetoothGatt#GATT_SUCCESS} if the read operation
* was completed successfully.
*/
public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic,
int status) {
}
/**
* Callback indicating the result of a characteristic write operation.
*
* <p>If this callback is invoked while a reliable write transaction is
* in progress, the value of the characteristic represents the value
* reported by the remote device. An application should compare this
* value to the desired value to be written. If the values don't match,
* the application must abort the reliable write transaction.
*
* @param gatt GATT client invoked {@link BluetoothGatt#writeCharacteristic}
* @param characteristic Characteristic that was written to the associated
* remote device.
* @param status The result of the write operation
* {@link BluetoothGatt#GATT_SUCCESS} if the operation succeeds.
*/
public void onCharacteristicWrite(BluetoothGatt gatt,
BluetoothGattCharacteristic characteristic, int status) {
}
/**
* Callback triggered as a result of a remote characteristic notification.
*
* @param gatt GATT client the characteristic is associated with
* @param characteristic Characteristic that has been updated as a result
* of a remote notification event.
*/
public void onCharacteristicChanged(BluetoothGatt gatt,
BluetoothGattCharacteristic characteristic) {
}
/**
* Callback reporting the result of a descriptor read operation.
*
* @param gatt GATT client invoked {@link BluetoothGatt#readDescriptor}
* @param descriptor Descriptor that was read from the associated
* remote device.
* @param status {@link BluetoothGatt#GATT_SUCCESS} if the read operation
* was completed successfully
*/
public void onDescriptorRead(BluetoothGatt gatt, BluetoothGattDescriptor descriptor,
int status) {
}
/**
* Callback indicating the result of a descriptor write operation.
*
* @param gatt GATT client invoked {@link BluetoothGatt#writeDescriptor}
* @param descriptor Descriptor that was writte to the associated
* remote device.
* @param status The result of the write operation
* {@link BluetoothGatt#GATT_SUCCESS} if the operation succeeds.
*/
public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor,
int status) {
}
/**
* Callback invoked when a reliable write transaction has been completed.
*
* @param gatt GATT client invoked {@link BluetoothGatt#executeReliableWrite}
* @param status {@link BluetoothGatt#GATT_SUCCESS} if the reliable write
* transaction was executed successfully
*/
public void onReliableWriteCompleted(BluetoothGatt gatt, int status) {
}
/**
* Callback reporting the RSSI for a remote device connection.
*
* This callback is triggered in response to the
* {@link BluetoothGatt#readRemoteRssi} function.
*
* @param gatt GATT client invoked {@link BluetoothGatt#readRemoteRssi}
* @param rssi The RSSI value for the remote device
* @param status {@link BluetoothGatt#GATT_SUCCESS} if the RSSI was read successfully
*/
public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {
}
/**
* Callback indicating the MTU for a given device connection has changed.
*
* This callback is triggered in response to the
* {@link BluetoothGatt#requestMtu} function, or in response to a connection
* event.
*
* @param gatt GATT client invoked {@link BluetoothGatt#requestMtu}
* @param mtu The new MTU size
* @param status {@link BluetoothGatt#GATT_SUCCESS} if the MTU has been changed successfully
*/
public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) {
}
}8、总结android 蓝牙4.0的api作为从机（周边/被搜索的一方）和主机（中心/搜索其他的一方）：
ndroid4.3 规范了BLE的API，但是直到目前的4.4，还有些功能不完善。
在BLE协议中，有两个角色，周边（Periphery）和中央（Central）；周边是数据提供者，中央是数据使用/处理者；在iOS SDK里面，可以把一个iOS设备作为一个周边，也可以作为一个中央；但是在Android SDK里面，直到目前最新的Android4.4.2，Android手机只能作为中央来使用和处理数据；那数据从哪儿来？从BLE设备来，现在的很多可穿戴设备都是用BLE来提供数据的。
一个中央可以同时连接多个周边，但是一个周边某一时刻只能连接一个中央。
大概了解了概念后，看看Android BLE SDK的四个关键类（class）：
a) BluetoothGattServer作为周边来提供数据；BluetoothGattServerCallback返回周边的状态。
b) BluetoothGatt作为中央来使用和处理数据；BluetoothGattCallback返回中央的状态和周边提供的数据。
因为我们讨论的是Android的BLE SDK，下面所有的BluetoothGattServer代表周边，BluetoothGatt代表中央。
8.1、创建一个周边（虽然目前周边API在Android手机上不工作，但还是看看）
每一个周边BluetoothGattServer，包含多个服务Service，每一个Service包含多个特征Characteristic。
- new一个特征：character = new BluetoothGattCharacteristic(
java
UUID.fromString(characteristicUUID),
BluetoothGattCharacteristic.PROPERTY_NOTIFY,
BluetoothGattCharacteristic.PERMISSION_READ);- new一个服务：service = new BluetoothGattService(UUID.fromString(serviceUUID),
java
BluetoothGattService.SERVICE_TYPE_PRIMARY);- 把特征添加到服务：service.addCharacteristic(character);
- 获取BluetoothManager：manager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
- 获取/打开周边：BluetoothGattServer server = manager.openGattServer(this,new BluetoothGattServerCallback(){...});
- 把service添加到周边：server.addService(service);
- 开始广播service：Google还没有广播Service的API，等吧！！！！！所以目前我们还不能让一个Android手机作为周边来提供数据。
8.2、创建一个中央（这次不会让你失望，可以成功创建并且连接到周边的）
了拿到中央BluetoothGatt，可要爬山涉水十八弯：
- 先拿到BluetoothManager：bluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
- 再拿到BluetoothAdapt：btAdapter = bluetoothManager.getAdapter();
- 开始扫描：btAdapter.startLeScan( BluetoothAdapter.LeScanCallback);
- 从LeScanCallback中得到BluetoothDevice：public void onLeScan(BluetoothDevice device, int rssi, byte[] scanRecord) {.....}
- 用BluetoothDevice得到BluetoothGatt：gatt = device.connectGatt(this, true, gattCallback);
终于拿到中央BluetoothGatt了，它有一堆方法（查API吧），调用这些方法，你就可以通过BluetoothGattCallback和周边BluetoothGattServer交互了。
8.3、吐槽一下：
BluetoothAdapter.LeScanCallback是接口，但是BluetoothGattServerCallback和BluetoothGattCallback是抽象类，这两个抽象类让人很不爽，不知道google为什么要把他们搞成抽象类，完全可以搞成接口的嘛，或者又有抽象类又有接口也行啊，就像Runable和Thread一样多好。这两个抽象类对于有代码洁癖的人简直就是一种折磨，在方法参数里面new，还要实现父类方法，是在受不了。
Android之消息推送
本文介绍在Android中实现推送方式的基础知识及相关解决方案。推送功能在手机开发中应用的场景是越来起来了，不说别的，就我们手机上的新闻客户端就时不j时的推送过来新的消息，很方便的阅读最新的新闻信息。这种推送功能是好的一面，但是也会经常看到很多推送过来的垃圾信息，这就让我们感到厌烦了，关于这个我们就不能多说什么了，毕竟很多商家要做广告。本文就是来探讨下Android中实现推送功能的一些解决方案，也希望能够起到抛砖引玉的作用。^_^
1、推送方式基础知识：
在移动互联网时代以前的手机，如果有事情发生需要通知用户，则会有一个窗口弹出，将告诉用户正在发生什么事情。可能是未接电话的提示，日历的提醒，或是一封新的彩信。推送功能最早是被用于Email中，用来提示我们新的信息。由于时代的发展和移动互联网的热潮，推送功能更加地普及，已经不再仅仅用在推送邮件了，更多地用在我们的APP中了。
当我们开发需要和服务器交互的应用程序时，基本上都需要获取服务器端的数据，比如《地震应急通》就需要及时获取服务器上最新的地震信息。要获取服务器上不定时更新的信息，一般来说有两种方法：第一种是客户端使用Pull（拉）的方式，就是隔一段时间就去服务器上获取一下信息，看是否有更新的信息出现。第二种就是 服务器使用Push（推送）的方式，当服务器端有新信息了，则把最新的信息Push到客户端上。这样，客户端就能自动的接收到消息。
虽然Pull和Push两种方式都能实现获取服务器端更新信息的功能，但是明显来说Push方式比Pull方式更优越。因为Pull方式更费客户端的网络流量，更主要的是费电量，还需要我们的程序不停地去监测服务端的变化。
在开发Android和iPhone应用程序时，我们往往需要从服务器不定的向手机客户端即时推送各种通知消息。我们只需要在Android或IPhone的通知栏处向下一拉，就展开了Notification Panel，可以集中一览各种各样通知消息。目前IOS平台上已经有了比较简单的和完美的推送通知解决方案，我会在以后详细介绍IPhone中的解决方案，可是Android平台上实现起来却相对比较麻烦。
最近利用几天的时间对Android的推送通知服务进行初步的研究，也希望能和大家共同探讨一下。
2、几种常见的解决方案实现原理：
1）轮询(Pull)方式：应用程序应当阶段性的与服务器进行连接并查询是否有新的消息到达，你必须自己实现与服务器之间的通信，例如消息排队等。而且你还要考虑轮询的频率，如果太慢可能导致某些消息的延迟，如果太快，则会大量消耗网络带宽和电池。
2）SMS(Push)方式：在Android平台上，你可以通过拦截SMS消息并且解析消息内容来了解服务器的意图，并获取其显示内容进行处理。这是一个不错的想法，我就见过采用这个方案的应用程序。这个方案的好处是，可以实现完全的实时操作。但是问题是这个方案的成本相对比较高，我们需要向移动公司缴纳相应的费用。我们目前很难找到免费的短消息发送网关来实现这种方案。
3）持久连接(Push)方式：这个方案可以解决由轮询带来的性能问题，但是还是会消耗手机的电池。IOS平台的推送服务之所以工作的很好，是因为每一台手机仅仅保持一个与服务器之间的连接，事实上C2DM也是这么工作的。不过刚才也讲了，这个方案存在着很多的不足之处，就是我们很难在手机上实现一个可靠的服务，目前也无法与IOS平台的推送功能相比。
Android操作系统允许在低内存情况下杀死系统服务，所以我们的推送通知服务很有可能就被操作系统Kill掉了。 轮询(Pull)方式和SMS(Push)方式这两个方案也存在明显的不足。至于持久连接(Push)方案也有不足，不过我们可以通过良好的设计来弥补，以便于让该方案可以有效的工作。毕竟，我们要知道GMail，GTalk以及GoogleVoice都可以实现实时更新的。
3、百度推送
百度云推送官方链接 http://developer.baidu.com/wiki/index.php?title=docs/cplat/push/scene
百度云推送使用指南 http://push.baidu.com/doc/guide/join
百度云SDK开发文档 http://push.baidu.com/doc/android/api
百度云客服端参考链接 http://blog.csdn.net/lmj623565791/article/details/27231237
4、其他推送
参考https://www.cnblogs.com/hanyonglu/archive/2012/03/04/2378971.html
Android之Crop
开源库参考链接：http://yydcdut.com/2016/04/17/android-crop-analyse/
不使用任何第三方库直接实现方案：http://www.linuxidc.com/Linux/2012-11/73940p2.htm
1、使用android-crop-analyse开源库实现
整个界面分为上面的两个 Button，显示的 CropImageView，裁剪显示区域的 HighlightView。通过拖拉已经放大缩小 HighlightView 来确定裁剪区域。同时当 HighlightView 缩小的一定值的时候， CropImageView 也会缩小。源码如下：
java
/**
* 调用系统activity后返回值 通过返回值来上传图片
* @param requestCode
* @param resultCode
* @param data
*/
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode == Crop.REQUEST_PICK && resultCode == RESULT_OK) { // Crop.REQUEST_PICK调用系统选择图片界面后返回值
beginCrop(data.getData());
} else if (requestCode == RESULT_CAPTURE_IMAGE && resultCode == RESULT_OK) { //RESULT_CAPTURE_IMAGE调用系统相机拍照后返回值
if (data != null)
beginCrop(data.getData());
else
beginCrop(Uri.fromFile(_userIconSDTempFile));
} else if ((requestCode == Crop.REQUEST_CROP)||(requestCode==Crop.RESULT_ERROR)) { //Crop.REQUEST_CROP剪切图片后返回值
handleCrop(resultCode, data);
}
}
/**
* 准备开始剪切图片
* @param source 被剪切的图片的地址
*/
private void beginCrop(Uri source) {
Uri destination = Uri.fromFile(new File(getCacheDir(), "cropped")); //设置图片剪切后存放的缓存地址
Crop.of(source, destination).asSquare().withMaxSize(100,50).start(this); //Crop.of生成一个Crop
//Crop.asSquare设置缩放比例
//Crop.start启动裁剪并设置返回值REQUEST_CROPstart(activity, REQUEST_CROP);
}
//Crop中的源码
interface Extra {
String ASPECT_X = "aspect_x";
String ASPECT_Y = "aspect_y";
String MAX_X = "max_x";
String MAX_Y = "max_y";
String ERROR = "error";
}
/**
* Set fixed aspect ratio for crop area
*
* @param x Aspect X
* @param y Aspect Y
*/
public Crop withAspect(int x, int y) {
cropIntent.putExtra(Extra.ASPECT_X, x);
cropIntent.putExtra(Extra.ASPECT_Y, y);
return this;
}
/**
* Crop area with fixed 1:1 aspect ratio
*/
public Crop asSquare() {
cropIntent.putExtra(Extra.ASPECT_X, 1);
cropIntent.putExtra(Extra.ASPECT_Y, 1);
return this;
}
/**
* Set maximum crop size
*
* @param width Max width
* @param height Max height
*/
public Crop withMaxSize(int width, int height) {
cropIntent.putExtra(Extra.MAX_X, width);
cropIntent.putExtra(Extra.MAX_Y, height);
return this;
}
/**
* 剪切图片界面后的返回值
* @param resultCode 剪切图片界面的返回值 REQUEST_CROP成功 RESULT_ERROR错误
* @param result
*/
private void handleCrop(int resultCode, Intent result) {
if (resultCode == RESULT_OK) {
UiUtils.showLoading(InformationActivity.this);
try { //剪切成功后从beginCrop给定的地址中获取图片
_userIconCacheFile = new File(new URI(result.getParcelableExtra(MediaStore.EXTRA_OUTPUT).toString()));
} catch (Exception e) {
e.printStackTrace();
_userIconCacheFile = new File(getCacheDir(), "cropped");
}
Bitmap bitmap = new BitmapDrawable(_userIconCacheFile.getAbsolutePath()).getBitmap();
int degree = DrawableProvider.getBitmapDegree(_userIconCacheFile.getAbsolutePath());
int width = bitmap.getWidth();
int height = bitmap.getHeight();
Matrix _matrix = new Matrix();
_matrix.postRotate(degree);
_matrix.postScale(300f / width, 300f / height); //长和宽放大缩小的比例
Bitmap _resizeBmp = Bitmap.createBitmap(bitmap, 0, 0, width, height, _matrix, true);
OutputStream out = null;
try {
out = new FileOutputStream(_userIconCacheFile);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
_resizeBmp.compress(Bitmap.CompressFormat.JPEG, 80, out);
uploadPic(); //上传服务器
} else if (resultCode == Crop.RESULT_ERROR) {
Toast.makeText(this, Crop.getError(result).getMessage(), Toast.LENGTH_SHORT).show();
}
}2、不使用开源库实现
上网搜索，确实有不少的例子，大多都是抄来抄去，而且水平多半处于demo的样子，可以用来讲解知识点，但是一碰到实际项目，就漏洞百出。
当时我用大众化的解决方案，暂时性的做了一个拍照截图的功能，似乎看起来很不错。问题随之而来，我用的是小米手机，在别的手机上都运行正常，小米这里却总是碰钉子。虽然我是个理性的米粉，但是也暗地里把小米的工程师问候了个遍。真是惭愧！
翻文档也找不出个答案来，我一直对com.android.camera.action.CROP持有大大的疑问，它是从哪里来，它能干什么，它接收处理什么类型的数据？Google对此却讳莫如深，在官方文档中只有Intent中有只言片语言及，却不甚详尽。
随着项目的驱动，我不能抱着不了解原理就不往前走的心态，唯一要做的，是解决问题。最后在德问上找到一条解决方案，说是哪怕是大米也没问题。当时乐呵呵将代码改了改，确实在所有的手机上跑起来了，一时如释重负，对这个的疑问也抛诸脑后了。
直到月前，BOSS要求将拍照上传到服务器的图片分辨率加倍。OK，加倍简单，增加outputX以及outputY不就得了？
intent.putExtra("outputX", outputX);
intent.putExtra("outputY", outputY);
这一增加，吓了我一跳。BOSS的手机拍到的照片几乎就是个缩略图，但是被我问候了全体工程师的小米在这个时候就体现出国产神机的范儿了，小米上的尺寸一切正常。这个为什么呢？我大致了解原因，却不知道如何解决。
在Android中，Intent触发Camera程序，拍好照片后，将会返回数据，但是考虑到内存问题，Camera不会将全尺寸的图像返回给调用的Activity，一般情况下，有可能返回的是缩略图，比如120*160px。
这是为什么呢？这不是一个Bug，而是经过精心设计的，却对开发者不透明。
以我的小米手机为例，摄像头800W像素，根据我目前设置拍出来的图片尺寸为3200*2400px。有人说，那就返回呗，大不了耗1-2M的内存，不错，这个尺寸的图片确实只有1.8M左右的大小。但是你想不到的是，这个尺寸对应的Bitmap会耗光你应用程序的所有内存。Android出于安全性考虑，只会给你一个寒碜的缩略图。
在Android2.3中，默认的Bitmap为32位，类型是ARGB_8888，也就意味着一个像素点占用4个字节的内存。我们来做一个简单的计算题：3200*2400*4 bytes = 30M。
如此惊人的数字！哪怕你愿意为一张生命周期超不过10s的位图愿意耗费这么巨大的内存，Android也不会答应的。
Mobile devices typically have constrained system resources.
Android devices can have as little as 16MB of memory available to a single application.
这是Android Doc的原文，虽然不同手机系统的厂商可能围绕16M这个数字有微微的上调，但是这30M，一般的手机还真挥霍不起。也只有小米这种牛机，内存堪比个人PC，本着土财主般挥金如土的霸气才能做到。
OK，说了这么多，无非是吐吐苦水，爆爆个人经历而已，实际的解决方案在哪里呢？
我也是Google到的，话说一般百度不了的问题，那就Google或者直接StackOverFlow，只不过得看英文罢了。
最后翻来覆去，我在国外的一个Android团队的博客中找到了相应的方案，印证了我的猜想同时也给出了实际的代码。
我将这篇文章翻译成了中文，作为本博客的基础，建议详细看看。
【译】如何使用Android MediaStore裁剪大图片 如何使用Android MediaStore裁剪大图片_Linux编程_Linux公社-Linux系统门户网站
这篇网址了不起的地方在于解决了Android对返回图片的大小限制，并且详细解释了裁剪图片的Intent附加数据的具体含义。OK，我只是站在巨人的肩膀上，改善方案，适应更广泛需求而已。
Android之性能检测
无论你的应用多么有创新性、有用，如果它卡得要命，或者非常消耗内存，那么没人会愿意使用它。
因此，性能变得尤为重要。当你忙碌于构建精美的用户界面或者完成新的特性时，你可能容易忘却掉一些性能相关的事情。
这也是为什么有Google Play的应用审核机制的原因之一。
这篇文章中，你会看到每个Android工程师需要了解的一些性能问题。你将会学会使用Android SDK提供的、已安装在你的设备中的工具来测试这些问题是否发生在你自己的应用中。
如果在你的应用中发现了一个性能问题，你肯定会想修复它。我们还会看一看如何使用Android SDK 工具来获取更多关于那些没有覆盖到的性能问题的相关信息。一旦你有了这些信息，你将会对如何提升应用性能有一个更深刻的理解，并且能够构建出让用户喜爱的App。
1、过度绘制
步骤1 : 问题描述
你应用的用户界面是连接用户的纽带，但是创建漂亮的界面只是挑战的其中一面，你还需要确保用户界面流畅的运行。
一个常见的问题就是用户界面卡顿，出现这种情况的原因可能是overdraw。Overdraw是屏幕上的某个像素在同一帧的时间内被绘制了多次。
例如，想象一下一个有蓝色的背景文本，Android不仅会绘制对用户可见的蓝色区域，而是会绘制整个蓝色的背景以及上面的文本。这意味着一些像素会被两次绘制，这就是过度绘制。
一些如上述例子所说的过度绘制示例是不可避免的。然而，过多的多度绘制会引发明显的性能问题，因此你必须将过度绘制的可能性降到最小。
检测应用中的过度绘制相对来说比较简单。大量的过度绘制会引出其他用户界面相关问题，例如视图层级过于复杂等。基于这些原因，当你测试你的App的性能问题时，从过度绘制开始是一个明智的选择。
步骤2 : 检测过度绘制
好消息是你的Android设备上已经内置了检测过度绘制的工具。
因此你需要做的第一步就是安装你要测试的App到你的设备中。然后打开设置页面，选择开发选项（Developer Options）->调试GPU 过度绘制（Debug GPU Overdraw），然后选择"显示过度绘制区域（Show overdraw area）"。如下图所示
这个工具使用色块来代表不同数量的过度绘制。剩下的事情就是启动你要测试的应用，然后观察它的过度绘制情况。
- 没颜色 :没有过度绘制，也就是说一个像素只被绘制了一次。
- 蓝色 :过度绘制了一次，也就是一个像素点被绘制了两次。
- 绿色 :过度绘制了2次. 也就是一个像素点被绘制了三次，通常，你需要集中精力优化过度绘制次数大于等于2次的情况。
- 浅红色 :过度绘制3次。这取决于你的应用，小范围的3次过度绘制可能是不可避免的，但是如果你看到了中等或者大量的红色区域那么你就需要查找出现这个问题的原因了。
- 深红色 :过度绘制4次，像素点被绘制了5次，甚至更多次。出现这种问题你绝逼要找到原因，并且解决它。
步骤3 ： 最小化过度绘制
一旦你发现了某个区域有严重的过度绘制，最简单的方法就是打开你应用的xml文件找到过度重叠的区域，特别是那些不可见的drawable对象和被绘制在其他控件上的背景，以此来降低这些地方的过度绘制。
你也应该查找那些背景属性设置为白色，并且它的父视图背景也设置为白色的区域。所有这些都会引起严重的过度绘制。
Android系统能自动的降低一些简单的过度绘制，但是这些对于复杂的自定义View并没有什么价值，因为Android不会知道你如何绘制你的内容。
如果你在App中使用了复杂的自定义View，你可以为使用clipRect函数为你的视图定义可绘制区域的边界。更新相关信息可以参考official Androiddocumentation.
2. Android 图形渲染
步骤1 : 问题描述
另一个常见的性能问题就是应用的视图层级。为了渲染每个视图，Android都会经历这三个阶段 :测量、布局、绘制。
花在这三个阶段的时间与View层级中的View的数量成正比，这就意味着降低App渲染时间的最简单的方法就是识别和移除那些并没有什么卵用的UI元素。
即使在你的视图层级上的所有View都是必须的，不同的布局方式也可能对测量过程产生重要的影响。通常来说，你的视图层级越深，花在测量视图的时间就越长。
在视图渲染期间，每个View都要向它的父View提供它自己的尺寸。如果父view发现了任意一个尺寸问题，那么它会强制要求所有的子视图重新测量。
即使没有错误发生，重新测量也可能出现。例如，为了正确的进行布局RelativeLayout通常会对它们的子视图进行两次测量。子视图使用了layout_weight属性的LinearLayout也会对它的子视图进行两次测量。
这些都取决于你的布局方式，测量和重新测量的代价非常昂贵，它会严重影响你的渲染速度。
确保你的用户界面渲染流畅的关键就是移除任何非必须的View以及减少你的View层级。
Hierarchy Viewer是一个能够将你完整的View层级可视化的工具，这个工具能够帮助你发现冗余的View以及嵌套的布局。
步骤2：使用 Hierarchy Viewer
在我们进一步了解Hierarchy Viewer之前，你需要知道它的一些规则。首先Hierarchy Viewer只能与正在运行的App进行交互，而不是你的源代码。这就是说你需要将App安装到你的设备或者模拟器上。
还有一个最重要的问题，就是默认情况下Hierarchy Viewer只能与运行开发版Android系统的设备进行交互（译者注: 一般来说，使用模拟器即可）。如果你没有开发设备，那你需要添加ViewServerclass到你的应用中。
了解这些之后就让我们打开Android Studio，并且选择"tools" -> "Android" -> "Android Device Monitor"，如图所示。
然后点击Hierarchy View按钮，如下图所示
屏幕左边的Windows标签下列出了所有Android设备和模拟器。选择你的设备后，你会看到你设备上运行的所有进程。选中你要检测的进程，然后你会看到三个自动更新的视图层级区域。
这三个窗口提供了视图层级的三个不同可视化展示。
- Tree View:**** 视图层级窗口，每个节点代表了一个View;
- Tree Overview:整个视图层级的缩略布局;
- Layout View:当前视图层级的轮廓.
Hierarchy View中有三个窗口。如果你在一个窗口中选择了一个View，那么它会在另外两个中高亮显示。你能同时使用这三个窗口查找View层级中的冗余视图。
如果你不确定一个View是否是UI界面中的必须元素，最简单的方法就是到Tree View窗口点击这个节点。你将会看到该View是如何显示在屏幕的预览，此时你就可以确切地知道该View是否是必须的。
但是即使一个View对最终的渲染效果有贡献也并不意味着它不会引起严重的性能问题。你已经看到了如何通过Hierarchy Viewer来找到明显的嵌套布局，但是如果这引起的性能问题并不那么明显呢？或者还有其他的原因使得该视图渲染得非常慢？
好消息就是你还可以通过Hierarchy Viewer来剖析每个View在不同的渲染阶段的耗时。当性能问题的原因不那么明显时，这是你发现问题的另一途径。
下个章节我将为你展示如何通过Hierarchy Viewer来剖析每个View的渲染时间来找到潜伏在问题表面的性能问题。
步骤3 : 节点的性能分析
定位你的用户界面瓶颈的最简单方法就是收集每个View分别完成测量、布局、绘制的时间。
你不仅可以通过Hierarchy Viewer收集这些信息，Hierarchy Viewer还可以通俗易懂地向你展示这些数据，因此你可以通过这种形式来找到性能问题。
Hierarchy Viewer默认并不会显示渲染时间。你需要到Tree View窗口添加这个信息，然后选择你想要测试的根节点。下一步，在Hierarchy Viewer上点击由绿、红、紫的三个圆形色块组成的按钮，如图所示。
三个圆点色块就会显示在每个节点上，从左到右，这些圆点分别代表 :
- 用于测量的时间
- 用于布局的时间
- 用于绘制的时间
每个圆点都有颜色 :
- 绿色代表该View的渲染速度至少要快于一半以上的其他参与测试的节点。例如，一个在布局位置上的绿色的圆点代表它的布局速度要快于50%以上的其他节点；
- 黄色代表该View慢于50%以上的其他节点;
- 红色代表该View的渲染速度比其他所有参与测试的节点都慢。
当收集了这些数据之后，你不仅知道哪些View需要优化，你还会确切地知道是在渲染的哪个阶段导致的问题。
哪些黄色、红色的地方就是你需要开始优化的地方，这些性能指标与该视图层级下的其他剖析节点也有关系。换句话说，你肯定会有一些视图渲染得比其他的慢。
在开始改良你的View相关的代码之前，摸着你的良心问一句该View渲染得比其他视图慢是否有一个合理的原因，如果答案是否定的，那么就开始你的View优化之旅吧。
3、Memory Leaks 内存泄漏
步骤1：问题描述
Android是一个自动管理内存的开发环境，不要让这个句话蒙蔽了，因为内存泄漏依旧是可能发生的。这是因为垃圾回收器只会移除那些不可达的对象。如果它不是一个不可达的对象，那么该对象就不会被释放掉。
这些不可达的对象阴魂不散，聚集在你的堆内存中，占用App的内存控件。如果你继续泄漏对象，那么可用的内存空间将会越来越小，GC操作就会频繁触发。
有两个原因表明这是一个坏消息。首先，GC操作通常不会明显地影响你的App性能，但是当内存控件较小时大量的GC操作会使你的App变慢，此时UI就不会那么流畅了。第二问题是移动设备的内存空间相对来说较小，因此内存泄漏会快速地升级为内存溢出，导致应用Crash。
内存泄漏难以被检测出。可能只有当用户开始抱怨你的应用时你才能发觉内存泄漏问题。幸运地是，Android SDK提供了一些有用的工具来让你找到这些问题。（译者注 : Square的开源库LeakCanary是查找内存泄漏的优秀工具,强烈建议大家使用）。
步骤2 : 内存监视器 （Memory Monitor）
Memory Monitor是一个能够实时获取应用内存使用情况的工具。需要注意的是这个工具只能作用于正在运行的应用，因此确保你的要测试的应用已经安装到你的设备中，并且你的设备已经连接到你的电脑上。
Memory Monitor已经内置在Android Studio中，因此你可以点击Android Studio的底部的"Memory"这个tab来切换到内存监视页面。当你切换到该页面的时候，Memory Monitor就开始记录你的内存使用情况了。
如果Memory Monitor没有开始记录，那么确保你的设备是已经被选中的状态。
如果Memory Monitor提示No debuggable applications，那么你可以打开Android Studio的"Tools"菜单，选择"Android"，然后确保选中了Enable adb integration。这个功能还不是很稳定，所以有时候你需要手动切换它的状态。你也可以断开设备与电脑的连接，然后再重连，这样可能就OK了。
一旦Memory Monitor检测到正在运行的应用，它就会显示这个应用的内存使用情况。已使用的内存会被表示为深蓝色，未分配的内存则会变为浅蓝色。
花一些时间与你的设备交互，并且关注你的内存使用情况。最终已分配的内存会增长，直到没有内存可用。此时，系统就会释放触发GC释放内存，当你看到已分配的内存明显的下降时就代表GC操作被触发了。
GC通常情况下会将无用的内存释放掉，但是当你看到App在短时间内快速增长或者GC变得非常频繁，此时你就需要倍加小心了，这就是发生内存泄漏的信号！
如果你通过Memory Monitor来追踪一个可疑的内存泄漏问题，你可能会看到Android系统会为你的App增大可用内存，TODO : 。
最终，你可能会看到你的App消耗了非常多的内存以至于系统无法再给你的应用更多的可用内存。如果你看到这种场景，那么说明你在内存使用上犯了很严重的错误。
步骤3 : Android Device Monitor
另一个能够帮助你收集更新关于内存泄漏信息和其他内存相关问题的工具是Android Device Monitor的DDMMS工具下的Heap。
Heap工具能够通过显示系统为你分配了多少内存来帮助你诊断内存泄漏问题。正如上面提到的，如果已分配的内存不断地增长，那么这是发生内存泄漏的明显信号。
但是这个工具还提供了许多关于你的应用堆内存使用情况的数据，包含你的App内分配的各种对象、分配的对象数量以及这些对象占用了多少空间。这些额外的信息对于你追踪内存泄漏极为有用。
你可以在Android Device Monitor工具中选择DDMS，在Devices中选择你要检测的App。然后选择Heap标签，如图所示。然后花一些时间与你的App进行交互以收集内存信息。
heap输出信息会在GC事件之后，因为你可以手动点击Cause GC来触发GC，使得Heap内存数据尽快地显示出来。
一旦GC事件被触发了，heap标签下就会更新App的堆内存使用信息，这些信息会在每次GC时更新。
## 总结
在这篇文章中，我们学习了一些开发中最常见的性能问题，过度绘制、内存泄漏、缓慢的UI渲染。
相信你已经掌握了如何使用工具来检查这些问题，以及如何获取更新的信息来判断你的应用中是否出现了这些性能问题。你有越多的信息，就越容易追踪到问题的原因并且修复它。
Android SDK有很多工具可以供你诊断和定位性能问题。如果你想学习更多这方面的知识，你可以访问u这两篇官方文档Traceview and dmtracedump和Allocation Tracker.
Android之静默安装
之前有很多朋友都问过我，在Android系统中怎样才能实现静默安装呢？所谓的静默安装，就是不用弹出系统的安装界面，在不影响用户任何操作的情况下不知不觉地将程序装好。虽说这种方式看上去不打搅用户，但是却存在着一个问题，因为Android系统会在安装界面当中把程序所声明的权限展示给用户看，用户来评估一下这些权限然后决定是否要安装该程序，但如果使用了静默安装的方式，也就没有地方让用户看权限了，相当于用户被动接受了这些权限。在Android官方看来，这显示是一种非常危险的行为，因此静默安装这一行为系统是不会开放给开发者的。
但是总是弹出一个安装对话框确实是一种体验比较差的行为，这一点Google自己也意识到了，因此Android系统对自家的Google Play商店开放了静默安装权限，也就是说所有从Google Play上下载的应用都可以不用弹出安装对话框了。这一点充分说明了拥有权限的重要性，自家的系统想怎么改就怎么改。借鉴Google的做法，很多国内的手机厂商也采用了类似的处理方式，比如说小米手机在小米商店中下载应用也是不需要弹出安装对话框的，因为小米可以在MIUI中对Android系统进行各种定制。因此，如果我们只是做一个普通的应用，其实不太需要考虑静默安装这个功能，因为我们只需要将应用上架到相应的商店当中，就会自动拥有静默安装的功能。
但是如果我们想要做的也是一个类似于商店的平台呢？比如说像360手机助手，它广泛安装于各种各样的手机上，但都是作为一个普通的应用存在的，而没有Google或小米这样的特殊权限，那360手机助手应该怎样做到更好的安装体验呢？为此360手机助手提供了两种方案， 秒装（需ROOT权限）和智能安装，如下图示：
因此，今天我们就模仿一下360手机助手的实现方式，来给大家提供一套静默安装的解决方案。
1、秒装
所谓的秒装其实就是需要ROOT权限的静默安装，其实静默安装的原理很简单，就是调用Android系统的pm install命令就可以了，但关键的问题就在于，pm命令系统是不授予我们权限调用的，因此只能在拥有ROOT权限的手机上去申请权限才行。
下面我们开始动手，新建一个InstallTest项目，然后创建一个SilentInstall类作为静默安装功能的实现类，代码如下所示
java
/**
* 静默安装的实现类，调用install()方法执行具体的静默安装逻辑。
* 原文地址：http://blog.csdn.net/guolin_blog/article/details/47803149
* @author guolin
* @since 2015/12/7
*/
public class SilentInstall {
/**
* 执行具体的静默安装逻辑，需要手机ROOT。
* @param apkPath
* 要安装的apk文件的路径
* @return 安装成功返回true，安装失败返回false。
*/
public boolean install(String apkPath) {
boolean result = false;
DataOutputStream dataOutputStream = null;
BufferedReader errorStream = null;
try {
// 申请su权限
Process process = Runtime.getRuntime().exec("su");
dataOutputStream = new DataOutputStream(process.getOutputStream());
// 执行pm install命令
String command = "pm install -r " + apkPath + "\n";
dataOutputStream.write(command.getBytes(Charset.forName("utf-8")));
dataOutputStream.flush();
dataOutputStream.writeBytes("exit\n");
dataOutputStream.flush();
process.waitFor();
errorStream = new BufferedReader(new InputStreamReader(process.getErrorStream()));
String msg = "";
String line;
// 读取命令的执行结果
while ((line = errorStream.readLine()) != null) {
msg += line;
}
Log.d("TAG", "install msg is " + msg);
// 如果执行结果中包含Failure字样就认为是安装失败，否则就认为安装成功
if (!msg.contains("Failure")) {
result = true;
}
} catch (Exception e) {
Log.e("TAG", e.getMessage(), e);
} finally {
try {
if (dataOutputStream != null) {
dataOutputStream.close();
}
if (errorStream != null) {
errorStream.close();
}
} catch (IOException e) {
Log.e("TAG", e.getMessage(), e);
}
}
return result;
}
} 可以看到，SilentInstall类中只有一个install()方法，所有静默安装的逻辑都在这个方法中了，那么我们具体来看一下这个方法。首先在第21行调用了Runtime.getRuntime().exec("su")方法，在这里先申请ROOT权限，不然的话后面的操作都将失败。然后在第24行开始组装静默安装命令，命令的格式就是pm install -r <apk路径>，-r参数表示如果要安装的apk已经存在了就覆盖安装的意思，apk路径是作为方法参数传入的。接下来的几行就是执行上述命令的过程，注意安装这个过程是同步的，因此我们在下面调用了process.waitFor()方法，即安装要多久，我们就要在这里等多久。等待结束之后说明安装过程结束了，接下来我们要去读取安装的结果并进行解析，解析的逻辑也很简单，如果安装结果中包含Failure字样就说明安装失败，反之则说明安装成功。
整个方法还是非常简单易懂的，下面我们就来搭建调用这个方法的环境。修改activity_main.xml中的代码，如下所示：
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"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context="com.example.installtest.MainActivity">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content">
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="onChooseApkFile"
android:text="选择安装包" />
<TextView
android:id="@+id/apkPathText"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:layout_gravity="center_vertical"
/>
</LinearLayout>
<View
android:layout_width="match_parent"
android:layout_height="1dp"
android:background="@android:color/darker_gray" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="onSilentInstall"
android:text="秒装" />
<View
android:layout_width="match_parent"
android:layout_height="1dp"
android:background="@android:color/darker_gray" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="onForwardToAccessibility"
android:text="开启智能安装服务" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="onSmartInstall"
android:text="智能安装" />
</LinearLayout> 这里我们先将程序的主界面确定好，主界面上拥有四个按钮，第一个按钮用于选择apk文件的，第二个按钮用于开始秒装，第三个按钮用于开启智能安装服务，第四个按钮用于开始智能安装，这里我们暂时只能用到前两个按钮。那么调用SilentInstall的install()方法需要传入apk路径，因此我们需要先把文件选择器的功能实现好，新建activity_file_explorer.xml和list_item.xml作为文件选择器的布局文件，代码分别如下所示
XML
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent">
<ListView
android:id="@+id/list_view"
android:layout_width="match_parent"
android:layout_height="match_parent"
/>
</LinearLayout>
[html] view plain copy
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:padding="4dp"
android:orientation="horizontal">
<ImageView android:id="@+id/img"
android:layout_width="32dp"
android:layout_margin="4dp"
android:layout_gravity="center_vertical"
android:layout_height="32dp"/>
<TextView android:id="@+id/name"
android:textSize="18sp"
android:textStyle="bold"
android:layout_width="match_parent"
android:gravity="center_vertical"
android:layout_height="50dp"/>
</LinearLayout> 然后新建FileExplorerActivity作为文件选择器的Activity，代码如下
java
public class FileExplorerActivity extends AppCompatActivity implements AdapterView.OnItemClickListener {
ListView listView;
SimpleAdapter adapter;
String rootPath = Environment.getExternalStorageDirectory().getPath();
String currentPath = rootPath;
List<Map<String, Object>> list = new ArrayList<>();
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_file_explorer);
listView = (ListView) findViewById(R.id.list_view);
adapter = new SimpleAdapter(this, list, R.layout.list_item,
new String[]{"name", "img"}, new int[]{R.id.name, R.id.img});
listView.setAdapter(adapter);
listView.setOnItemClickListener(this);
refreshListItems(currentPath);
}
private void refreshListItems(String path) {
setTitle(path);
File[] files = new File(path).listFiles();
list.clear();
if (files != null) {
for (File file : files) {
Map<String, Object> map = new HashMap<>();
if (file.isDirectory()) {
map.put("img", R.drawable.directory);
} else {
map.put("img", R.drawable.file_doc);
}
map.put("name", file.getName());
map.put("currentPath", file.getPath());
list.add(map);
}
}
adapter.notifyDataSetChanged();
}
@Override
public void onItemClick(AdapterView<?> parent, View v, int position, long id) {
currentPath = (String) list.get(position).get("currentPath");
File file = new File(currentPath);
if (file.isDirectory())
refreshListItems(currentPath);
else {
Intent intent = new Intent();
intent.putExtra("apk_path", file.getPath());
setResult(RESULT_OK, intent);
finish();
}
}
@Override
public void onBackPressed() {
if (rootPath.equals(currentPath)) {
super.onBackPressed();
} else {
File file = new File(currentPath);
currentPath = file.getParentFile().getPath();
refreshListItems(currentPath);
}
}
} 这部分代码由于和我们本篇文件的主旨没什么关系，主要是为了方便demo展示的，因此我就不进行讲解了。
接下来修改MainActivity中的代码，如下所示：
java
/**
* 仿360手机助手秒装和智能安装功能的主Activity。
* 原文地址：http://blog.csdn.net/guolin_blog/article/details/47803149
* @author guolin
* @since 2015/12/7
*/
public class MainActivity extends AppCompatActivity {
TextView apkPathText;
String apkPath;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
apkPathText = (TextView) findViewById(R.id.apkPathText);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == 0 && resultCode == RESULT_OK) {
apkPath = data.getStringExtra("apk_path");
apkPathText.setText(apkPath);
}
}
public void onChooseApkFile(View view) {
Intent intent = new Intent(this, FileExplorerActivity.class);
startActivityForResult(intent, 0);
}
public void onSilentInstall(View view) {
if (!isRoot()) {
Toast.makeText(this, "没有ROOT权限，不能使用秒装", Toast.LENGTH_SHORT).show();
return;
}
if (TextUtils.isEmpty(apkPath)) {
Toast.makeText(this, "请选择安装包！", Toast.LENGTH_SHORT).show();
return;
}
final Button button = (Button) view;
button.setText("安装中");
new Thread(new Runnable() {
@Override
public void run() {
SilentInstall installHelper = new SilentInstall();
final boolean result = installHelper.install(apkPath);
runOnUiThread(new Runnable() {
@Override
public void run() {
if (result) {
Toast.makeText(MainActivity.this, "安装成功！", Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(MainActivity.this, "安装失败！", Toast.LENGTH_SHORT).show();
}
button.setText("秒装");
}
});
}
}).start();
}
public void onForwardToAccessibility(View view) {
}
public void onSmartInstall(View view) {
}
/**
* 判断手机是否拥有Root权限。
* @return 有root权限返回true，否则返回false。
*/
public boolean isRoot() {
boolean bool = false;
try {
bool = new File("/system/bin/su").exists() || new File("/system/xbin/su").exists();
} catch (Exception e) {
e.printStackTrace();
}
return bool;
}
} 可以看到，在MainActivity中，我们对四个按钮点击事件的回调方法都进行了定义，当点击选择安装包按钮时就会调用onChooseApkFile()方法，当点击秒装按钮时就会调用onSilentInstall()方法。在onChooseApkFile()方法方法中，我们通过Intent打开了FileExplorerActivity，然后在onActivityResult()方法当中读取选择的apk文件路径。在onSilentInstall()方法当中，先判断设备是否ROOT，如果没有ROOT就直接return，然后判断安装包是否已选择，如果没有也直接return。接下来我们开启了一个线程来调用SilentInstall.install()方法，因为安装过程会比较耗时，如果不开线程的话主线程就会被卡住，不管安装成功还是失败，最后都会使用Toast来进行提示。
代码就这么多，最后我们来配置一下AndroidManifest.xml文件：
XML
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.installtest">
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name=".FileExplorerActivity"/>
</application>
</manifest> 并没有什么特殊的地方，由于选择apk文件需要读取SD卡，因此在AndroidManifest.xml文件中要记得声明读SD卡权限。
另外还有一点需要注意，在Android 6.0系统中，读写SD卡权限被列为了危险权限，因此如果将程序的targetSdkVersion指定成了23则需要做专门的6.0适配，这里简单起见，我把targetSdkVersion指定成了22，因为6.0的适配工作也不在文章的讲解范围之内。
现在运行程序，就可以来试一试秒装功能了，切记手机一定要ROOT，效果如下图所示：
可以看到，这里我们选择的网易新闻安装包已成功安装到手机上了，并且没有弹出系统的安装界面，由此证明秒装功能已经成功实现了.
2、智能安装
那么对于ROOT过的手机，秒装功能确实可以避免弹出系统安装界面，在不影响用户操作的情况下实现静默安装，但是对于绝大部分没有ROOT的手机，这个功能是不可用的。那么我们应该怎么办呢？为此360手机助手提供了一种折中方案，就是借助Android提供的无障碍服务来实现智能安装。所谓的智能安装其实并不是真正意义上的静默安装，因为它还是要弹出系统安装界面的，只不过可以在安装界面当中释放用户的操作，由智能安装功能来模拟用户点击，安装完成之后自动关闭界面。这个功能是需要用户手动开启的，并且只支持Android 4.1之后的手机，如下图所示：
的，那么接下来我们就模仿一下360手机助手，来实现类似的智能安装功能。
智能安装功能的实现原理要借助Android提供的无障碍服务，关于无障碍服务的详细讲解可参考官方文档：http://developer.android.com/guide/topics/ui/accessibility/services.html。
首先在res/xml目录下新建一个accessibility_service_config.xml文件，代码如下所示：
XML
<accessibility-service xmlns:android="http://schemas.android.com/apk/res/android"
android:packageNames="com.android.packageinstaller"
android:description="@string/accessibility_service_description"
android:accessibilityEventTypes="typeAllMask"
android:accessibilityFlags="flagDefault"
android:accessibilityFeedbackType="feedbackGeneric"
android:canRetrieveWindowContent="true"
/> 其中，packageNames指定我们要监听哪个应用程序下的窗口活动，这里写com.android.packageinstaller表示监听Android系统的安装界面。description指定在无障碍服务当中显示给用户看的说明信息，上图中360手机助手的一大段内容就是在这里指定的。accessibilityEventTypes指定我们在监听窗口中可以模拟哪些事件，这里写typeAllMask表示所有的事件都能模拟。accessibilityFlags可以指定无障碍服务的一些附加参数，这里我们传默认值flagDefault就行。accessibilityFeedbackType指定无障碍服务的反馈方式，实际上无障碍服务这个功能是Android提供给一些残疾人士使用的，比如说盲人不方便使用手机，就可以借助无障碍服务配合语音反馈来操作手机，而我们其实是不需要反馈的，因此随便传一个值就可以，这里传入feedbackGeneric。最后canRetrieveWindowContent指定是否允许我们的程序读取窗口中的节点和内容，必须写true。
记得在string.xml文件中写一下description中指定的内容，如下所示：
XML
<resources>
<string name="app_name">InstallTest</string>
<string name="accessibility_service_description">智能安装服务，无需用户的任何操作就可以自动安装程序。</string>
</resources> 接下来修改AndroidManifest.xml文件，在里面配置无障碍服务：
XML
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.installtest">
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme">
......
<service
android:name=".MyAccessibilityService"
android:label="我的智能安装"
android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
<intent-filter>
<action android:name="android.accessibilityservice.AccessibilityService" />
</intent-filter>
<meta-data
android:name="android.accessibilityservice"
android:resource="@xml/accessibility_service_config" />
</service>
</application>
</manifest> 这部分配置的内容多数是固定的，必须要声明一个android.permission.BIND_ACCESSIBILITY_SERVICE的权限，且必须要有一个值为android.accessibilityservice.AccessibilityService的action，然后我们通过<meta-data>将刚才创建的配置文件指定进去。
接下来就是要去实现智能安装功能的具体逻辑了，创建一个MyAccessibilityService类并继承自AccessibilityService，代码如下所示：
java
/**
* 智能安装功能的实现类。
* 原文地址：http://blog.csdn.net/guolin_blog/article/details/47803149
* @author guolin
* @since 2015/12/7
*/
public class MyAccessibilityService extends AccessibilityService {
Map<Integer, Boolean> handledMap = new HashMap<>();
public MyAccessibilityService() {
}
@Override
public void onAccessibilityEvent(AccessibilityEvent event) {
AccessibilityNodeInfo nodeInfo = event.getSource();
if (nodeInfo != null) {
int eventType = event.getEventType();
if (eventType== AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED ||
eventType == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED) {
if (handledMap.get(event.getWindowId()) == null) {
boolean handled = iterateNodesAndHandle(nodeInfo);
if (handled) {
handledMap.put(event.getWindowId(), true);
}
}
}
}
}
private boolean iterateNodesAndHandle(AccessibilityNodeInfo nodeInfo) {
if (nodeInfo != null) {
int childCount = nodeInfo.getChildCount();
if ("android.widget.Button".equals(nodeInfo.getClassName())) {
String nodeContent = nodeInfo.getText().toString();
Log.d("TAG", "content is " + nodeContent);
if ("安装".equals(nodeContent)
|| "完成".equals(nodeContent)
|| "确定".equals(nodeContent)) {
nodeInfo.performAction(AccessibilityNodeInfo.ACTION_CLICK);
return true;
}
} else if ("android.widget.ScrollView".equals(nodeInfo.getClassName())) {
nodeInfo.performAction(AccessibilityNodeInfo.ACTION_SCROLL_FORWARD);
}
for (int i = 0; i < childCount; i++) {
AccessibilityNodeInfo childNodeInfo = nodeInfo.getChild(i);
if (iterateNodesAndHandle(childNodeInfo)) {
return true;
}
}
}
return false;
}
@Override
public void onInterrupt() {
}
} 代码并不复杂，我们来解析一下。每当窗口有活动时，就会有消息回调到onAccessibilityEvent()方法中，因此所有的逻辑都是从这里开始的。首先我们可以通过传入的AccessibilityEvent参数来获取当前事件的类型，事件的种类非常多，但是我们只需要监听TYPE_WINDOW_CONTENT_CHANGED和TYPE_WINDOW_STATE_CHANGED这两种事件就可以了，因为在整个安装过程中，这两个事件必定有一个会被触发。当然也有两个同时都被触发的可能，那么为了防止二次处理的情况，这里我们使用了一个Map来过滤掉重复事件。
接下来就是调用iterateNodesAndHandle()方法来去解析当前界面的节点了，这里我们通过递归的方式将安装界面中所有的子节点全部进行遍历，当发现按钮节点的时候就进行判断，按钮上的文字是不是"安装"、"完成"、"确定"这几种类型，如果是的话就模拟一下点击事件，这样也就相当于帮用户自动操作了这些按钮。另外从Android 4.4系统开始，用户需要将应用申请的所有权限看完才可以点击安装，因此如果我们在节点中发现了ScrollView，那就模拟一下滑动事件，将界面滑动到最底部，这样安装按钮就可以点击了。
最后，回到MainActivity中，来增加对智能安装功能的调用，如下所示
java
/**
* 仿360手机助手秒装和智能安装功能的主Activity。
* 原文地址：http://blog.csdn.net/guolin_blog/article/details/47803149
* @author guolin
* @since 2015/12/7
*/
public class MainActivity extends AppCompatActivity {
......
public void onForwardToAccessibility(View view) {
Intent intent = new Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS);
startActivity(intent);
}
public void onSmartInstall(View view) {
if (TextUtils.isEmpty(apkPath)) {
Toast.makeText(this, "请选择安装包！", Toast.LENGTH_SHORT).show();
return;
}
Uri uri = Uri.fromFile(new File(apkPath));
Intent localIntent = new Intent(Intent.ACTION_VIEW);
localIntent.setDataAndType(uri, "application/vnd.android.package-archive");
startActivity(localIntent);
}
} 当点击了开启智能安装服务按钮时，我们通过Intent跳转到系统的无障碍服务界面，在这里启动智能安装服务。当点击了智能安装按钮时，我们通过Intent跳转到系统的安装界面，之后所有的安装操作都会自动完成了。
现在可以重新运行一下程序，效果如下图所示：可以看到，当打开网易新闻的安装界面之后，我们不需要进行任何的手动操作，界面的滑动、安装按钮、完成按钮的点击都是自动完成的，最终会自动回到手机原来的界面状态，这就是仿照360手机助手实现的智能安装功能。
3、监听安装卸载apk完成方式：
第一步：新建监听类BootReceiver继承BroadcastReceiver
java
package com.rongfzh.yc;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
public class BootReceiver extends BroadcastReceiver{
@Override
public void onReceive(Context context, Intent intent){
//接收安装广播
if (intent.getAction().equals("android.intent.action.PACKAGE_ADDED")) {
String packageName = intent.getDataString();
System.out.println("安装了:" +packageName + "包名的程序");
}
//接收卸载广播
if (intent.getAction().equals("android.intent.action.PACKAGE_REMOVED")) {
String packageName = intent.getDataString();
System.out.println("卸载了:" + packageName + "包名的程序");
}
}
} 第二步：修改AndroidManifest.xml配置文件，添加广播介绍，添加监听的权限
XML
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.rongfzh.yc"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk android:minSdkVersion="7" />
<application
android:icon="@drawable/ic_launcher"
android:label="@string/app_name" >
<activity
android:name=".PakDetectActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<receiver android:name=".BootReceiver"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.PACKAGE_ADDED" />
<action android:name="android.intent.action.PACKAGE_REMOVED" />
<data android:scheme="package" />
</intent-filter>
</receiver>
</application>
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.RESTART_PACKAGES"/>
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
</manifest>第三步：运行程序卸载一个程序ApiDemos程序打印日志如下
System.out(1513): 卸载了:package:com.example.android.apis包名的程序
第四步：安装腾讯微博，打印日志如下：
System.out(1513): 安装了:package:com.tencent.WBlog包名的程序
Android之更新xUtils3
说实话，对于xUtils，是我最近才用到的开发框架（也是刚接触），对于其功能不得不说，简化了很多的开发步骤，可以说是非常好的开发工具，但是其最近更新到3.0也没有解决加载自定义ImageView报错的问题。
我总是喜欢用一些最新的东西，xUtils 3.0才刚更新，是一次比较大的重构，对于百度到的使用规则，基本都是3.0以前的，使得用3.0的开发者需要求解用法的时候，遇到许多阻碍，故此在这里简单介绍xUtils 3.0的使用规则。关于怎么导入功能，其实并不是本文的内容，不过在此文最后一节简单讲解了一下导入的方式
1.xUtils中的IOC框架
使用xUtils的第一步就是必须创建自己的Application类，代码如下：
public class LYJApplication extends Application { @Override public void onCreate() { super.onCreate(); x.Ext.init(this);//Xutils初始化 }}
在AndroidManifest.xml的application标签中添加如下代码：
android:name=".LYJApplication"
这样初始化就算完成了。
使用IOC框架的代码如下：
java
import org.xutils.view.annotation.ContentView;
import org.xutils.view.annotation.Event;
import org.xutils.view.annotation.ViewInject;
import org.xutils.x;
@ContentView(value = R.layout.activity_main)
public class MainActivity extends AppCompatActivity {
@ViewInject(value = R.id.mybut)
private Button mybut;
@Override protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
x.view().inject(this);
}
@Event(value = R.id.mybut,type = View.OnClickListener.class)
private void onButtonClick(View v){
switch (v.getId()){
case R.id.mybut:
Toast.makeText(this,"你好我是Xutils的IOC功能",Toast.LENGTH_SHORT).show();
break;
}
}
}需要解释的以下几点：
其一：使用IOC必须全部为私有，不然无效，这里就做演示了，不信你可以把用到IOC框架的注解的成员变量及方法全部换成public ,那么全部会无效，当然除了ContentView例外。
其二，所有用到IOC成员变量，使用的时候，必须在x.view().inject(this)后，如果写在前面，那么程序会崩溃。
2.xUtils加载图片功能
现在我们需要设置两个权限，如下：
XML
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />接下来就是加载网络图片到imageView中：
java
x.image().bind(image,"http://pic.baike.soso.com/p/20090711/20090711101754-314944703.jpg");也可以设置参数：
java
ImageOptions imageOptions = new ImageOptions.Builder()
.setSize(DensityUtil.dip2px(120), DensityUtil.dip2px(120)) //图片大小
.setRadius(DensityUtil.dip2px(5)) //ImageView圆角半径
.setCrop(true) // 如果ImageView的大小不是定义为wrap_content, 不要crop.
.setImageScaleType(ImageView.ScaleType.CENTER_CROP)
.setLoadingDrawableId(R.mipmap.ic_launcher) //加载中默认显示图片
.setFailureDrawableId(R.mipmap.ic_launcher) //加载失败后默认显示图片
.build();
x.image().bind(image, "http://pic.baike.soso.com/p/20090711/20090711101754-314944703.jpg",imageOptions);你也可以将第2个参数设置为图片文件路径，那么将从SD卡中加载图片。
3.xUtils操作数据库
我们都知道，一个App中操作数据库的地方有很多，就像是否登录一样，有些地方必须登录后才能操作，那么肯定是全局变量，所以，必须将数据库的初始化放在Application，且必须提供获取数据库的方法，使得在应用程序的任何地方都可以直接获取数据库，并操作数据库，不然重复的获取与释放只能增加内存无谓的消耗。
初始化数据库：
java
public class LYJApplication extends Application {
private DbManager.DaoConfig daoConfig;
public DbManager.DaoConfig getDaoConfig() {
return daoConfig;
}
@Override
public void onCreate() {
super.onCreate();
x.Ext.init(this);//Xutils初始化
daoConfig = new DbManager.DaoConfig()
.setDbName("lyj_db")//创建数据库的名称
.setDbVersion(1)//数据库版本号
.setDbUpgradeListener(new DbManager.DbUpgradeListener() {
@Override public void onUpgrade(DbManager db, int oldVersion, int newVersion) {
// TODO: ...
// db.addColumn(...);
// db.dropTable(...);
// ... }
});
//数据库更新操作
}
}上面的注释明了，有必要说明的一点是setDbDir(new File("/sdcard"))，可以将数据库存储在你想存储的地方，如果不设置，那么数据库默认存储在/data/data/你的应用程序/database/xxx.db下。这里我们就默认放在应用程序下。
我们首先创建一个实体类，如下：
java
@Table(name="lyj_person")
public class LYJPerson {
@Column(name = "id", isId = true)
private int id;
@Column(name = "name")
private String name;
@Column(name = "age")
private String age;
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}通过实体类可以直接操作数据库。
我们在Application中加入如下代码，向数据库添加数据：
java
DbManager db = x.getDb(daoConfig);
LYJPerson person1=new LYJPerson();
person1.setName("liyuanjinglyj");
person1.setAge("23");
LYJPerson person2=new LYJPerson();
person2.setName("xutilsdemo");
person2.setAge("56");
try {
db.save(person1);
db.save(person2);
} catch (DbException e) {
e.printStackTrace();
}在Activity中操作获取数据库数据的代码如下：
java
DbManager db = x.getDb(((LYJApplication)getApplicationContext()).getDaoConfig());
try {
List<LYJPerson> lyjPersons=db.selector(LYJPerson.class).findAll();
for (int i=0;i<lyjPersons.size();i++){
Log.i("liyuanjinglyj","LYJPerson"+i+".name="+lyjPersons.get(i).getName());
Log.i("liyuanjinglyj","LYJPerson"+i+".name="+lyjPersons.get(i).getAge());
}
} catch (DbException e) {
e.printStackTrace();
}4.xUtils的网络请求
Android规定UI线程是不能涉及网络任务的，所以，这里主要简单介绍Xutils的异步网络请求，同步的自行探究。使用格式如下：
java
RequestParams params = new RequestParams("http://blog.csdn.net/mobile/experts.html");
x.http().get(params, new Callback.CommonCallback<String>() {
@Override
public void onSuccess(String result) {
Document doc = Jsoup.parse(result);
Element div = doc.select("div.list_3").get(0);
Elements imgs = div.getElementsByTag("img");
for (int i = 0; i < imgs.size(); i++) {
Element img = imgs.get(i);
Log.i("liyuanjinglyj",img.attr("alt"));
}
}
@Override
public void onError(Throwable ex, boolean isOnCallback) {
}
@Override
public void onCancelled(Callback.CancelledException cex) {
}
@Override
public void onFinished() {
}
});这里获取的是CSDN移动博客专家的HTML页面信息，看看下面的日志，就知道Xutils网络功能还是很强大的。
本文最后附带了一下粗略模仿CSDN APP的源码，有意者可以下载看看，里面用到另一个开发框架，我用来专门处理图片的（afinal）。都说xUtils是afinal的进化版，不过在图片方面，我们觉得xUtils还有点不足。
http://download.csdn.net/detail/liyuanjinglyj/9379103
5.导入xUtils工程到Android Studio
下载地址如下：https://github.com/wyouflf/xUtils3/tree/master
- 将下载的工程复制到Project目录下
- 添加到settings.gradle文件：include ':app',':xutils'
- 编译到工程中：
dependencies { compile fileTree(dir: 'libs', include: ['*.jar']) compile 'com.android.support:appcompat-v7:23.0.1' compile project(':xutils')}
- 将xutils文件夹下的build.gradle中的版本与最低版本调整到与创建工程一致
ompileSdkVersion 23buildToolsVersion "23.0.1"defaultConfig { minSdkVersion 15 targetSdkVersion 23 versionCode 20151224 versionName version}
- 添加如下代码到build.gradle（Project:XutilsDemo）中
dependencies { classpath 'com.android.tools.build:gradle:1.3.0' classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.2' classpath 'com.github.dcendents:android-maven-gradle-plugin:1.3' // NOTE: Do not place your application dependencies here; they belong // in the individual module build.gradle files}
点击Sync now就可以使用xUtils了
Activity之数据恢复与传递
2019-01-10记录，因为BaseActivity对于数据恢复与保存已经参数传递比较混乱，维护起来很多时候都不记得自己以前写的什么代码了，因此在对其重新进行了封装与优化。
1、Activity之间进行数据传递：
ActivityA启动ActivityB代码如下：
html
Intent intent=new Intent(ActivityA.this,ActivityB.class);
intent.putExtra("SHEN","我是传递过来的参数");
startActivity(intent);ActivityB中进行参数接收：
html
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test);
testView=findViewById(R.id.param_text);
saveView=findViewById(R.id.save_text);
rstoreView=findViewById(R.id.restore_text);
if(savedInstanceState!=null){
testView.setText("savedInstanceState="+savedInstanceState.getString("SHEN","null"));
}else{
testView.setText("getIntent="+getIntent().getStringExtra("SHEN"));
}
}日志打印知道这个时候的savedInstanceState是为null，传递过来的参数通过getIntent().getStringExtra("SHEN")成功获取了
2、Activity的数据保存与恢复
ActivityB中对刚刚传递过来的数据进行异常销毁保存
html
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putString("SHEN","我是保存的数据");
saveView.setText("onSaveInstanceState-我是保存的数据");
}ActivityB刚刚异常保存的数据进行恢复：
html
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState){
super.onRestoreInstanceState(savedInstanceState);
rstoreView.setText("onRestoreInstanceState-"+savedInstanceState.getString("SHEN"));
}日志打印可以看出，onCreate里面的savedInstanceState参数不在为NULL，并且通过savedInstanceState.getString("SHEN","null")将异常销毁的时候保存的数据成功拿取出来了，onRestoreInstanceState里面的savedInstanceState参数也将这个数据成功的拿取出来了
3、结论：
1、如果是为了获取其他activity传递过来的参数，就可以在onCreate里面使用getIntent().getStringExtra("SHEN")来获取
2、如果是恢复异常销毁的时候保存的数据，就可以在onCreate里面使用savedInstanceState.getString("SHEN","null")来获取，也可以在onRestoreInstanceState里面使用savedInstanceState.getString("SHEN","null")来获取
4、分析：
onSaveInstanceState的调用时机：
答案是当activity有可能被系统回收的情况下，而且是在onStop()之前。注意是有可能，如果是已经确定会被销毁，比如用户按下了返回键，或者调用了finish()方法销毁activity，则onSaveInstanceState不会被调用。
或者也可以说，此方法只有在activity被异常终止的情况下会被调用。
总结下，onSaveInstanceState(Bundle outState)会在以下情况被调用：
1、当用户按下HOME键时。
2、从最近应用中选择运行其他的程序时。
3、按下电源按键（关闭屏幕显示）时。
4、从当前activity启动一个新的activity时。
5、屏幕方向切换时(无论竖屏切横屏还是横屏切竖屏都会调用)。
在前4种情况下，当前activity的生命周期为：
onPause -> onSaveInstanceState -> onStop。
（这个是我测试的结果，但是根据《Android开发艺术探索》，说onPause和onSaveInstanceState的顺序是不一定的）
onRestoreInstanceState调用时机：
onRestoreInstanceState(Bundle savedInstanceState)只有在activity确实是被系统回收，重新创建activity的情况下才会被调用。
比如第5种情况屏幕方向切换时，activity生命周期如下：
onPause -> onSaveInstanceState -> onStop -> onDestroy -> onCreate -> onStart -> onRestoreInstanceState -> onResume
在这里onRestoreInstanceState被调用，是因为屏幕切换时原来的activity确实被系统回收了，又重新创建了一个新的activity。
（顺便吐槽一下网上的那些文章说横屏切竖屏和竖屏切横屏时activity生命周期方法执行不一样，经自己实践证明是一样的。）
而按HOME键返回桌面，又马上点击应用图标回到原来页面时，activity生命周期如下：
onPause -> onSaveInstanceState -> onStop -> onRestart -> onStart -> onResume
因为activity没有被系统回收，因此onRestoreInstanceState没有被调用。
如果onRestoreInstanceState被调用了，则页面必然被回收过，则onSaveInstanceState必然被调用过。
onCreate与onRestoreInstanceState里面都有Bundle参数都可以用来进行数据恢复，他们有甚区别：
因为onSaveInstanceState 不一定会被调用，所以onCreate()里的Bundle参数可能为空，如果使用onCreate()来恢复数据，一定要做非空判断。
而onRestoreInstanceState的Bundle参数一定不会是空值，因为它只有在上次activity被回收了才会调用。
而且onRestoreInstanceState是在onStart()之后被调用的。有时候我们需要onCreate()中做的一些初始化完成之后再恢复数据，用onRestoreInstanceState会比较方便。下面是官方文档对onRestoreInstanceState的说明：
This method is called after onStart() when the activity is being re-initialized from a previously saved state, given here in savedInstanceState. Most implementations will simply use onCreate(Bundle) to restore their state, but it is sometimes convenient to do it here after all of the initialization has been done or to allow subclasses to decide whether to use your default implementation.
1
注意这个说明的最后一句是什么意思？
to allow subclasses to decide whether to use your default implementation.
它是说，用onRestoreInstanceState方法恢复数据，你可以决定是否在方法里调用父类的onRestoreInstanceState方法，即是否调用super.onRestoreInstanceState(savedInstanceState);
而用onCreate()恢复数据，你必须调用super.onCreate(savedInstanceState);
否则运行会报如下错误：
E/AndroidRuntime( 4964): android.util.SuperNotCalledException: Activity {com.example.test/com.example.test.SecondActivity} did no
t call through to super.onCreate()
E/AndroidRuntime( 4964): at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2331)
E/AndroidRuntime( 4964): at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:2426)
E/AndroidRuntime( 4964): at android.app.ActivityThread.access$800(ActivityThread.java:153)
E/AndroidRuntime( 4964): at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1345)
E/AndroidRuntime( 4964): at android.os.Handler.dispatchMessage(Handler.java:110)
E/AndroidRuntime( 4964): at android.os.Looper.loop(Looper.java:193)
E/AndroidRuntime( 4964): at android.app.ActivityThread.main(ActivityThread.java:5386)
E/AndroidRuntime( 4964): at java.lang.reflect.Method.invokeNative(Native Method)
E/AndroidRuntime( 4964): at java.lang.reflect.Method.invoke(Method.java:515)
E/AndroidRuntime( 4964): at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:829)
E/AndroidRuntime( 4964): at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:645)
E/AndroidRuntime( 4964): at dalvik.system.NativeStart.main(Native Method)
--------- beginning of /dev/log/main
参考文章：
Android onSaveInstanceState()和onRestoreInstanceState()调用时机： Android onSaveInstanceState()和onRestoreInstanceState()调用时机_onsaveinstancestate(),onrestoreinstancestate的掉用时机-CSDN博客
Activity之弹出对话框如何防止全屏模式失效
2019-03-13记录，Activity的全屏模式如下，因为兼容android6.0，就直接动态代码实现：
java
//在activity的onCreate方法中先调用此方法在setContent进行实现全屏模式
private void setFullScreenMode(){
//设置永不休眠模式
getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,
WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
//隐藏系统工具栏方式一
getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LOW_PROFILE);
//隐藏底部导航栏
View decorView = getWindow().getDecorView();
if (Build.VERSION.SDK_INT > 11 && Build.VERSION.SDK_INT < 19) {
decorView.setSystemUiVisibility(View.GONE);
} else if (Build.VERSION.SDK_INT >= 19) {
decorView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
| View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
| View.SYSTEM_UI_FLAG_FULLSCREEN);
}
decorView.setOnSystemUiVisibilityChangeListener(new View.OnSystemUiVisibilityChangeListener(){
@Override
public void onSystemUiVisibilityChange(int visibility) {
View decorView = getWindow().getDecorView();
int uiState=decorView.getSystemUiVisibility();
if (Build.VERSION.SDK_INT > 11 && Build.VERSION.SDK_INT < 19) {
if(uiState!=View.GONE) decorView.setSystemUiVisibility(View.GONE);
} else if (Build.VERSION.SDK_INT >= 19) {
if(uiState!=(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
| View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
| View.SYSTEM_UI_FLAG_FULLSCREEN))
decorView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
| View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
| View.SYSTEM_UI_FLAG_FULLSCREEN);
}
}
});
}然而，现实对话框的时候，在华为的平板上，下面本来被隐藏的导航栏显示了出来，而且activity被上下压缩，很不美观，最开始以为是theme引起的，结果然并卵，网上也没有查到相关资料，好吧，我没就从dialog入手吧。
dialog内部其实也是一个Window，然后将视图资源加载进去，那么初步怀疑出现这种情况的原因：dialog弹出来后用了dialog的window,这个window很显然是默认的属性不是全屏的。
既然上面实现全屏模式是通过设置Window的属性，那么就依葫芦画瓢将dialog的window也想如上设置，将上面方法更改，参数传递一个Window进去，代码如下：
java
public void showDialog(){
AlertDialog dialog=new AlertDialog.Builder(_rootActivity)
.setTitle("确定删除班级"+nameView.getText().toString()+"吗？")
.setPositiveButton("是", this)
.setNegativeButton("否", null)
.create();
final Window window=dialog.getWindow();
setFullScreenMode(window);
dialog.show();
}
private void setFullScreenMode(Window window){
//设置永不休眠模式
window.setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,
WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
//隐藏系统工具栏方式一
window.getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LOW_PROFILE);
//隐藏底部导航栏
View decorView = window.getDecorView();
if (Build.VERSION.SDK_INT > 11 && Build.VERSION.SDK_INT < 19) {
decorView.setSystemUiVisibility(View.GONE);
} else if (Build.VERSION.SDK_INT >= 19) {
decorView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
| View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
| View.SYSTEM_UI_FLAG_FULLSCREEN);
}
decorView.setOnSystemUiVisibilityChangeListener(new View.OnSystemUiVisibilityChangeListener(){
@Override
public void onSystemUiVisibilityChange(int visibility) {
View decorView = getWindow().getDecorView();
int uiState=decorView.getSystemUiVisibility();
if (Build.VERSION.SDK_INT > 11 && Build.VERSION.SDK_INT < 19) {
if(uiState!=View.GONE) decorView.setSystemUiVisibility(View.GONE);
} else if (Build.VERSION.SDK_INT >= 19) {
if(uiState!=(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
| View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
| View.SYSTEM_UI_FLAG_FULLSCREEN))
decorView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
| View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
| View.SYSTEM_UI_FLAG_FULLSCREEN);
}
}
});
}Ok,经过测试上面问题完全解决，弹出来的对话框不会在改变activity的宽高了