Android组件Service学习
富貴必從勤苦得，男兒須讀五車書。唐.杜甫《柏學士茅屋》
作为程序员的我们，须知富贵是要通过勤苦努力才能得到的，要想在行业内有所建树，就必须刻苦学习和钻研。
今天我们来讲一下Android中Service的相关内容。
Service在Android中和Activity是属于同一级别上的组件，我们可以将他们认为是两个好哥们，Activity仪表不凡，迷倒万千少女，经常做一些公众人物角色，而Service一副彪悍的长相，但却身强力壮，常常在后台做一些搬运工的力气活，虽然有些累，但大家都不能失去他。
下面我们就围绕Service对其进行全面讲解：
1.Service生命周期
Service生命周期可以从两种启动Service的模式开始讲起，分别是context.startService()和context.bindService()。
(1).startService的启动模式下的生命周期：当我们首次使用startService启动一个服务时，系统会实例化一个Service实例，依次调用其onCreate和onStartCommand方法，然后进入运行状态，此后，如果再使用startService启动服务时，不再创建新的服务对象，系统会自动找到刚才创建的Service实例，调用其onStart方法；如果我们想要停掉一个服务，可使用stopService方法，此时onDestroy方法会被调用，需要注意的是，不管前面使用了多个次startService，只需一次stopService，即可停掉服务。
(2).bindService启动模式下的生命周期：在这种模式下，当调用者首次使用bindService绑定一个服务时，系统会实例化一个Service实例，并一次调用其onCreate方法和onBind方法，然后调用者就可以和服务进行交互了，此后，如果再次使用bindService绑定服务，系统不会创建新的Service实例，也不会再调用onBind方法；如果我们需要解除与这个服务的绑定，可使用unbindService方法，此时onUnbind方法和onDestroy方法会被调用。
两种模式有以下几点不同之处：startService模式下调用者与服务无必然联系，即使调用者结束了自己的生命周期，只要没有使用stopService方法停止这个服务，服务仍会运行；通常情况下，bindService模式下服务是与调用者生死与共的，在绑定结束之后，一旦调用者被销毁，服务也就立即终止，就像江湖上的一句话：不求同生，但愿同死。
值得一提的是，以前我们在使用startService启动服务时都是习惯重写onStart方法，在Android2.0时系统引进了onStartCommand方法取代onStart方法，为了兼容以前的程序，在onStartCommand方法中其实调用了onStart方法，不过我们最好是重写onStartCommand方法。
实现界面如下：
.aidl文件
界面如下：
在另外一个项目中调用如下：
实现的界面：
作为程序员的我们，须知富贵是要通过勤苦努力才能得到的，要想在行业内有所建树，就必须刻苦学习和钻研。
今天我们来讲一下Android中Service的相关内容。
Service在Android中和Activity是属于同一级别上的组件，我们可以将他们认为是两个好哥们，Activity仪表不凡，迷倒万千少女，经常做一些公众人物角色，而Service一副彪悍的长相，但却身强力壮，常常在后台做一些搬运工的力气活，虽然有些累，但大家都不能失去他。
下面我们就围绕Service对其进行全面讲解：
1.Service生命周期
Service生命周期可以从两种启动Service的模式开始讲起，分别是context.startService()和context.bindService()。
(1).startService的启动模式下的生命周期：当我们首次使用startService启动一个服务时，系统会实例化一个Service实例，依次调用其onCreate和onStartCommand方法，然后进入运行状态，此后，如果再使用startService启动服务时，不再创建新的服务对象，系统会自动找到刚才创建的Service实例，调用其onStart方法；如果我们想要停掉一个服务，可使用stopService方法，此时onDestroy方法会被调用，需要注意的是，不管前面使用了多个次startService，只需一次stopService，即可停掉服务。
(2).bindService启动模式下的生命周期：在这种模式下，当调用者首次使用bindService绑定一个服务时，系统会实例化一个Service实例，并一次调用其onCreate方法和onBind方法，然后调用者就可以和服务进行交互了，此后，如果再次使用bindService绑定服务，系统不会创建新的Service实例，也不会再调用onBind方法；如果我们需要解除与这个服务的绑定，可使用unbindService方法，此时onUnbind方法和onDestroy方法会被调用。
两种模式有以下几点不同之处：startService模式下调用者与服务无必然联系，即使调用者结束了自己的生命周期，只要没有使用stopService方法停止这个服务，服务仍会运行；通常情况下，bindService模式下服务是与调用者生死与共的，在绑定结束之后，一旦调用者被销毁，服务也就立即终止，就像江湖上的一句话：不求同生，但愿同死。
值得一提的是，以前我们在使用startService启动服务时都是习惯重写onStart方法，在Android2.0时系统引进了onStartCommand方法取代onStart方法，为了兼容以前的程序，在onStartCommand方法中其实调用了onStart方法，不过我们最好是重写onStartCommand方法。
以上两种模式的流程如下图所示：
下面结合列子看看第一种生命周期：Unbounded
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
public void start(View view){
Intent intent = new Intent(this,MyService.class);
//通知框架开启服务。
startService(intent);
}
public void stop(View view){
Intent intent = new Intent(this,MyService.class);
stopService(intent);
}
@Override
protected void onDestroy() {
System.out.println("啊啊啊，我是activity，我挂了");
super.onDestroy();
}
//调用服务里面的方法。不可以自己new服务，调用的服务的方法，必须通过框架得到服务的引用。
public void call(View view){
}
}Service如下:
public class MyService extends Service {
@Override
public IBinder onBind(Intent arg0) {
return null;
}
@Override
public void onCreate() {
System.out.println("oncreate");
super.onCreate();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
System.out.println("onstartcommand");
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onDestroy() {
System.out.println("ondestory");
super.onDestroy();
}
/**
* 这是服务里面的一个方法
*/
public void methodInService(){
Toast.makeText(this, "哈哈，我是服务里面的方法", 0).show();
}
}
实现界面如下：
当我们单击开启服务时候：
不管单击多少次，服务只执行onCreate（）方法一次，然后onstartcommand()可以执行多次：
单击：停止服务时
调用ondestory（）一次。
这种方式启用服务时，生命周期如下：
开启服务： onCreate()--> onStartCommand() ---> onDestory();
如果服务已经开启，不会重复的执行onCreate()， 而是会调用onStart()和 onStartCommand();
服务停止的时候 onDestory().
服务只会被停止一次
单击调用服务里面的方法按钮，无响应。这种情况下是无法执行服务里面的方法的。
Bind方式开启服务：
看看原理图
实例代码如下：
public class MainActivity extends Activity {
private MyConn conn ;
private IMiddlePerson mp;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
//绑定服务
public void bind(View view){
//3.activity采用绑定的方式去开启服务。
Intent intent = new Intent(this,MyService.class);
conn = new MyConn();
bindService(intent, conn, BIND_AUTO_CREATE);
}
//解除绑定服务
public void unbind(View view){
unbindService(conn);
}
@Override
protected void onDestroy() {
System.out.println("啊啊啊，我是activity，我挂了");
super.onDestroy();
}
//调用服务里面的方法。
public void call(View view){
//5.通过中间人调用服务里面的方法。
mp.callMethodInService(55);
}
private class MyConn implements ServiceConnection{
//4. 当服务被连接的时候调用 服务别成功 绑定的时候调用
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
System.out.println("在activity里面成功得到了中间人");
mp = (IMiddlePerson) service;
}
//当服务失去连接的时候调用（一般进程挂了，服务被异常杀死）
@Override
public void onServiceDisconnected(ComponentName name) {
}
}
}
Service:
public class MyService extends Service {
//2.实现服务成功绑定的代码 ，返回一个中间人。
@Override
public IBinder onBind(Intent arg0) {
System.out.println("服务被成功绑定了。。。。");
return new MiddlePerson();
}
@Override
public boolean onUnbind(Intent intent) {
System.out.println("onunbind");
return super.onUnbind(intent);
}
@Override
public void onCreate() {
System.out.println("oncreate");
super.onCreate();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
System.out.println("onstartcommand");
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onDestroy() {
System.out.println("ondestory");
super.onDestroy();
}
/**
* 这是服务里面的一个方法
*/
public void methodInService(){
Toast.makeText(this, "哈哈，服务给你办好了暂住证。", 0).show();
}
//1.第一步服务要暴露方法 必须要有一个中间人
private class MiddlePerson extends Binder implements IMiddlePerson{
/**
* 代办暂住证
* @param money 给钱 50块钱以上才给办。
*/
public void callMethodInService(int money){
if(money>=50){
methodInService();
}else{
Toast.makeText(getApplicationContext(), "多准备点钱。", 0).show();
}
}
/**
* 陪领导打麻将
*/
public void playMajiang(){
System.out.println("陪领导打麻将。");
}
}
}
为了实现服务里面方法的安全性，写了一个中间人的接口，这样，只有接口中含有的方法，服务才会暴露在外面。
/**
* 中间人的接口定义
*
*/
public interface IMiddlePerson {
/**
* 代办暂住证
* @param money
*/
public void callMethodInService(int money);
}
运行的界面如下：
单击并多次单击绑定服务的时候：
此时调用的方法是：onCreate（）---》onBind（）--》onServiceConnected（）【服务连接成功时调用的方法】。
单击调用服务里面的方法的时候，成功调用：
说明bind方式启用服务的时候，是可以实现调用服务里面的方法的。
调用了onbound方法
所以生命周期为：
onCreate() --->onBind();--->onunbind()-->onDestory();【但是我实验的时候，并没有看到onDesory方法执行】
绑定服务不会调用onstart或者onstartcommand方法；
这种绑定服务的方法需要注意步骤：5点【上面已注释1.2.3.4.5.非常重要]
两种服务的比较：
三、两种开启服务方法的区别。
start方式开启服务。 一旦服务开启跟调用者(开启者)就没有任何关系了。
开启者退出了，开启者挂了，服务还在后台长期的运行。
开启者没有办法去调用服务里面的方法。（美国的司法独立）
bind的方式开启服务，绑定服务，调用者挂了，服务也会跟着挂掉。不求同时生，但求同时死。
开启者可以调用服务里面的方法。
下面看看远程服务，在一个程序中，通过aidl规范，实现进程间的通信，打开服务。
先看看两个工程【对应两个进程】的包结构
这里可以搜搜AIDL相关的知识，Android中进程间的通信.
服务端代码
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
}
public class RemoteService extends Service {
@Override
public void onCreate() {
System.out.println("远程服务被创建了。。。");
super.onCreate();
}
@Override
public void onDestroy() {
System.out.println("远程服务被销毁了。");
super.onDestroy();
}
@Override
public IBinder onBind(Intent intent) {
return new MiddlePerson();
}
private void methodInService(){
System.out.println("我是远程服务的方法，我被调用了。。。。");
}
//1.创建一个中间人 远程服务继承的是ipc的一个实现类
private class MiddlePerson extends IMiddlePerson.Stub{
@Override
public void callMethodInService() {
methodInService();
}
}
}
.aidl文件
interface IMiddlePerson {
/**
* 调用服务里面的方法
*/
void callMethodInService();
}
在看看绑定服务端的代码.
public class MainActivity extends Activity {
private MyConn conn;
private IMiddlePerson iMp;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
/**
* 绑定远程服务
* @param view
*/
public void bind(View view){
Intent intent = new Intent();
intent.setAction("com.itheima.remoteservice");
conn = new MyConn();
bindService(intent, conn, BIND_AUTO_CREATE);
}
private class MyConn implements ServiceConnection{
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
iMp = IMiddlePerson.Stub.asInterface(service);
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
}
public void call(View view){
try {
iMp.callMethodInService();
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
protected void onDestroy() {
unbindService(conn);
super.onDestroy();
}
}
.aidl文件
interface IMiddlePerson {
/**
* 调用服务里面的方法
*/
void callMethodInService();
}
界面如下：
单击后，后台输出如下：
所以实现了远程调用的逻辑业务功能。
可以发现远程调用和bind调用是一样的，只能是bind调用来实现，但是必须通过进程来实现。
对上面的本地服务和远程服务bind绑定做一个小结：
远程服务：调用者和服务在不同的工程代码里面。
本地服务：调用者和服务在同一个工程代码里面。
每一个应用程序都是运行在自己独立的进程里面的。
进程操作系统分配内存空间的一个单位。进程的数据都是独立的。独立的内存空间。
aidl：android interface definition language 安卓接口定义语言
aidl文件都是公有的，没有访问权限修饰符
IPC： inter process communication 进程间通讯
绑定本地服务调用方法的步骤：
1.在服务的内部创建一个内部类 提供一个方法，可以间接调用服务的方法
private class MiddlePerson extends Binder implements IMiddlePerson{}
2.实现服务的onbind方法，返回的就是中间人 MiddlePerson
3.在activity 绑定服务。bindService();
4.在服务成功绑定的时候 会执行一个方法 onServiceConnected 传递过来一个 IBinder对象
5.强制类型转化 调用接口里面的方法。
绑定远程服务调用方法的步骤：
1.在服务的内部创建一个内部类 提供一个方法，可以间接调用服务的方法
2.把暴露的接口文件的扩展名改为aidl文件 去掉访问修饰符 public
private class MiddlePerson extends IMiddlePerson.Stub{} IPC的子类
3.实现服务的onbind方法，返回的就是中间人 IMiddlePerson
4.在activity 绑定服务。bindService();
5.在服务成功绑定的时候 会执行一个方法 onServiceConnected 传递过来一个 IBinder对象
6.IMiddlePerson.Stub.asInterface(binder) 调用接口里面的方法。
下面通过一个调用远程服务运用混合模式开启服务案例
需求：支付宝对外提供服务，实现支付等功能。服务必须不能停止，要在后台长期运行。【所以必须柔和两种服务绑定的方式】
两个工程的包结构：
对于支付宝里面提供的服务：
public class SafePayService extends Service {
@Override
public IBinder onBind(Intent intent) {
System.out.println("服务被绑定 onbind");
return new MyBinder();
}
/**
* 安全支付的方法
*/
private boolean pay(long time,String pwd,double money){
if("123".equals(pwd)){
return true;
}else{
return false;
}
}
private class MyBinder extends ISafePay.Stub{
/**
* 调用安全支付的逻辑
*/
@Override
public boolean callPay(long time, String pwd, double money)
throws RemoteException {
return pay(time, pwd, money);
}
}
@Override
public void onCreate() {
System.out.println("oncreate支付宝服务被创建，一直在后台运行，检查手机的安全状态");
super.onCreate();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
System.out.println("服务onstart");
return super.onStartCommand(intent, flags, startId);
}
@Override
public boolean onUnbind(Intent intent) {
System.out.println("onunbind");
return super.onUnbind(intent);
}
@Override
public void onDestroy() {
System.out.println("ondestory支付宝服务被销毁");
super.onDestroy();
}
}
.aidl的接口：
interface ISafePay{
boolean callPay(long time,String pwd,double money);
}
在另外一个项目中调用如下：
public class MainActivity extends Activity {
private ISafePay iSafePay;
private MyConn conn;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// Intent intent = new Intent();
// intent.setAction("com.itheima.alipay");
// startService(intent);
//保证服务长期后台运行。
}
public void start(View view){
Intent intent = new Intent();
intent.setAction("com.itheima.alipay");
startService(intent);
}
public void stop(View view){
Intent intent = new Intent();
intent.setAction("com.itheima.alipay");
stopService(intent);
}
public void bind(View view){
Intent intent = new Intent();
intent.setAction("com.itheima.alipay");
conn = new MyConn();
bindService(intent, conn, BIND_AUTO_CREATE);//异步的操作
}
public void unbind(View view){
unbindService(conn);
}
public void click(View view){
Intent intent = new Intent();
intent.setAction("com.itheima.alipay");
conn = new MyConn();
bindService(intent, conn, BIND_AUTO_CREATE);//异步的操作
//绑定服务调用服务的方法。
}
private class MyConn implements ServiceConnection{
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
iSafePay = ISafePay.Stub.asInterface(service);
try {
boolean result = iSafePay.callPay(System.currentTimeMillis(), "123", 3.52f);
if(result){
Toast.makeText(getApplicationContext(), "支付成功，获取大炮弹", 0).show();
}else{
Toast.makeText(getApplicationContext(), "支付失败，请重试", 0).show();
}
// unbindService(conn);
// conn = null;
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
}
}
实现的界面：
必须按顺序依次：
混合调用的服务的生命周期：
服务长期后台运行，又想调用服务的方法：
1.start方式开启服务（保证服务长期后台运行）
2.bind方式绑定服务（保证调用服务的方法）
3.unbind解除绑定服务
4.stopService停止服务。