##01_start开启服务的生命周期(重点)

  • 服务的特点:
  • 生命周期的方法:
    onCreate: 初始化service的实例对象;
    onStartCommand:开启服务;
    onDestroy:销毁实例对象之前调用这个方法做扫尾工作;
    onResume、onPause、onStop、onRestart等生命周期的都没有,因为没有界面;

##02_bind方式开启服务的生命周期(重点)
使用的方法:

bindService:绑定服务、开启服务;
unbindService:解除绑定的服务、停止服务;

特点:

1、第一次绑定服务时,先创建一个服务对象oncreate,然后绑定服务onBind;
2、解除绑定的服务时,先解除绑定服务,然后销毁服务的实例对象;
3、服务只能被绑定一次,多次绑定不会执行任何操作;
4、服务只能解除一次,如果多次解除绑定程序会抛出异常;
5、当界面关闭时,服务就被解除绑定了;

推荐的混合开启服务的方式:

1、startService:使用这种方式开启服务,可以让服务长期运行在后台;
2、bindService:绑定服务,为了调用服务里面的业务逻辑方法;
3、unbindService:解除绑定,为了不再调用服务里面的业务逻辑方法;
4、stopService:停止服务,不再使用服务对象;

##03_为什么要引入bindservice的API
目的:为了让应用程序能够调用服务里面的业务逻辑方法;

##04_绑定服务调用服务方法的过程

步骤:
1、在服务的类里面写中间人的内部类,让它IBinder接口,目的是为onBind返回中间人这个类型:
2、在中间人内部写一个方法,在这个方法里面调用服务处的业务逻辑方法:
3、在activity中绑定服务成功时,得到中间人的对象;
4、在activity中调用中间人的方法,就相当于间接地调用服务的业务逻辑方法:

代码:

TestService.java:

package com.itheima.testservice;

import java.io.FileDescriptor;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.os.IInterface;
import android.os.Parcel;
import android.os.RemoteException;
import android.widget.Toast;

public class TestService extends Service {

/**
* 应用程序绑定服务对象时会调用这个方法
* 绑定服务
*/
@Override
public IBinder onBind(Intent intent) {
System.out.println("--------onBind-----------");
//绑定服务时返回中间人对象
return new MyBinder();
}

/**
*
* 解除绑定的服务时调用这个方法
*/
@Override
public boolean onUnbind(Intent intent) {
System.out.println("--------onUnbind-----------");
return super.onUnbind(intent);
}


@Override
public void onCreate() {
super.onCreate();

System.out.println("--------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() {
super.onDestroy();
System.out.println("--------onDestroy-----------");
}

/**
* 服务的业务逻辑方法
*/
public void methodInService() {
System.out.println("=======methodInService==================");
Toast.makeText(this, "tishi", 0).show();
}


/**
* 1、中间人
* @author Administrator
*
*/
public class MyBinder extends Binder{

//2、在中间人内部写一个方法,在这个方法里面调用服务处的业务逻辑方法:
public void callMethodInService(){
//调用服务的业务逻辑方法
methodInService();
}


}
}

MainActivity.java:

package com.itheima.testservice;

import com.itheima.testservice.TestService.MyBinder;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.view.View;

public class MainActivity extends Activity {

private Intent intent;
private MyConn conn;
private MyBinder myBinder;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}

public void start(View view) {

intent = new Intent(this, TestService.class);

startService(intent);
}

public void stop(View view) {

stopService(intent);
}

public void call(View view){

//4、在activity中调用中间人的方法,就相当于间接地调用服务的业务逻辑方法:
myBinder.callMethodInService();
}

public void bind(View view) {
//intent = new Intent(this, TestService.class);

conn = new MyConn();
//intent 开启service使用的intent
//MyConn 应用程序与服务之间建立的连接
//开启服务时如果服务对象不存在,就会自动创建一个服务对象
bindService(intent,conn, BIND_AUTO_CREATE);
}

public void unbind(View view) {
//解除绑定的服务
unbindService(conn);
}


private class MyConn implements ServiceConnection {



/**
* 绑定服务成功会调用这个方法 让应用程序与service之间建立一个连接,就是通讯的通道
*/
@Override
public void onServiceConnected(ComponentName name, IBinder service) {

myBinder = (MyBinder) service;
}

/**
* 服务的连接崩溃的时候调用这方方法
*/
@Override
public void onServiceDisconnected(ComponentName name) {
}

}

}

##05_绑定服务抽取接口(重点)

接口的作用:对外暴露功能,隐藏实现的细节;

步骤:
1、在工程里面添加一个接口,里面写一个方法,对外开放的方法:
2、让中间人实现这个接口,为了让中间人具有接口的角色(类型),中间人需要实现接口里面的方法;
3、在activity中绑定服务成功时得到接口类型的对象;
4、在activity中调用接口类型的中间人的方法;

代码:

IService.java:

package com.itheima.testservice.service;

public interface IService {
public void callMethodInService();
}

TestService.java:

package com.itheima.testservice;

import com.itheima.testservice.service.IService;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.view.View;
import android.widget.Toast;

public class TestService extends Service {

/**
* 应用程序绑定服务对象时会调用这个方法
* 绑定服务
*/
@Override
public IBinder onBind(Intent intent) {
System.out.println("--------onBind-----------");
//绑定服务时返回中间人对象
return new MyBinder();
}

/**
*
* 解除绑定的服务时调用这个方法
*/
@Override
public boolean onUnbind(Intent intent) {
System.out.println("--------onUnbind-----------");
return super.onUnbind(intent);
}


@Override
public void onCreate() {
super.onCreate();
System.out.println("--------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() {
super.onDestroy();
System.out.println("--------onDestroy-----------");
}

/**
* 服务的业务逻辑方法
*/
public void methodInService() {
System.out.println("=======methodInService==================");
Toast.makeText(this, "tishi", 0).show();
}

public void eat(){
System.out.println("=======eat==================");
}

public void nj(){
System.out.println("=======nj==================");
}

public void xsn(){
System.out.println("=======xsn==================");
}

/**
* 1、中间人
* @author Administrator
*
*/
private class MyBinder extends Binder implements IService{

// //2、在中间人内部写一个方法,在这个方法里面调用服务处的业务逻辑方法:
// public void callMethodInService(){
// //调用服务的业务逻辑方法
// methodInService();
// }

public void callEat(){
eat();
}

public void callXsn(){
xsn();
}

/**
* 2、实现接口中的方法,在这方法里面调用服务的业务逻辑方法
*/
@Override
public void callMethodInService() {
//调用服务的业务逻辑方法
methodInService();
}
}
}

MainActivity.java:

package com.itheima.testservice;

import com.itheima.testservice.service.IService;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.view.View;

public class MainActivity extends Activity {

private Intent intent;
private MyConn conn;
// private MyBinder myBinder;
private IService myBinder;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}

public void start(View view) {
intent = new Intent(this, TestService.class);
startService(intent);
}

public void stop(View view) {
stopService(intent);
}

public void call(View view) {
// 4、在activity中调用中间人的方法,就相当于间接地调用服务的业务逻辑方法:
myBinder.callMethodInService();
}

public void bind(View view) {
//intent = new Intent(this, TestService.class);
conn = new MyConn();
// intent 开启service使用的intent
// MyConn 应用程序与服务之间建立的连接
// 开启服务时如果服务对象不存在,就会自动创建一个服务对象
bindService(intent, conn, BIND_AUTO_CREATE);
}

public void unbind(View view) {
// 解除绑定的服务
unbindService(conn);
}

private class MyConn implements ServiceConnection {
/**
* 绑定服务成功会调用这个方法 让应用程序与service之间建立一个连接,就是通讯的通道
*/
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
// myBinder = (MyBinder) service;
//3、在activity中绑定服务成功时得到接口类型的对象;
myBinder = (IService) service;

/**
* 服务的连接崩溃的时候调用这方方法
*/
@Override
public void onServiceDisconnected(ComponentName name) {
}
}
}

##06_服务的应用场景

应用场景:天气预报、股票软件,检测网络状态提交数据;

##07_利用服务注册广播接收者

使用代码注册广播接收者的目的:有些操作比较频繁的广播事件,如果使用配置文件来注册,每次在接收广播事件的时候都需要读取配置,这样比较耗时并且占用的资源比较大。如果使用代码注册广播接收者会比较省时和节省资源。

模版代码:

//1、创建广播接收者的对象
ScreenBroadcastReceiver receiver = new ScreenBroadcastReceiver();
//2、创建IntentFilter
IntentFilter filter = new IntentFilter();
filter.addAction("android.intent.action.SCREEN_OFF");
filter.addAction("android.intent.action.SCREEN_ON");
//3、注册广播接收者
registerReceiver(receiver, filter);

##08_远程服务aidl的写法(重点)

远程服务:在同一个设备安装的另一个应用程序,在这应用程序中有一个服务在运行。
本地服务:服务的类是写在当前应用程序里面的。

在本地的应用程序中调用另一个工程里面的服务的方法。

aidl:Android Interface Definition Language 安卓的接口定义语言;
aidl格式的文件都是对外开放的共享文件,可以把它拷贝到其他工程里使用;

IPC:Inter Process communication进程间的通讯;

步骤:

1、在远程工程里面添加一个接口,里面写一个方法,对外开放的方法:
2、让中间人实现这个接口,为了让中间人具有接口的角色(类型),中间人需要实现接口里面的方法:
修改IService接口的扩展名为aidl,为了写一个对外开放的共享文件,让中间人继承Stub;
3、在本地应用程序的activity中绑定服务成功时得到接口类型的对象:
在本地工程中创建了一个与远程服务工程一样的包,把aidl文件拷贝到这个包里;
4、在本地应用程序activity中绑定服务成功时得到IService接口类型的中间人对象:

远程服务:

package com.itheima.remoteservice;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;

import com.itheima.remoteservice.IService.Stub;

public class TestService extends Service {

@Override
public IBinder onBind(Intent intent) {
return new MyBinder();
}


public void methodInService(){
System.out.println("----------methodInService----------");
}


private class MyBinder extends Stub{

/**
* 实现接口中的方法
*/
@Override
public void callMethodInService() {
//调用了服务的业务逻辑方法
methodInService();
}
}

}

本地应用程序代码:

package com.itheima.localapp;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.view.View;

import com.itheima.remoteservice.IService;
import com.itheima.remoteservice.IService.Stub;

public class MainActivity extends Activity {

private Intent intent;
private MyConn conn;

private IService myBinder;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}

public void start(View view) {

intent = new Intent();
intent.setAction("com.itheima.remoteservice.REMOTESERVICE");
startService(intent);
}

public void bind(View view) {

conn = new MyConn();
bindService(intent, conn, BIND_AUTO_CREATE);
}

public void unbind(View view) {

unbindService(conn);
}


public void stop(View view) {

stopService(intent);
}

public void call(View view){
try {
//调用接口的方法,间接地调用服务的业务逻辑方法
myBinder.callMethodInService();
} catch (RemoteException e) {
e.printStackTrace();
}
}

private class MyConn implements ServiceConnection{

@Override
public void onServiceConnected(ComponentName name, IBinder service) {
//得到IService接口类型的对象
myBinder = Stub.asInterface(service);
}

@Override
public void onServiceDisconnected(ComponentName name) {
// TODO Auto-generated method stub
}
}
}