绑定的方式调用服务的方法和采用接口方式抽取方法

Android服务机制详解

最新推荐文章于 2021-01-19 15:40:59 发布

原创最新推荐文章于 2021-01-19 15:40:59 发布 · 464 阅读

1 ·

CC 4.0 BY-SA版权

Android 专栏收录该内容

183 篇文章

订阅专栏

本文详细介绍了Android中的服务机制，包括两种启动方式：start方式和服务绑定方式，并对比了两者的生命周期和使用场景。start方式适用于后台任务，而绑定方式更适合组件间交互。

1.配置文件配置服务，复制包名+类名的快捷方式：拷贝全名称不是在类名中右键，而是展开类名下右键。

一、采用start的方式开启服务

生命周期如下：

onStart()过时了

开启服务： onCreate()-->onStartCommand() ---> onDestory();

如果服务已经开启，不会重复的执行onCreate()，而是会调用onStart()和 onStartCommand();

服务停止的时候 onDestory().

服务只会被停止一次

服务的生命周期 (start方式开启)：

1.MainActivity

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){
    
    }
}

MyService:

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();
	}

}

二、服务还有一种开启方式，绑定的方式开启服务

1.图片理解

2. 生命周期

onCreate()--->onBind();--->onunbind()-->onDestory();

绑定服务不会调用onstart或者onstartcommand方法；

3.绑定服务代码

MainActivity：

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) {
			
		}
    }
}

MyService：

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("陪领导打麻将。");
		}
	}
}

定义接口IMiddlePerson：

/**
 * 中间人的接口定义
 *
 */
public interface IMiddlePerson {
	/**
	 * 代办暂住证
	 * @param money
	 */
	public void callMethodInService(int money);
}

三、两种开启服务方法的区别

1. start方式开启服务。一旦服务开启跟调用者(开启者)就没有任何关系了。

开启者退出了，开启者挂了，服务还在后台长期的运行。

开启者没有办法去调用服务里面的方法。（美国的司法独立）

2. bind的方式开启服务，绑定服务，调用者挂了，服务也会跟着挂掉。不求同时生，但求同时死。开启者可以调用服务里面的方法。

---------------------------------------------------------------------------例子：手机卫士05，拦截信息--------------------------------------

public class CallSmsSafeService extends Service {
	public static final String TAG = "CallSmsSafeService";
	private InnerSmsReceiver receiver;
	private BlackNumberDao dao;
	private TelephonyManager tm;
	private MyListener listener;

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

	private class InnerSmsReceiver extends BroadcastReceiver{
		@Override
		public void onReceive(Context context, Intent intent) {
			Log.i(TAG,"内部广播接受者， 短信到来了");
			//检查发件人是否是黑名单号码，设置短信拦截全部拦截。
			Object[] objs = (Object[]) intent.getExtras().get("pdus");
			for(Object obj:objs){
				SmsMessage smsMessage = SmsMessage.createFromPdu((byte[]) obj);
				//得到短信发件人
				String sender = smsMessage.getOriginatingAddress();
				String result = dao.findMode(sender);
				if("2".equals(result)||"3".equals(result)){
					Log.i(TAG,"拦截短信");
					abortBroadcast();
				}
				//演示代码。
				String body = smsMessage.getMessageBody();
				if(body.contains("fapiao")){
					//你的头发票亮的很  语言分词技术。
					Log.i(TAG,"拦截发票短信");
					abortBroadcast();
				}
			}
		}
	}
	
	@Override
	public void onCreate() {
		dao = new BlackNumberDao(this);
		receiver = new InnerSmsReceiver();
		IntentFilter filter =  new IntentFilter("android.provider.Telephony.SMS_RECEIVED");
		filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
		registerReceiver(receiver,filter);
		super.onCreate();
	}
	
	@Override
	public void onDestroy() {
		unregisterReceiver(receiver);
		receiver = null;
		super.onDestroy();
	}

}