Android_Service_BindService_IntentService

最新推荐文章于 2021-09-01 22:49:44 发布

Letter_

最新推荐文章于 2021-09-01 22:49:44 发布

阅读量881

点赞数

分类专栏： Android

本文链接：https://blog.csdn.net/u013636377/article/details/38817773

版权

Android 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

实现一个Service

1.创建创建一个类继承android.app.Service类，实现抽象方法，重写onStart() and onDestory()

2.AndroidMainfest.xml 配置Service

.onStartCommand()返回一个 int flags

START_STICKY "粘性的"

如果service进程被kill,保留service为开始状态,不保留intent对象,

系统会尝试重新创建Service,并执行 onStartCommand(Intent intent, int flags, int startId);

如果此时没有任何启动命令被传递到service，那么参数intent为null

START_NOT_STICKY"非粘性的"

执行.onStartCommand() 方法后服务被异常kill掉，系统不会重启该service

START_REDELIVER_STICKY

重传Inten，执行.onStartCommand() ,服务被异常kill，系统会重启该service，并传入intent

IntentService

intentService 继承 service 并处理异步请求的一个·Class ，内部有一个工作线程来处理耗时操作，任务结束后intentService自动kill

也可以启动多次，每一个耗时操作都会以工作队列方式在Intent.onHandleIntent()方法中回调执行，执行第一个工作线程后-执行第二个...以此类推

BingService

1.实现ServiceConnection 抽象类
重写两个回调方法：
onServiceConnected();系统调用此方法发送由服务的onBind()方法返回IBinder对象

onServiceDisconnected();连接的服务丢失时,崩溃,被kill调用此方法，解除服务不会调用

Messenger

SerMainActivity.java

package com.example.serframe;

import com.example.serframe.SwitchBut.OnSwitchChangedListener;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.CompoundButton;
import android.widget.Switch;
import android.widget.Toast;
import android.widget.ToggleButton;

public class SerMainActivity extends Activity{
	private Button butStartSer,butStopSer,ButIntentSerStart,ButIntentSerStop,ButBindSerStart,ButOnBindSer,ButcallPeople;
	private SwitchBut switch1;
	private IPeople people;//要使用的业务对象接口
	
	//conn 服务连接对象 传递給BindService 绑定回调conn.onServiceConnected()方法
	ServiceConnection conn = new ServiceConnection(){

		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			//系统调用此方法发送由服务的onBind()方法返回IBinder对象
			System.out.println("--SerMainActivity.onServiceConnected()");
			people = IPeople.Stub.asInterface(service);
		}
		@Override
		public void onServiceDisconnected(ComponentName name) {
			//连接的服务丢失时,崩溃,被kill调用此方法，解除服务不会调用
				System.out.println("--SerMainActivity.onServiceDisconnected()");
		}
	};
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_ser_main);
		butStartSer = (Button) findViewById(R.id.butStartSer);
		butStopSer = (Button) findViewById(R.id.butStopSer);
		ButIntentSerStart = (Button) findViewById(R.id.ButIntentSerStart);
		ButIntentSerStop = (Button) findViewById(R.id.ButIntentSerStop);
		ButBindSerStart = (Button) findViewById(R.id.ButBindSerStart);
		ButOnBindSer = (Button) findViewById(R.id.ButOnBindSer);
		ButcallPeople = (Button) findViewById(R.id.ButcallPeople);
		
		butStartSer.setOnClickListener(new ButListener());
		butStopSer.setOnClickListener(new ButListener());
		ButIntentSerStart.setOnClickListener(new ButListener());
		ButIntentSerStop.setOnClickListener(new ButListener());
		ButBindSerStart.setOnClickListener(new ButListener());
		ButOnBindSer.setOnClickListener(new ButListener());
		ButcallPeople.setOnClickListener(new ButListener());
			
	}
	
	class ButListener implements OnClickListener{

		@Override
		public void onClick(View v) {
			//Service
			Intent intent = new Intent(getApplicationContext(),SerframeService.class);
			//IntentService
			Intent IntentSer = new Intent(getApplicationContext(),IntentSer.class);
			//BindService
			Intent service = new Intent(getApplicationContext(),BindSer.class);
			
			
			switch (v.getId()) {
			case R.id.butStartSer:
				//start service 通过 intent 启动
				startService(intent);
				break;
			case R.id.butStopSer:
				//stop service 
				stopService(intent);
				break;
			case R.id.ButIntentSerStart:
				//start IntentService 通过 intentSer 启动
				startService(IntentSer);
				break;
			case R.id.ButIntentSerStop:
				//stop IntentService 
				stopService(IntentSer);
				break;
			case R.id.ButBindSerStart:
				//参数(服务intent, 服务连接对象, 绑定的服务方式);绑定服务，没有service自动创建
				bindService(service, conn, Context.BIND_AUTO_CREATE);
				break;
			case R.id.ButOnBindSer:
				//解除绑定
				unbindService(conn);
				break;
			case R.id.ButcallPeople:
				//调用远程业务对象(或本地业务)
				try {
					people.setName("PP");
					people.setSex("男");
					people.setAge(20);
					
					String Peo = people.getPeople();
					Toast.makeText(getApplicationContext(), Peo, 1).show();
				} catch (RemoteException e) {
					e.printStackTrace();
				}
				break;
			default:
				break;
			}
		}
	}
}

AIDL_IPC说明文档.txt

IPC（inter process conmmunication）进程间通信
同一进程中 各个组件进行通信十分方便，普通函数调用即可，对于不同进程中的组件就用到IPC机制
Android IBinder/Binder Framework 实现了IPC通信(远程通信：进程间的通信)
IBinder/Binder 是远程对象基本接口，该接口描述一个远程对象进行通信的抽象协议

AIDL （Android interface definition language）
AIDL：提供本程序组件給其他程序组件访问的接口声明
1.创建（IPeople.aidl）  -保存-自动生成 /gen/Package Name/IPeople.java
2.创建一个业务类（PeopleImpl.java）继承 IPeople.Stub 内部类  实现其业务方法

支持数据类型： 
	基本数据类型，
	String，
	CharSequence：接口字符序列，
	List，
	Map，  
	自定义类型：自己定义一个类 实现自己的类型
	
	类的归属
	A.应用程序
	SerMainActivity.java 
	
	B.应用程序
	BindSer.java
	IPeople.aidl  生成-> /gen/Package Name/IPeople.java
	PeopleImpl.java 继承 IPeople.Stub 内部类 实现其业务方法

	B程序：创建业务对象 PeopleImpl 通过BindService方式  暴露給A应用程序

IPeople.aidl

1.保存生成-> /gen/Package Name/IPeople.java
2.创建一个业务类（PeopleImpl.java）继承 IPeople.Stub 内部类实现其业务方法

PeopleImpl.java

package com.example.serframe;

import android.os.RemoteException;

public class PeopleImpl extends IPeople.Stub{
	private String name;
	private String sex;
	private int age;
	

	@Override
	public void setName(String name) throws RemoteException {
		this.name = name; 
	}

	@Override
	public void setSex(String sex) throws RemoteException {
		this.sex = sex;
	}

	@Override
	public void setAge(int age) throws RemoteException {
		this.age = age;
	}

	@Override
	public String getPeople() throws RemoteException {
		
		return "name="+name+",sex="+sex+",age="+age;
	}

}

BindSer.java

* 1.实现ServiceConnection 抽象类
* 重写两个回调方法：
* onServiceConnected();系统调用此方法发送由服务的onBind()方法返回IBinder对象
* onServiceDisconnected();连接的服务丢失时,崩溃,被kill调用此方法，解除服务不会调用
*
* class:为啥可以返回 PeopleImpl类型它们是相互继承
* PeopleImpl extends IPeople.Stub extends android.os.Binder implements android.os.IBinder

package com.example.serframe;

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

public class BindSer extends Service {
	private PeopleImpl peopleImpl;

	@Override
	public void onCreate() {
		super.onCreate();
		System.out.println("-BindSer.onCreate()");
	}
	
	//返回绑定IBinder 对象
	@Override
	public IBinder onBind(Intent intent) {
		System.out.println("-BindSer.onBind(Intent intent)");
		peopleImpl = new PeopleImpl();
		return peopleImpl;
	}
	
	@Override
	public boolean onUnbind(Intent intent) {
		System.out.println("-BindSer.onUnbind(Intent intent)");
		return super.onUnbind(intent);
	}
}

IntentSer.java IntentService 方式启动服务

* IntentService 服务
* intentService 继承 service 并处理异步请求的一个·Class ，
* 該類型的Service 在單獨的線程中來執行任務，任務結束后會自動結束Service，當我們有一次性完成的任務時，使用IntentService
* 如：web下載，下载完成就自动结束service；

package com.example.serframe;

import android.app.IntentService;
import android.content.Intent;
import android.util.Log;

public class IntentSer extends IntentService {

	public IntentSer() {
		super("IntentSer:");
	}

	// 此方法会创建一个单独 work thread中执行，完成工作任务
	@Override
	protected void onHandleIntent(Intent arg0) {
		// TODO Auto-generated method stub
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + " : " + i);
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}

	// 销毁服务时调用
	@Override
	public void onDestroy() {
		// TODO Auto-generated method stub
		Log.i("IntentSer:", " onDestroy");
		super.onDestroy();
	}

}

SerframeService.java Start Service 启动服务方式

* Service 组件[生命周期]
* 1.定义一个服务类继承 service
* 2.Service 两种启动方式
* started Bind
* 默认：一个started的service 与启动他的组件在同一线程中，
* 我们用service完成一些耗时操作，会阻塞主线程
* 我们必须使用线程处理问题 new Thread()
* stop service 两种方法
* <1.在外部使用stopService();
* <2.在服务类内部使用stopSelf();

package com.example.serframe;

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

public class SerframeService extends Service {
	
	//bind 方式启动Service
	@Override
	public IBinder onBind(Intent arg0) {
		return null;
	}
	
	//创建服务时调用
	@Override
	public void onCreate() {
		Log.i("SerframeService:", " onCreate");
		super.onCreate();
	}
	
	//执行服务的操作
	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		Log.i("SerframeService:", " onStartCommand()");
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 10; i++) {
					System.out.println(Thread.currentThread().getName()+" : "+i);
					try {
						Thread.sleep(500);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				//执行完毕-调用-自动停止服务
				SerframeService.this.stopSelf();
			}
		}).start();
		
		
		return START_STICKY;
		//return super.onStartCommand(intent, flags, startId);
	}
	
	//销毁服务时调用
	@Override
	public void onDestroy() {
		Log.i("SerframeService:", " onDestroy");
		super.onDestroy();
	}

}

AndroidManifest.xml 主配置文件添加服务组件

<application> 
        <!-- 注册service服务 -->
        <service android:name=".SerframeService"/>	
         <!-- 注册IntentService服务 -->
        <service android:name=".IntentSer"/>	
         <!-- 注册BindService服务 -->
        <service android:name=".BindSer"/>	
    </application>

activity