鉴于Service的知识比较容易忘掉,所以今天就把Service的知识总结一下
服务: 长期后台运行的没有界面的组件。
android应用:什么地方需要用到服务?
天气预报:后台的连接服务器的逻辑,每隔一段时间 获取最新的天气信息
股票显示:后台的连接服务器的逻辑,每隔一段时间 获取最新的股票信息
mp3播放器: 后台长期的播放音乐。
当然在Activity中new Thread(){}.start(); 子线程没有界面,也是长期后台运行的。但是当Activity被销毁掉时,当内存不够的时候,系统就会认为这是一个空进程,然后会自动回收掉这个进程,导致这个后台运行的线程异常停止掉。
下面说一下android的进程管理的相关知识:
android系统进程管理是按照一定的规则的:
1.应用程序一旦被打开 通常情况下关闭(清空任务栈)后进程不会停止。方面下一次快速启动。
带来内存不足的问题。
2.Android系统有一套 内存清理机制。 按照优先级去回收系统的内存。
进程分为5个等级的优先级:(从高到低)
1.Foreground process 前台进程 用户正在玩的应用程序对应的进程
2.Visible process 可视进程 用户仍然可以看到这个进程的界面。
3.Service process服务进程 应用程序有一个服务组件在后台运行。
4.Background process 后台进程 应用程序没有服务在运行 并且最小化 (activity onstop)
5.Empty process 空进程 没有任何运行的activity, 任务栈空了(例如:当应用程序被按返回键退出时)
所以长期后台运行的组件, 不要在activity开启子线程。
应该是创建服务,在服务里面开启子线程。
服务的目的:
1.长期后台运行。
2.提高进程的优先级,系统不容易回收掉进程,即便回收了,内存充足的时候,把进程重新创建。
当然这里也要提及一下IntentService
IntentService会使用队列来管理请求Intent,每当客户端代码通过Intent请求启动IntentService时,IntentService会将该Intent加队列中,然后开启一条新的worker线程来处理该Intent。对于一步的startService()请求,IntentService会按次序依次处理队列中的Intent,该线程保证同一时刻只处理一个Intent。由于IntentService使用信的woeker线程处理Intent请求,因此IntentService不会阻塞主线程,所以IntentService自己就可以处理耗时任务。
所以可以启动IntentService多次,而每一个耗时操作会以工作队列的方式在IntentService的onHandleIntent回调方法中执行,并且,每次只会执行一个工作线程,执行完第一个再执行第二个,以此类推。而且,所有请求都在一个单线程中,不会阻塞应用程序的主线程(UI Thread),同一时间只处理一个请求。那么,用IntentService有什么好处呢?首先,我们省去了在Service中手动开线程的麻烦,第二,当操作完成时,我们不用手动停止Service。
IntentService的原理:
下面介绍一个Service的四种用法:
第一种:本地服务(普通的启动服务)
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);
}
第二种:本地服务(调用本地服务)
第一步:先定义一个service的接口类IMiddlePerson
/**
* 定义一个接口,这样不仅可以让内部类的信息不公开,而且还可以给外部调用这个方法
* 中间人的接口定义
*
*/
public interface IMiddlePerson {
/**
* 代办暂住证
* @param money
*/
public void callMethodInService(int money);
}
第二步:定义一个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{//继承Binder是因为 onBind()方法返回的是一个IBinder类型,
//而Binder是IBinder接口的实例
/**
* 代办暂住证
* @param money 给钱 50块钱以上才给办。
*/
public void callMethodInService(int money){
if(money>=50){
methodInService();
}else{
Toast.makeText(getApplicationContext(), "多准备点钱。", 0).show();
}
System.out.println("我是从接口实现的方法,特点是调用我这个方法不会暴露这个类的其他信息");
}
/**
* 陪领导打麻将
*/
public void playMajiang(){
System.out.println("陪领导打麻将。");
System.out.println("外部不能调用我这个方法,原因是因为我是私有类的成员" +
",所以想实现调用service的方法,就要通过实现接口的方式去实现,例如上面的sendmessage()");
}
}
}
第三步:调用
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) {
}
}
}
绑定本地服务调用方法的步骤:
1.在服务的内部创建一个内部类 提供一个方法,可以间接调用服务的方法
private class MiddlePerson extends Binder implements IMiddlePerson{}
2.实现服务的onbind方法,返回的就是中间人 MiddlePerson
3.在activity 绑定服务。bindService();
4.在服务成功绑定的时候 会执行一个方法 onServiceConnected 传递过来一个 IBinder对象
5.强制类型转化 调用接口里面的方法。
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
第三种:远程服务-----调用者和服务在不同的工程代码里面。
每一个应用程序都是运行在自己独立的进程里面的。
进程操作系统分配内存空间的一个单位。进程的数据都是独立的。独立的内存空间。
aidl:android interface definition language 安卓接口定义语言
aidl文件都是公有的,没有访问权限修饰符
IPC: inter process communication 进程间通讯
所以下面通过aidl进行进程间的通信
和上面一样,只不过要将之前的接口类改一下后缀名为.aidl,然后把所以public,private和protected删掉,因为aidl本来就是公有的,修改后如下
package com.itheima.remoteservice;
interface IMiddlePerson {
/**
* 调用服务里面的方法
*/
void callMethodInService();
}
然后在service中的调用就变成了下面这样
private void methodInService(){
System.out.println("我是远程服务的方法,我被调用了。。。。");
}
//1.创建一个中间人 远程服务继承的是ipc的一个实现类<pre name="code" class="html">
private class MiddlePerson extends IMiddlePerson.Stub{@Overridepublic void callMethodInService() {methodInService();}}
当然我们需要在AndroidManifest中进行配置
<service android:name="com.cenzr.remoteservice.RemoteService">
<intent-filter >
<action android:name="com.<span style="font-family: Arial, Helvetica, sans-serif;">cenzr</span>.remoteservice"/>
</intent-filter>
</service>
我们现在另外新建一个项目,然后把刚刚定义好的aidl连同包和aidl文件一起拷过来
接着我们就可以调用我们远程服务service中的方法了
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.cenzr.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();
}
}
绑定远程服务调用方法的步骤:
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) 调用接口里面的方法。
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------
第四种用法:混合使用
当你想service一直在后台运行又想调用里面的方法的时候就可以才去这样的方式
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.cenzr.alipay");
startService(intent);
// 保证服务长期后台运行。
}
public void start(View view){
Intent intent = new Intent();
intent.setAction("com.<span style="font-family: Arial, Helvetica, sans-serif;"><span style="font-size:10px;">cenzr</span></span>.alipay");
startService(intent);
}
public void stop(View view){
Intent intent = new Intent();
intent.setAction("com.cenzr.alipay");
stopService(intent);
}
public void bind(View view){
Intent intent = new Intent();
intent.setAction("com.cenzr.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.cenzr.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) {
}
}
}
//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
以下是各种方式的生命周期
一、采用start的方式开启服务
生命周期如下:
onStart()过时了
开启服务: onCreate()--> onStartCommand() ---> onDestory();
如果服务已经开启,不会重复的执行onCreate(), 而是会调用onStart()和 onStartCommand();
服务停止的时候 onDestory().
服务只会被停止一次
二、服务还有一种开启方式,绑定的方式开启服务。
onCreate() --->onBind();--->onunbind()-->onDestory();
绑定服务不会调用onstart或者onstartcommand方法;
混合调用的服务的生命周期:
服务长期后台运行,又想调用服务的方法:
1.start方式开启服务(保证服务长期后台运行)
2.bind方式绑定服务(保证调用服务的方法)
3.unbind解除绑定服务
4.stopService停止服务。