Android中的进程优先级：
进程优先级仅仅是供Android虚拟机查看的，进程优先级越低，
那么在Android运行时若内存趋于阈值时，将会先被杀掉。
当android管理的内存接近阀值时会杀掉一些进程优先级低的进程来释放内存
Android会为每一个应用程序开启一个进程或者多个进程；
而给每个进程分配的内存也是有限的（比如75mb）；
不够就可以开启子进程又给你分配75mb；手机对进程的管理比较严格，因为内存有限；
没有一个进程是可以善终的，因为每启动一个程序都会最少起一个进程，即使你关闭了所有的程序界面，
这个进程也不会主动结束，而是等着内存不足时由android系统来将其中一部分强制杀死；
进程也有ID号，按back键结束的只是应用程序，而不是进程；
但是这个强制杀死的动作会先杀死那个进程呢？
如你写了好多东西刚要发送，但是由于内存不足而系统杀死了这个程序对应的进程，这样用户是很恼火的；
android里的进程只能启动，没有主动退出机制；
这就必然导致它越启动越多呀，总会把内存占满吧？怎么杀呢，先杀进程优先级低的；
在大多数情况下，每个Android应用程序都运行在自己的Linux进程中，
当应用程序的某些代码需要运行时，这个进程就被创建并一直运行下去，
直到系统认为该进程不再有用为止，然后系统将回收进程占用的内存以便分配给其它的应用程序
Android会尽可能长时间的为应用程序维持进程。
有五级：由最低到最高
1.空进程empty：进程中不包含任何组件实例；一旦内存不足就会首先被杀死;
这个进程当中已经没有任何一个还存活的组件实例，所有的组件实例都被销毁了；
不是没有类了或者代码执行了；是没有组件了，因为就算所有的activity都结束了，
进程也没有结束；但是这时进程里已经没有组件运行了；
哪怕你忙的四脚朝天，但是已经没有组件实例了，那么你就属于空进程；
闲的没事干，但还有组件实例活着，就都不属于空进程；
按back键销毁了activity，且没有其他任何组件了，成了空进程，
但是该activity中启动的那个线程还在运行；
不包含任何处于活动状态的应用程序组件。
保留这种进程的唯一原因是，当下次应用程序的某个组件需要运行时，
不需要重新创建进程，这样可以提高启动速度。
2.后台进程：基本上经常被杀死；后台包含处于onStop停止状态的activity实例；
所有组件都在后天运行
拥有一个当前用户看不到的Activity（它的onStop()方法被调用）。
这些进程对用户体验没有直接的影响。如果它们正确执行了Activity生命期，
系统可以在任意时刻杀死进程来回收内存，并提供给下面三种类型的进程使用。
3.服务进程：90%的情况是不会被杀死的；service和activity唯一的区别是没有界面；
就是这个进程里至少还有一个service实例在运行，此处引出service；
Service运行的进程有一个已经用startService()方法启动的Service。
虽然这些进程用户无法直接看到，但它们做的事情却是用户所关心的
例如后台MP3播放、后台数据上传下载等）。
因此，系统将一直运行这些进程除非内存不足以维持所有的前台进程和可见进程
4.可见进程：一般不会被杀死的；用户能看见但不能操作的处于onPause暂停状态的activity实例
1）进程中包含处于暂停可见状态的Activity实例 （上面透明的Activity2将Activity1透出来）
暂停状态的另一种情况是二个activity正在切换的瞬间；
2）进程中包含处于暂停状态的Activity实例绑定的Service实例此进程可见，但没有用户焦点
它有一个可以被用户从屏幕上看到的Activity，但不在前台，它的onPause()方法被调用。
这样的进程一般不允许被杀死，除非为了保证前台进程的运行不得不这样做
5.前台进程：不会被杀死，除非机器死机扣电池;前台正处于和用户交互状态的activity实例
1）进程中包含处于onResume交互状态的Activity实例
2）进程中包含正在执行生命周期方法的组件实例
3）进程中包含与交互状态的Activity实例绑定的Service实例
4）进程中包含执行了setForground（true）方法的Service实例
正在与用户交互的进程
与用户当前正在做的事情密切相关。
不同的应用程序组件能够通过不同的方法使它的宿主进程移到前台。
当下面任何一个条件满足时，可以考虑将进程移到前台：
（1）进程正在运行一个与用户交互的Activity ，它的onResume()方法被调用
（2）进程有一个Service，该Service对应的Activity正在与用户交互
（3）进程有一个Service被调用startForeground()方法，要求到前台来执行
（4）进程有一个Service，并且在Service的某个回调函数
（onCreate()、onStart()、或onDestroy()）内有正在执行的代码。
（5）进程有一正在运行的BroadcastReceiver，它的onReceive()方法正在执行
下载了几十首歌，不想等：
点击ＨＯＭＥ键：只是回到后台，他还存在，那他就是一个后台进程；
点击ＢＡＣＫ键：唯一的activity就结束了，这时后台下载音乐的那个进程就成了空进程了；
什么是Service
1>核心组件，有对应的生命周期方法，必须注册。
2>通常通过Activity或者其他Context对象来调用
Context.startService/bindService()
启动工作线程在后台执行耗时操作服务于Activity,没有界面、没有交互；
适合长时间后台运行的场合，适用于需要长时间（是在service中启动的工作线程中执行耗时操作，service本身的生命周期方法是运行在主线程的）在后台运行的情况，比如说长时间的音乐下载或播放；不过活还是得线程干，只是在service里创建的工作线程可以保障线程活的时间更长；
3>是Context的子类，具备资源访问能力；
所以是可以在server中启动一个有界面的Activity的；
Activity中能写的那些操作界面的东西在service中都可以操作；
4>提高所在进程的优先级到服务进程，
Service实例所在的进程拥有较高的优先级，处于三级（服务进程），
不容易被杀死；提高进程优先级给在其内部的任务保驾护航，
活着只是对线程中任务顺利安全执行的一种保障；起service,再起线程；
7>和activity一样，也是控制器；
组件和容器是分不开的：
1.android的四大组件只有在android这个大的容器中才能正常运行的；
2. jsp组件必须在tomacat这个容器中才能正常使用的；
使用Service的一般步骤
1> 编写一个Java类继承Service。
2> 重写其父类的生命周期方法。
onCreate()
onStartCommand()
onDestroy()
3> 在AndroidManifest.xml中使用service标签注册
启动service的二种方式
1.创建意图（intent）
Intent intent=new Intent(context, Service.class);
Intent.putXXX();//可以传递参数给service
2.启动模式的service用context.startService(intent)启动;
绑定模式的service用context.bindService()方法启动，
调用context.unbindService()方法结束，
还可以通过ServiceConnection访问Service；
在service每一次的开启关闭过程中，只有onStartCommand（）方法可被多次调用
（通过多次startService()方法调用），
其他onCreate、onBind、onUnbind、onDestroy在一个生命周期中只能被调用一次；
Service在启动模式下的生命周期方法（都运行在主线程）：
当我们第一次启动Service时，先后调用了onCreate()、onStartCommand()这二个方法，
当停止service时则执行onDestroy()方法；
这里需要注意的是，如果service已经启动了，当我们再次启动service时
不会再执行onCreate()方法，而是直接执行onStartCommand()方法；
所以一个service的onStartCommand()方法会被重复得调用多次，
stopSerive时会直接onDestroy;
如果是调用者自己直接退出而没有调用stopService的话，service会一直在后台运行，该service的调用者再启动起来后可以通过stopService关闭Service；
启动模式的activity只能调用service的onStartCommand方法执行业务逻辑；如：context.startService(intent);
而如果我要实现播放音乐、上一首、下一首等多个功能/业务逻辑时
这种启动模式的service就不能适应业务的需要；
1.OnCreate：当创建service实例时（server是全局单例的，所以就只会创建这一次）
执行此方法，像一个人只能生一次；第一次调用startService时创建service实例，
且创建的这个service实例是全局单例的；
2.OnStartCommand:每次执行context.startService()方法启动该实例的时候都会执行该方法，在该方法中执行业务；替换了过时的onStart（）方法；intent参数就是在startService时传过来的intent；startId这个启动id参数在调用startServer方法时android系统为你分配的一个启动id；在该线程中不能直接执行耗时操作，不然会阻塞主线线程，得启动工作线程去执行；
该方法的返回值：
Service.START_STICKY;//当service实例被异常杀死时，android容器将会自动重启该service,但不会重新传入intent;
START_REDELIVER_INTENT //当service实例被异常杀死时，android容器将会自动重启service,并且会重新传入intent;
Service.START_NOT_STICKY;//当service实例被异常杀死时，android容器将不会自动重启该service;
Service.START_STICKY_COMPATIBILITY;//当service实例被异常杀死时，android容器将不确定会不会自动重启该service,并且把intent对象再次传递给该service;表示一种兼容模式；
START_CONTINUATION_MASK：底层系统会从常量（states）中任意选择一个返回
Intent intent：调用startService方法启动Service时传递过来的intent对象
int flags：标示intent是否是重新传入的
1 START_FLAG_REDELIVERY 会重新传入intent
0 START_STICKY 不会重新传入intent
int startId: 每次加1 代表了是那一次启动请求
3.onDestroy:在销毁service实例（stopSelf()）时执行此方法，像人只能死一次；
销毁/停止一个service的二种方式：
1>在activity中调用context.stopService(intent); 他杀
2>在service中调用stopSelf();或者 stopSelf(startId); 自杀
双击会起二个线程去下载，用stopSelf(startId);
自杀是在判断所有service都被销毁了才执行onDestory（）方法
销毁/停止一个service的二种方式：
1>在activity中调用context.stopService(intent); 他杀
2>在service中调用stopSelf();或者 stopSelf(startId); 自杀
双击会起二个线程去下载，用stopSelf(startId);
自杀是在判断所有service都被销毁了才执行onDestory（）方法
如何使用IntentService：
android为我们提供了一个IntentService，
在该IntentService中内置有一个Looper和MessageQuene;
Looper将会轮循消息队列，若消息队列中含有消息对象，则执行该任务。
所以IntentService中内置有一个工作线程顺序执行该消息队列中的任务。
它是service的一个抽象子类，主要用于在后台批量执行的耗时任务处理；
比如播放多媒体的时候用户启动了其他Activity，这个时候程序要在后台继续播放，
比如检测SD卡上文件的变化，再或者在后台记录你地理位置信息的改变等等，总之服务嘛，就是藏在后头的；IntentService和service有所不同，通过Looper和Thread来解决标准Service中处理逻辑阻塞问题；工作原理：其内部包含了一个HandlerThread和一个关联到该工作线程的Handler对象；每次启动时在onStartCommand方法中将intent和startId传入到工作线程中处理；在工作线程中调用onHandleIntent方法执行具体的耗时任务，
并在任务执行完成后调用stopSelf(startId)方法结束本次启动；
销毁/停止一个service的二种方式：
1>在activity中调用context.stopService(intent); 他杀
2>在service中调用stopSelf();或者 stopSelf(startId); 自杀
双击会起二个线程去下载，用stopSelf(startId);
自杀是在判断所有service都被销毁了才执行onDestory（）方法
单线程去一个一个完成消息队列中的任务：
1>编写一个Java类继承IntentService，并在子类的构造方法中调用父类有参的构造方法；
2>重写onHandleIntent()方法，该方法在工作线程中执行。
3>以service的方式在清单文件中注册。
优点：Activity的进程，当处理Intent的时候，会产生一个对应的Service;
Android的进程处理器现在会尽可能的不kill掉你；
IntentService是一个特殊的Service,继承了Service类，
此service在运行时会默认启动一个工作线程，
在工作线程中可以执行耗时操作，此线程中的这个操作执行结束以后，service会自动关闭。
销毁/停止一个service的二种方式：
1>在activity中调用context.stopService(intent); 他杀
2>在service中调用stopSelf();或者 stopSelf(startId); 自杀
双击会起二个线程去下载，用stopSelf(startId);
自杀是在判断所有service都被销毁了才执行onDestory（）方法
class MyService01 extends IntentService{
//在此方法中执行耗时操作
public void onHandleIntent(intent ...){}
}
注意：对于官方给定的IntentService只适用于启动模式。
销毁/停止一个service的二种方式：
1>在activity中调用context.stopService(intent); 他杀
2>在service中调用stopSelf();或者 stopSelf(startId); 自杀
双击会起二个线程去下载，用stopSelf(startId);
自杀是在判断所有service都被销毁了才执行onDestory（）方法
service在绑定模式下的生命周期方法：
Activity能进行绑定得益于Service的接口，
为了支持Serivce的绑定，实现onBind方法；
Service和Activity的连接可以用ServiceConnection来实现，
你需要实现一个新的SerivceConnection，
重写onServiceConnected和onServiceDisconnected方法，
一旦连接建立，你就能得到Service实例的引用；
执行绑定调用bindService方法，传入一个选择了要绑定的Service的Intent(显示或隐式)
和一个实现了ServiceConnection的实例
相当于是activity与service之间建立了一个长连接（SerivceConnection），
在activity中可以借助此对象操作service中的方法；
activity作为客户端，service作为服务器端，建立一个通道，一一对应绑定起来；
activity可以调用service里面声明的任何某一个方法；
客户端调用服务器端方法需要协议（二人说好的接口）；
Context.bindService：//绑定成功后客户端会拿到该service的引用(接口)，
通过引用调用service中的方法；
即绑定成功服务器service会给客户端activity一个IBinder接口；
service会经历onCreate()、onBind()，onBind将返回给客户端一个IBind接口实例，
IBind允许客户端回调服务的方法，比如得到service运行的状态或者其他操作；
这个时候把调用者（context或Activity）会和service绑定在一起，
一旦context退出了，service就会调用onUnbind()->onDestroyed相应退出，
销毁/停止一个service的二种方式：
1>在activity中调用context.stopService(intent); 他杀
2>在service中调用stopSelf();或者 stopSelf(startId); 自杀
双击会起二个线程去下载，用stopSelf(startId);
自杀是在判断所有service都被销毁了才执行onDestory（）方法
service在绑定模式下的生命周期方法：
Activity能进行绑定得益于Service的接口，
为了支持Serivce的绑定，实现onBind方法；
Service和Activity的连接可以用ServiceConnection来实现，
你需要实现一个新的SerivceConnection，
重写onServiceConnected和onServiceDisconnected方法，
一旦连接建立，你就能得到Service实例的引用；
执行绑定调用bindService方法，传入一个选择了要绑定的Service的Intent(显示或隐式)
和一个实现了ServiceConnection的实例
相当于是activity与service之间建立了一个长连接（SerivceConnection），
在activity中可以借助此对象操作service中的方法；
activity作为客户端，service作为服务器端，建立一个通道，一一对应绑定起来；
activity可以调用service里面声明的任何某一个方法；
客户端调用服务器端方法需要协议（二人说好的接口）；
Context.bindService：//绑定成功后客户端会拿到该service的引用(接口)，
通过引用调用service中的方法；
即绑定成功服务器service会给客户端activity一个IBinder接口；
service会经历onCreate()、onBind()，onBind将返回给客户端一个IBind接口实例，
IBind允许客户端回调服务的方法，比如得到service运行的状态或者其他操作；
这个时候把调用者（context或Activity）会和service绑定在一起，
一旦context退出了，service就会调用onUnbind()->onDestroyed相应退出，
所谓绑定在一起就共存亡了；
1.onCreate：当有第一个客户端绑定service时会创建service，
先执行onCreate然后执行onBind
2.onBind：每当有客户端绑定service时(即context.bindService()时)都会执行onBind;
此方法要返回一个IBinder对象；
3.onUnbind():
4.onDestroy：打那个最后一个客户端解除与service的绑定时，执行onDestroy方法。
销毁/停止一个service的二种方式：
1>在activity中调用context.stopService(intent); 他杀
2>在service中调用stopSelf();或者 stopSelf(startId); 自杀
双击会起二个线程去下载，用stopSelf(startId);
自杀是在判断所有service都被销毁了才执行onDestory（）方法
service在绑定模式下的生命周期方法：
Activity能进行绑定得益于Service的接口，
为了支持Serivce的绑定，实现onBind方法；
Service和Activity的连接可以用ServiceConnection来实现，
你需要实现一个新的SerivceConnection，
重写onServiceConnected和onServiceDisconnected方法，
一旦连接建立，你就能得到Service实例的引用；
执行绑定调用bindService方法，传入一个选择了要绑定的Service的Intent(显示或隐式)
和一个实现了ServiceConnection的实例
相当于是activity与service之间建立了一个长连接（SerivceConnection），
在activity中可以借助此对象操作service中的方法；
activity作为客户端，service作为服务器端，建立一个通道，一一对应绑定起来；
activity可以调用service里面声明的任何某一个方法；
客户端调用服务器端方法需要协议（二人说好的接口）；
Context.bindService：//绑定成功后客户端会拿到该service的引用(接口)，
通过引用调用service中的方法；
即绑定成功服务器service会给客户端activity一个IBinder接口；
service会经历onCreate()、onBind()，onBind将返回给客户端一个IBind接口实例，
IBind允许客户端回调服务的方法，比如得到service运行的状态或者其他操作；
这个时候把调用者（context或Activity）会和service绑定在一起，
一旦context退出了，service就会调用onUnbind()->onDestroyed相应退出，
IBinder是一个接口类型：
//客户端会拿到该service的引用(即这个IBinder接口)，通过引用调用service中的方法；
客户端怎么知道服务器端定义了什么方法，
那么服务器端给了一个定义好的IBinder接口《service的引用》给客户端；
客户端调用接口的方法，服务器端用子类实现该接口的方法，通过多态实现对方法的实际调用；
达到c/s一个通信的效果；
远程方法调用，反射，动态代理
绑定就是二者之间建立一个连接，中间的接口（二人说好的协议，即方法名和参数列表）
客户端调用这个接口的方法，服务器实现这些方法，
通过多态达到客户端activity对服务器service方法的实际动态调用；
对service的使用更灵活，更方便，能使service做更多的事情；
销毁/停止一个service的二种方式：
1>在activity中调用context.stopService(intent); 他杀
2>在service中调用stopSelf();或者 stopSelf(startId); 自杀
双击会起二个线程去下载，用stopSelf(startId);
自杀是在判断所有service都被销毁了才执行onDestory（）方法
service在绑定模式下的生命周期方法：
Activity能进行绑定得益于Service的接口，
为了支持Serivce的绑定，实现onBind方法；
Service和Activity的连接可以用ServiceConnection来实现，
你需要实现一个新的SerivceConnection，
重写onServiceConnected和onServiceDisconnected方法，
一旦连接建立，你就能得到Service实例的引用；
执行绑定调用bindService方法，传入一个选择了要绑定的Service的Intent(显示或隐式)
和一个实现了ServiceConnection的实例
相当于是activity与service之间建立了一个长连接（SerivceConnection），
在activity中可以借助此对象操作service中的方法；
activity作为客户端，service作为服务器端，建立一个通道，一一对应绑定起来；
activity可以调用service里面声明的任何某一个方法；
客户端调用服务器端方法需要协议（二人说好的接口）；
Context.bindService：//绑定成功后客户端会拿到该service的引用(接口)，
通过引用调用service中的方法；
即绑定成功服务器service会给客户端activity一个IBinder接口；
service会经历onCreate()、onBind()，onBind将返回给客户端一个IBind接口实例，
IBind允许客户端回调服务的方法，比如得到service运行的状态或者其他操作；
这个时候把调用者（context或Activity）会和service绑定在一起，
一旦context退出了，service就会调用onUnbind()->onDestroyed相应退出，
service服务端：
public IBinder onBind(Intent intent) {
return new MyBinder();//为了支持Service的绑定，得实现该方法
}
//在MyBinder中定义供activity客户端调用的接口方法，并且返回MyBinder对象。
class MyBinder extends Binder{
//声明供客户端调用的接口方法
}
销毁/停止一个service的二种方式：
1>在activity中调用context.stopService(intent); 他杀
2>在service中调用stopSelf();或者 stopSelf(startId); 自杀
双击会起二个线程去下载，用stopSelf(startId);
自杀是在判断所有service都被销毁了才执行onDestory（）方法
service在绑定模式下的生命周期方法：
Activity能进行绑定得益于Service的接口，
为了支持Serivce的绑定，实现onBind方法；
Service和Activity的连接可以用ServiceConnection来实现，
你需要实现一个新的SerivceConnection，
重写onServiceConnected和onServiceDisconnected方法，
一旦连接建立，你就能得到Service实例的引用；
执行绑定调用bindService方法，传入一个选择了要绑定的Service的Intent(显示或隐式)
和一个实现了ServiceConnection的实例
相当于是activity与service之间建立了一个长连接（SerivceConnection），
在activity中可以借助此对象操作service中的方法；
activity作为客户端，service作为服务器端，建立一个通道，一一对应绑定起来；
activity可以调用service里面声明的任何某一个方法；
客户端调用服务器端方法需要协议（二人说好的接口）；
Context.bindService：//绑定成功后客户端会拿到该service的引用(接口)，
通过引用调用service中的方法；
即绑定成功服务器service会给客户端activity一个IBinder接口；
service会经历onCreate()、onBind()，onBind将返回给客户端一个IBind接口实例，
IBind允许客户端回调服务的方法，比如得到service运行的状态或者其他操作；
这个时候把调用者（context或Activity）会和service绑定在一起，
一旦context退出了，service就会调用onUnbind()->onDestroyed相应退出，
Activity客户端：
在对的时间绑定service：
Intent intent=new Intent(this, PlayMusicService.class);
MyConnection conn=new MyConnection();
this.bindService(intent, conn, BIND_AUTO_CREATE);
在MyConnection中，绑定成功时将会执行onServiceConnected方法，
并且返回service中onBind方法的返回值。我们可以直接使用该IBinder实例。
Activity{
IBinder binder;
onCreate(){
this.bindService(intent, conn, flags);
}
class MyConnection implements ServiceConnection{
onServiceConnected(IBinder binder){
强转binder得到Service实例的引用 保存到成员
}
}
}
在对的时间解除service的绑定：context.unBindService(conn);
------------------------------------------------
销毁/停止一个service的二种方式：
1>在activity中调用context.stopService(intent); 他杀
2>在service中调用stopSelf();或者 stopSelf(startId); 自杀
双击会起二个线程去下载，用stopSelf(startId);
自杀是在判断所有service都被销毁了才执行onDestory（）方法
service在绑定模式下的生命周期方法：
Activity能进行绑定得益于Service的接口，
为了支持Serivce的绑定，实现onBind方法；
Service和Activity的连接可以用ServiceConnection来实现，
你需要实现一个新的SerivceConnection，
重写onServiceConnected和onServiceDisconnected方法，
一旦连接建立，你就能得到Service实例的引用；
执行绑定调用bindService方法，传入一个选择了要绑定的Service的Intent(显示或隐式)
和一个实现了ServiceConnection的实例
相当于是activity与service之间建立了一个长连接（SerivceConnection），
在activity中可以借助此对象操作service中的方法；
activity作为客户端，service作为服务器端，建立一个通道，一一对应绑定起来；
activity可以调用service里面声明的任何某一个方法；
客户端调用服务器端方法需要协议（二人说好的接口）；
Context.bindService：//绑定成功后客户端会拿到该service的引用(接口)，
通过引用调用service中的方法；
即绑定成功服务器service会给客户端activity一个IBinder接口；
service会经历onCreate()、onBind()，onBind将返回给客户端一个IBind接口实例，
IBind允许客户端回调服务的方法，比如得到service运行的状态或者其他操作；
这个时候把调用者（context或Activity）会和service绑定在一起，
一旦context退出了，service就会调用onUnbind()->onDestroyed相应退出，
AIDL：CS架构 是一个文件
跨进程：ContentProvider（别人家程序的私有数据库）、
广播、Service(AIDL跨进程访问第三方Service)
Google提供的第三方Service
2006/2007年就被墙了，之前百度和Google（有违反国家法律的东西，很爷们的走了，当时技术研究不太多，对国内影响不大）都可以，百度比Google差多了；
现在人家的生态圈特别大 开源的很，大Google
CSDN还可以 中国程序员不太喜欢回答各种问题，不太愿意共享，比较封闭
谷歌（数据分析和搜索引擎，所有的数据都存在数据库里，大数据）
的语音服务now比苹果的语音强大太多了 之后语音是一个很大很广的大市场
是一种android接口定义语言，用于约束二个进程间的通信规则，供编译器生成代码，实现Android设备上的进程间通信；进程之间的通信信息首先会被转换成AIDL协议消息，然后发送给对方，对方收到AIDL协议信息后再转换成相对应的对象；
AIDL支持的类型包括Java基本类型和String、List、Map、CharSequence，
如果使用自定义类型，必须实现Parcelable接口；
基于Google服务的开发，国内都是分享到QQ、微信、朋友圈；为什么要访问别人的服务，比如coc部落冲突， 国外人android系统都绑定Google账号,
换个手机从google账号拿回来你已经获得的等级
类似第三方登陆 开心消消乐 拿自己账号登陆（要么用人公司的账号登陆，或者不想注册，直接用QQ、微博等直接登陆（账号都记得清楚），这就是第三方登陆）
用QQ 登陆后再返回自己的应用（前提是安装了QQ）
原生的Google的android系统： 手机都是自带的 刷了android的原生系统
GooglePlay Google+
国内APP下载平台太多，都有利益关系，所以得多渠道打包APK
国外人就只用GooglePlay一个而已 GoogleServiceFramework 服务框架 APP
我自己的APP（有那谷歌账号登陆的需求）可以实现数据的同步 这是一个生态圈
他们的应用程序之间是有关系的 独立不能运行的
谷歌的云服务 什么都可以无限量的放上去 只要登陆谷歌账号
人请求地址不会直接给你所以搞了一个GoogleServiceFramework服务框架 APP
里面没有Activity 全是Service 账号 支付 排名等各种服务 UserService
人把好多功能都封装了 在咱们程序中安装谷歌服务框架
让我们的Activity去绑定人家的Service，调其Service的方法
用隐式意图去访问人家service（用隐式意图注册）
serviceConnection有一些框架的回调方法
远程方法调用，反射。。。等
拿到IBinder对象就可以掉其方法 但是其子类实例你不知道（人家service定义的实现类）
协议 规范 接口他妈就是一个事 多个人协调工作 一个人干就不要什么接口 规范 协议
绑定、连接成功就可以拿到这个IBinder对象
跨进程内存就分开 通信是能通过网络通信（就是AIDL）
S端：写一个.aidl文件（定义一些接口方法，这就像是一个接口一样，
这不是一个类，类在进程间是不能传递的，）
C端：不知道拿到的这个IBinder对象里面都有什么对象 原来是强转（知道服务器具体是什么）但拿到这个.aidl文件（就知道你这个服务器的具体内容了），会生成一个java类，用这个类再去调其Service中的方法即可
中间机制很复杂：
进程间通讯的前提是双方都自愿，即安全的基础上实现
跨进程访问第三方service要用AIDL
为了完成别人能完成的一个需求（人家的类名什么的咱都不知道）
service的绑定机制就是一个客户端和服务端的网络通讯
销毁/停止一个service的二种方式：
1>在activity中调用context.stopService(intent); 他杀
2>在service中调用stopSelf();或者 stopSelf(startId); 自杀
双击会起二个线程去下载，用stopSelf(startId);
自杀是在判断所有service都被销毁了才执行onDestory（）方法
service在绑定模式下的生命周期方法：
Activity能进行绑定得益于Service的接口，
为了支持Serivce的绑定，实现onBind方法；
Service和Activity的连接可以用ServiceConnection来实现，
你需要实现一个新的SerivceConnection，
重写onServiceConnected和onServiceDisconnected方法，
一旦连接建立，你就能得到Service实例的引用；
执行绑定调用bindService方法，传入一个选择了要绑定的Service的Intent(显示或隐式)
和一个实现了ServiceConnection的实例
相当于是activity与service之间建立了一个长连接（SerivceConnection），
在activity中可以借助此对象操作service中的方法；
activity作为客户端，service作为服务器端，建立一个通道，一一对应绑定起来；
activity可以调用service里面声明的任何某一个方法；
客户端调用服务器端方法需要协议（二人说好的接口）；
Context.bindService：//绑定成功后客户端会拿到该service的引用(接口)，
通过引用调用service中的方法；
即绑定成功服务器service会给客户端activity一个IBinder接口；
service会经历onCreate()、onBind()，onBind将返回给客户端一个IBind接口实例，
IBind允许客户端回调服务的方法，比如得到service运行的状态或者其他操作；
这个时候把调用者（context或Activity）会和service绑定在一起，
一旦context退出了，service就会调用onUnbind()->onDestroyed相应退出，
是Android中跨应用程序进程通讯的一种机制（还有广播接收器机制）；
可以实现android中跨进程访问第三方服务业务。
建立在绑定服务（自己的activity和别人的service绑定在一起）的基础之上；
但是返回来的IBinder对象客户端拿不到，可以使用.AIDL接口文件实现,
服务端写的AIDL文件开放出来（将该.AIDL文件拷贝到客户端），格式、方法；
这样客户端对其解析后会生成一个接口，然后直接调用接口中的方法即可；
刚才是可以直接拿到myIBinder，是用户编程的一个接口；
开发了一些客户端app(不带界面的google服务框架)：
一推service中提供了登录、查询等各种google的服务；
如一些自己的应用都需要登录google账号访问google的一些服务
自己的应用中访问google服务框架 属于跨应用程序进程
android中可以使用绑定服务跨进程访问第三方服务业务
而服务器远在海边自己的activity app 别人的service app
形成了跨应用程序进程
销毁/停止一个service的二种方式：
1>在activity中调用context.stopService(intent); 他杀
2>在service中调用stopSelf();或者 stopSelf(startId); 自杀
双击会起二个线程去下载，用stopSelf(startId);
自杀是在判断所有service都被销毁了才执行onDestory（）方法
service在绑定模式下的生命周期方法：
Activity能进行绑定得益于Service的接口，
为了支持Serivce的绑定，实现onBind方法；
Service和Activity的连接可以用ServiceConnection来实现，
你需要实现一个新的SerivceConnection，
重写onServiceConnected和onServiceDisconnected方法，
一旦连接建立，你就能得到Service实例的引用；
执行绑定调用bindService方法，传入一个选择了要绑定的Service的Intent(显示或隐式)
和一个实现了ServiceConnection的实例
相当于是activity与service之间建立了一个长连接（SerivceConnection），
在activity中可以借助此对象操作service中的方法；
activity作为客户端，service作为服务器端，建立一个通道，一一对应绑定起来；
activity可以调用service里面声明的任何某一个方法；
客户端调用服务器端方法需要协议（二人说好的接口）；
Context.bindService：//绑定成功后客户端会拿到该service的引用(接口)，
通过引用调用service中的方法；
即绑定成功服务器service会给客户端activity一个IBinder接口；
service会经历onCreate()、onBind()，onBind将返回给客户端一个IBind接口实例，
IBind允许客户端回调服务的方法，比如得到service运行的状态或者其他操作；
这个时候把调用者（context或Activity）会和service绑定在一起，
一旦context退出了，service就会调用onUnbind()->onDestroyed相应退出，
服务端：将写好的只包含service的服务器端程序先安装到手机上
定义AIDL接口文件，该文件的语法与interface非常相似。
文件中定义供客户端调用的接口方法。
android将会在gen目录下自动生成相应接口。
在接口中含有静态内部抽象类Stub.
在onBind方法中，实现该接口中的Stub并且return。
public Ibinder onBind(Intent intent){
return new MyStub();
}
class MyStub extends Stub{
play(){ 实现抽象方法 }
next(){ 实现抽象方法 }
public void play() throws RemoteException {
Log.i("info", "play....");
}
}
拷贝服务端中用于定义接口的aidl文件到客户端应用程序.
要求包名也要一致，android将会在客户端代码中也会自动生成
相应的接口文件供客户端程序调用.
执行service绑定后，服务端将会返回Ibinder接口的实例，
我们使用Stub.asInterface(ibinder)方法获取该接口实例的引用，
直接调用接口的方法，动态执行服务端service的代码。
this.bindService(intent, conn, flags);
conn=new ServiceConnection(){
onServiceConnected(CompnentName,IBinder binder){
MyInterface m=Stub.asInterface(binder);
//接下来调用m的相应接口方法即可执行service中的相应方法.
}
}
销毁/停止一个service的二种方式：
1>在activity中调用context.stopService(intent); 他杀
2>在service中调用stopSelf();或者 stopSelf(startId); 自杀
双击会起二个线程去下载，用stopSelf(startId);
自杀是在判断所有service都被销毁了才执行onDestory（）方法
service在绑定模式下的生命周期方法：
Activity能进行绑定得益于Service的接口，
为了支持Serivce的绑定，实现onBind方法；
Service和Activity的连接可以用ServiceConnection来实现，
你需要实现一个新的SerivceConnection，
重写onServiceConnected和onServiceDisconnected方法，
一旦连接建立，你就能得到Service实例的引用；
执行绑定调用bindService方法，传入一个选择了要绑定的Service的Intent(显示或隐式)
和一个实现了ServiceConnection的实例
相当于是activity与service之间建立了一个长连接（SerivceConnection），
在activity中可以借助此对象操作service中的方法；
activity作为客户端，service作为服务器端，建立一个通道，一一对应绑定起来；
activity可以调用service里面声明的任何某一个方法；
客户端调用服务器端方法需要协议（二人说好的接口）；
Context.bindService：//绑定成功后客户端会拿到该service的引用(接口)，
通过引用调用service中的方法；
即绑定成功服务器service会给客户端activity一个IBinder接口；
service会经历onCreate()、onBind()，onBind将返回给客户端一个IBind接口实例，
IBind允许客户端回调服务的方法，比如得到service运行的状态或者其他操作；
这个时候把调用者（context或Activity）会和service绑定在一起，
一旦context退出了，service就会调用onUnbind()->onDestroyed相应退出，
IPC是内部进程通信的简称，是共享”命名管道”的资源。
Android中的IPC机制是为了让Activity和Service之间可以随时的进行交互，
故在Android中该机制只适用于Activity和Service之间的通信，
类似于远程方法调用，类似于C/S模式的访问。
通过定义AIDL接口文件来定义IPC接口。
Servier端实现IPC接口，Client端调用IPC接口本地代理。
销毁/停止一个service的二种方式：
1>在activity中调用context.stopService(intent); 他杀
2>在service中调用stopSelf();或者 stopSelf(startId); 自杀
双击会起二个线程去下载，用stopSelf(startId);
自杀是在判断所有service都被销毁了才执行onDestory（）方法
service在绑定模式下的生命周期方法：
Activity能进行绑定得益于Service的接口，
为了支持Serivce的绑定，实现onBind方法；
Service和Activity的连接可以用ServiceConnection来实现，
你需要实现一个新的SerivceConnection，
重写onServiceConnected和onServiceDisconnected方法，
一旦连接建立，你就能得到Service实例的引用；
执行绑定调用bindService方法，传入一个选择了要绑定的Service的Intent(显示或隐式)
和一个实现了ServiceConnection的实例
相当于是activity与service之间建立了一个长连接（SerivceConnection），
在activity中可以借助此对象操作service中的方法；
activity作为客户端，service作为服务器端，建立一个通道，一一对应绑定起来；
activity可以调用service里面声明的任何某一个方法；
客户端调用服务器端方法需要协议（二人说好的接口）；
Context.bindService：//绑定成功后客户端会拿到该service的引用(接口)，
通过引用调用service中的方法；
即绑定成功服务器service会给客户端activity一个IBinder接口；
service会经历onCreate()、onBind()，onBind将返回给客户端一个IBind接口实例，
IBind允许客户端回调服务的方法，比如得到service运行的状态或者其他操作；
这个时候把调用者（context或Activity）会和service绑定在一起，
一旦context退出了，service就会调用onUnbind()->onDestroyed相应退出，
AIDL是Android Interface Define Language（Android接口定义语言）；
当A进程要去调用B进程中的service时，并实现通信，我们通常都是通过AIDL来操作的；
A工程 C端：首先我们在net.blogjava.mobile.aidlservice包中创建一个RemoteService.aidl文件，
在里面我们自定义一个接口，含有方法get。
ADT插件会在gen目录下自动生成一个RemoteService.java文件，
该类中含有一个名为RemoteService.stub的内部类，该内部类中含有aidl文件接口的get方法。
说明一：aidl文件的位置不固定，可以任意；然后定义自己的MyService类，
在MyService类中自定义一个内部类去继承RemoteService.stub这个内部类，实现get方法。
在onBind方法中返回这个内部类的对象，系统会自动将这个对象封装成IBinder对象，传递给他的调用者。
其次需要在AndroidManifest.xml文件中配置MyService类，代码如下：
<!-- 注册服务 -->
<service android:name=".MyService">
<intent-filter>
<!-- 指定调用AIDL服务的ID -->
<action android:name="net.blogjava.mobile.aidlservice.RemoteService" />
</intent-filter>
</service>
为什么要指定调用AIDL服务的ID,就是要告诉外界MyService这个类能够被别的进程访问，
只要别的进程知道这个ID，正是有了这个ID,B工程才能找到A工程实现通信。
说明：AIDL并不需要权限
B工程 S端：首先我们要将A工程中生成的RemoteService.java文件拷贝到B工程中，
在bindService方法中绑定aidl服务；绑定AIDL服务就是将RemoteService的ID作为intent的action参数。
说明：如果我们单独将RemoteService.aidl文件放在一个包里，那个在我们将gen目录下的该包拷贝到B工程中。
如果我们将RemoteService.aidl文件和我们的其他类存放在一起，那么我们在B工程中就要建立相应的包，以保证RmoteService.java文件的报名正确，我们不能修改RemoteService.java文件;
bindService(new Intent("net.blogjava.mobile.aidlservice.RemoteService"),
serviceConnection, Context.BIND_AUTO_CREATE);
ServiceConnection的onServiceConnected(ComponentName name, IBinder service)方法中的service参数就是A工程中MyService类中继承了RemoteService.stub类的内部类的对象。
销毁/停止一个service的二种方式：
1>在activity中调用context.stopService(intent); 他杀
2>在service中调用stopSelf();或者 stopSelf(startId); 自杀
双击会起二个线程去下载，用stopSelf(startId);
自杀是在判断所有service都被销毁了才执行onDestory（）方法
service在绑定模式下的生命周期方法：
Activity能进行绑定得益于Service的接口，
为了支持Serivce的绑定，实现onBind方法；
Service和Activity的连接可以用ServiceConnection来实现，
你需要实现一个新的SerivceConnection，
重写onServiceConnected和onServiceDisconnected方法，
一旦连接建立，你就能得到Service实例的引用；
执行绑定调用bindService方法，传入一个选择了要绑定的Service的Intent(显示或隐式)
和一个实现了ServiceConnection的实例
相当于是activity与service之间建立了一个长连接（SerivceConnection），
在activity中可以借助此对象操作service中的方法；
activity作为客户端，service作为服务器端，建立一个通道，一一对应绑定起来；
activity可以调用service里面声明的任何某一个方法；
客户端调用服务器端方法需要协议（二人说好的接口）；
Context.bindService：//绑定成功后客户端会拿到该service的引用(接口)，
通过引用调用service中的方法；
即绑定成功服务器service会给客户端activity一个IBinder接口；
service会经历onCreate()、onBind()，onBind将返回给客户端一个IBind接口实例，
IBind允许客户端回调服务的方法，比如得到service运行的状态或者其他操作；
这个时候把调用者（context或Activity）会和service绑定在一起，
一旦context退出了，service就会调用onUnbind()->onDestroyed相应退出，
482
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
