Android Service（一）--浅谈Service

一．Service简介

service可以说是一个在后台运行的Activity，它不是一个单独的进程，它只需要应用告诉它要在后台做什么就可以了，它要实现和用户的交互的话需要通过通知栏或则是发送广播，UI去接收显示。它的应用十分广泛，尤其是在框架层，应用更多的是对系统服务的调用。它用于处理一些不干扰用户使用的后台操作。如下载，网络获取。播放音乐，他可以通过INTENT来开启，同时也可以绑定到宿主对象（调用者例如ACTIVITY上）来使用。服务是一个应用程序组件代表应用程序执行一个长时间操作的行为，虽然不与用户交互或供应功能供其它应用程序使用。每个服务类必须有一个相应的包的AndroidManifest.xml中 <Service>声明。服务可以通过Context.startService()和Context.bindService()开始工作。它和其他的应用对象一样，在他的宿主进程的主线程中运行。

二．服务的类型

按使用范围分为本地服务个远程服务两种。

本地服务：用于应用程序内部，实现应用程序自己的一些耗时任务，比如查询升级信息，并不占用应用程序比如Activity所属线程，而是单开线程后台执行，这样用户体验比较好。

在Service可以调用Context.startService()启动，调用Context.stopService()结束。在内部可以调用Service.stopSelf() 或 Service.stopSelfResult()来自己停止。无论调用了多少次startService()，都只需调用一次stopService()来停止。

远程服务：用于android系统内部的应用程序之间，可被其他应用程序复用，比如天气预报服务，其他应用程序不需要再写这样的服务，调用已有的即可。可以定义接口并把接口暴露出来，以便其他应用进行操作。客户端建立到服务对象的连接，并通过那个连接来调用服务。调用Context.bindService()方法建立连接，并启动，以调用 Context.unbindService()关闭连接。多个客户端可以绑定至同一个服务。如果服务此时还没有加载，bindService()会先加载它。

按运行类别分为前台服务和后台服务两种。

前台服务：前台服务需要调用 startForeground （ android 2.0 及其以后版本 ）或 setForeground （android 2.0 以前的版本）使服务成为 前台服务。

使用前台服务可以避免服务在后台运行的时候被系统KILL。

后台服务：后台服务就是处于后台运行的。

三．Service生命周期

注意：本地服务中，onStart已经被onStartCommand方法取代，Service和Activity都是由Context类派生的，可以通过getApplicationContext()方法获取上下文对象，和Activity一样，它有着自己的生命周期，可是和Activity相比，它所执行的过程略有不同，如上图所示。

四．3种服务通信类型

3种服务通信类型，分别是通过startService()直接启动服务，通过bindService()的方式启动和使用AIDL方式的Service。

1. context.startService() 启动流程（后台处理工作），只能实现启动和停止服务

流程：UI ——>Service

操作：使用Intent进行数据传递，通过服务中的onStartCommand方法进行接受（和Activity间传递方式一样）

启动流程：

context.startService() -> onCreate() -> onStartCommand() -> Service running -> context.stopService() -> onDestroy() -> Service stop

所以调用startService的生命周期大致为：

onCreate（只在创建的时候调用一次直到被摧毁） --> onStartCommand (服务开启后，可多次调用) --> onDestroy

服务中的onStartCommand(Intent intent, int flags, int startId)方法会返回一个唯一的整数标识符来识别启动请求，启动请求可以是START_STICKY、START_STICKY_COMPATIBILITY、START_NOT_STICKY、START_REDELIVER_INTENT等，标志位可以是START_FLAG_REDELIVERY、START_FLAG_RETRY。

通过这种方式，服务并不会随着绑定组建的摧毁而摧毁，而是服务自我摧毁。（所以这种方式适用于文件下载，上传等请求自行运行的场景）。

从生命周期图中我们可以看出，onCreate方法只在创建时候被调用了一次，这说明：Service被启动时只调用一次onCreate()方法，如果服务已经被启动，在次启动的Service组件将直接调用onStartCommand()方法，通过这样的生命周期，可以根据自身需求将指定操作分配进onCreate()方法或onStartCommand()方法中。

使用方法：

（1）创建服务类

public class MyService extends Service {
	@Override
	public void onCreate() {
	}

	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		//接受传递过来的intent的数据等
		return START_STICKY;
	}

	@Override
	public void onDestroy() {

	}
}

（2）在AndroidManifest.xml文件中注册Service

<service android:name="服务类所在的包名.MyService" />

（3）启动服务

Intent intent = new Intent(getApplicationContext(), MyService.class);
startService(intent);

2. context.bindService()启动流程（在本地同一进程内与Activity交互），单向交互

流程：UI ——>Service

启动流程：

context.bindService() -> onCreate() -> onBind() -> Service running -> onUnbind() -> onDestroy() -> Service stop

bindService的生命周期简化为为： onCreate --> onBind --> onUnbind --> onDestory。

通过该方法，服务启动时会调用onCreate()来启动服务，可是它不会调用onStartCommand() 方法，并且只有在所有的服务都接触了后，服务才会自动停止运行。通过服务的onBind()方法，可以获的一个客户端与服务器进行通信的IBdiner接口。IBind允许客户端回调服务的方法，比如得到Service的实例、运行状态或其他操作。这个时候把调用者（Context，例如Activity）会和Service绑定在一起，Context退出了，Srevice就会调用onUnbind->onDestroy相应退出。

注：绑定服务的Android组建在摧毁前应解除绑定，否则会造成内存泄漏。

使用方法：

（1）创建服务类

private LocalService extends Service{
	@Override
	public void onCreate() {

	}
	/** 绑定的IBinder */
	private final IBinder mBinder = new LocalBinder();

	public class LocalBinder extends Binder {
		public LocalService getService() {
			return LocalService.this;
		}
	}

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

	@Override
	public boolean onUnbind(Intent intent) {
		// TODO Auto-generated method stub
		return super.onUnbind(intent);
	}
}

（2）在AndroidManifest.xml文件中注册Service

同startService的一样。

（3）绑定服务

绑定服务需要需要设置ServiceConnection和标志位，方法如下：

bindService(Intent service, ServiceConnection conn, int flags)

ServiceConnection可以监听服务的状态，在进行服务绑定的时，其标志位可以为以下几种（这里列出3种）：

1).Context.BIND_AUTO_CREATE

说明：表示收到绑定请求的时候，如果服务尚未创建，则即刻创建，在系统内存不足需要先摧毁优先级组件来释放内存，且只有驻留该服务的进程成为被摧毁对象时，服务才被摧毁

2).Context.BIND_DEBUG_UNBIND

说明：通常用于调试场景中判断绑定的服务是否正确，但容易引起内存泄漏，因此非调试目的的时候不建议使用

3).Context.BIND_NOT_FOREGROUND

说明：表示系统将阻止驻留该服务的进程具有前台优先级，仅在后台运行，该标志位位于Froyo中引入。

注意：绑定服务的以异步方式运行的。绑定服务必须在当前的上下文环境中运行，某些场景中，通过上下文进行添加绑定接触方法如下：

getApplicationContext().bindService(service, conn, flags)

Activity中代码如下：

/** 是否绑定 */
boolean mIsBound = false;

/** 绑定服务 */
public void doBindService() {
	bindService(new Intent(MainActivity.this, LocalService.class), mConnection,Context.BIND_AUTO_CREATE);
	mIsBound = true;
}

/** 解除绑定服务 */
public void doUnbindService() {
	if (mIsBound) {
		// Detach our existing connection.
		unbindService(mConnection);
		mIsBound = false;
	}
}

private ServiceConnection mConnection = new ServiceConnection() {

	@Override
	public void onServiceConnected(ComponentName name, IBinder service) {
		mBoundService = ((LocalService.LocalBinder) service).getService();
		Toast.makeText(MainActivity.this, "服务连接", Toast.LENGTH_SHORT)
				.show();
	}

	@Override
	public void onServiceDisconnected(ComponentName name) {
		mBoundService = null;
		Toast.makeText(MainActivity.this, "服务未连接", Toast.LENGTH_SHORT)
				.show();
	}
};

3. 使用AIDL方式的Service（进行跨进程通信），双向交互

流程：UI <——>Service

操作：注册绑定广播接受器，之后通过广播来进行2者间通信

启动流程：和bindService一样，实现上是在bindService 的基础上使用AIDL进行通信。

使用方法：

远程绑定调用service主要是用来不同进程的信息共享。就比如服务器和客户端，在服务器端设置好一个service提供方法或信息，然后客户端可以直接调用服务器端service提供方法或信息。这里有个前提是客户端必须有和服务器端一份一样的AIDL，然后服务器端在客户端使用的系统上有注册过（也就是安装运行过一次），之后客户端就可以远程绑定调用服务器端的service了。

具体的步骤如下：

1.首先，是服务器的

1）创建一个android应用工程 ,命名为AidlServer

2) 在主Aitivity所在的包里新建个AIDL文件，这是ADT会自动帮你在gen目录下生成一个和AIDL文件同名的JAVA文件（这里的AidlService.java是下一步骤生成的，这里可以先忽略）

3）如上图所示，创建一个用来使用service的类(AidlService.java）

具体每个文件的代码如下：

IAidlService.idal文件：

package com.example.aidlserver;
interface IAidlService {
    String getValue();
}

AidlService.java文件：

public class AidlService extends Service {

	private class MyBinder extends IAidlService.Stub {  

		@Override
		public String getValue() throws RemoteException {
			// TODO Auto-generated method stub
			return "test remote service";
		}
    }  

	@Override
	public void onCreate() {
		super.onCreate();
		Log.i("AidlService","onCreate");
	}	

	@Override
	public IBinder onBind(Intent intent) {
		// TODO Auto-generated method stub
		Log.i("AidlService","service on bind");
		return new MyBinder();
	}

	@Override
	public void onDestroy() {
		Log.i("AidlService","service on destroy");
		super.onDestroy();
	}

}

MainActivity.java文件：

public class MainActivity extends Activity {
	private TextView show;
	private IAidlService  iservice;

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

		show = (TextView)findViewById(R.id.show);
	}

	/*点击第二次的时候次可以改变TextView的值，因为第一次只是绑定，返回的对象是空。*/
	public void onGetAidlServerDataBtnClick(View v){
		Intent service = new Intent(IAidlService.class.getName());
        bindService(service, connection, BIND_AUTO_CREATE);
        if (iservice != null) {
            try {
                show.setText(iservice.getValue());
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
	}

	private ServiceConnection connection = new ServiceConnection() {  

        public void onServiceConnected(ComponentName name, IBinder service) {
            // TODO Auto-generated method stub
        	/*获取Service对象*/
        	iservice = (IAidlService) IAidlService.Stub.asInterface(service);
            Log.i("Client","Bind Success:" + service);
        }    

        public void onServiceDisconnected(ComponentName name) {
            // TODO Auto-generated method stub
        	iservice = null;
            Log.i("Client","onServiceDisconnected");
        }
    };  

}

AndroidManifest.xml

<service
            android:name=".AidlService"
            android:enabled="true"
            android:process=":remote">
            <intent-filter>
                <!-- AIDL完整路径名。必须指明，客户端能够通过AIDL类名查找到它的实现类 -->
                <action android:name="com.example.aidlserver.IAidlService"/>
                <category android:name="android.intent.category.DEFAULT"/>
            </intent-filter>
 </service>

这里，服务器端的工作做好了，接下来是客户端的工作。

2.接着，是客户端的：

1）首先，创建一个工程，命名为AidlClient

2）接着，把服务器端的一些文件拷贝过来（创建com.ds.server这个包，然后往里面复制进入如下图的服务器端的文件（IAidlService.java)

下面是个文件的内容

AidlClientActivity.java

public class MainActivity extends Activity {
	private TextView show;
	private IAidlService  iservice;

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

		show = (TextView)findViewById(R.id.show);
	}

	/*点击第二次的时候次可以改变TextView的值，因为第一次只是绑定，返回的对象是空。*/
	public void onGetAidlServerDataBtnClick(View v){
		Intent service = new Intent(IAidlService.class.getName());
        bindService(service, connection, BIND_AUTO_CREATE);
        if (iservice != null) {
            try {
                show.setText(iservice.getValue());
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
	}

	private ServiceConnection connection = new ServiceConnection() {  

        public void onServiceConnected(ComponentName name, IBinder service) {
            // TODO Auto-generated method stub
        	/*获取Service对象*/
        	iservice = (IAidlService) IAidlService.Stub.asInterface(service);
            Log.i("Client","Bind Success:" + service);
        }    

        public void onServiceDisconnected(ComponentName name) {
            // TODO Auto-generated method stub
        	iservice = null;
            Log.i("Client","onServiceDisconnected");
        }
    };
}

注意：使用广播进行双向交互的时候，在服务退出的时候记得unregisterReceiver(receiver);注销广播接收器。

五．停止服务

1. 启动服务停止有2种方法：

（1）stopSelf() 自我停止服务

（2）stopService(Intent name) 被动停止服务

2. 绑定服务的解除绑定方法如下

unbindService(ServiceConnection conn)

六．拓展

1. 如何检查Android后台服务线程（Service类）是否正在运行

Android系统自己提供了一个函数ActivityManager.getRunningServices，可以列出当前正在运行的后台服务线程。

代码如下：

private boolean isServiceRunning() {
    ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
    for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
        if ("com.example.MyService".equals(service.service.getClassName())) {
            return true;
        }
    }
    return false;
}

2. Service和Thread的区别

我们拿服务来进行一个后台长时间的动作，为了不阻塞线程，然而，Thread就可以达到这个效果，为什么我们不直接使用Thread去代替服务呢？

1). Thread：Thread 是程序执行的最小单元，它是分配CPU的基本单位。可以用 Thread 来执行一些异步的操作。

2). Service：Service 是android的一种机制，当它运行的时候如果是Local Service，那么对应的 Service 是运行在主进程的 main 线程上的。如：onCreate，onStart 这些函数在被系统调用的时候都是在主进程的 main 线程上运行的。如果是Remote Service，那么对应的 Service 则是运行在独立进程的 main 线程上。因此请不要把 Service 理解成线程。

既然这样，那么我们为什么要用 Service 呢？其实这跟 android 的系统机制有关，我们先拿 Thread 来说。Thread 的运行是独立于 Activity 的，也就是说当一个 Activity 被 finish 之后，如果你没有主动停止 Thread 或者 Thread 里的 run 方法没有执行完毕的话，Thread 也会一直执行。因此这里会出现一个问题：当 Activity 被 finish 之后，你不再持有该 Thread 的引用。另一方面，你没有办法在不同的 Activity 中对同一 Thread 进行控制。

举个例子：如果你的 Thread 需要不停地隔一段时间就要连接服务器做某种同步的话，该 Thread 需要在 Activity 没有start的时候也在运行。这个时候当你 start 一个 Activity 就没有办法在该 Activity 里面控制之前创建的 Thread。因此你便需要创建并启动一个 Service ，在 Service 里面创建、运行并控制该 Thread，这样便解决了该问题（因为任何 Activity 都可以控制同一 Service，而系统也只会创建一个对应 Service 的实例）。

因此你可以把 Service 想象成一种消息服务，而你可以在任何有 Context 的地方调用 Context.startService、Context.stopService、Context.bindService，Context.unbindService，来控制它，你也可以在 Service 里注册 BroadcastReceiver，在其他地方通过发送 broadcast 来控制它，当然这些都是 Thread 做不到的。

七．参考网址

1. http://blog.csdn.net/vipzjyno1/article/details/26004831  服务介绍

2. http://blog.csdn.net/kernel_jim_wu/article/details/8479070  aidl clent server

时间： 2024-08-20 21:46:54

Android Service（一）--浅谈Service的相关文章

安卓开发_浅谈Service

一.Service(服务) Service是Android程序中四大基础组件之一,它和Activity一样都是Context的子类,区别在于它没有UI界面,是在后台运行的组件. public abstract class Service extends ContextWrapper implements ComponentCallbacks java.lang.Object ? android.content.Context ? android.content.ContextWrapper ?

浅谈Service Manager成为Android进程间通信（IPC）机制Binder守护进程之路

文章转载至CSDN社区罗升阳的安卓之旅,原文地址:http://blog.csdn.net/luoshengyang/article/details/6621566 上一篇文章Android进程间通信(IPC)机制Binder简要介绍和学习计划简要介绍了Android系统进程间通信机制Binder的总体架构,它由Client.Server.Service Manager和驱动程序Binder四个组件构成.本文着重介绍组件Service Manager,它是整个Binder机制的守护进程,用来管理

浅谈Service层为何要有接口

被人随意问了一句,为何每个service层都要写一个接口呢,多麻烦~虽然想说点什么,但是又不知道从何说起,只好从新整理一下思绪. 情景1:在开源框架中有很多这种情况,就是某个功能支持用户自定义扩展.说白了,它提供了一个接口,我们只需要实现这个接口,把我们自己的实现逻辑补上,就可以让框架按照我们的逻辑来执行.问题来了,框架的作者并不知道我们的实现类是什么,如果不定义一个接口,那么要如何在框架中调用我们的实现类呢? 情景2:我和同事分别做项目的2个不同功能模块,但是同事的功能中却需要调用我这头实现的

浅谈Service

一.生命周期: startService()方式启动,Service是通过接受Intent并且会经历onCreate()和onStart().当用户在发出意图使之销毁时会经历onDestroy():( onCreate-->onStart-->onDestory ) bindService()方式启动,与Activity绑定的时候,会经历onCreate()和onBind(),而当Activity被销毁的时候,Service会先调用onUnbind()然后是onDestroy().( onCr

Windows Azure Cloud Service (37) 浅谈Cloud Service

<Windows Azure Platform 系列文章目录> 最近在和一些客户聊天,常常被遇到这样的问题: 1.问题一:我在创建一个新的Windows Azure Virtual Machine的虚拟机时候,会同时创建同样名称的Cloud Service(云服务). 我看微软的报价里说虚拟机会收费,云服务也会收费.这样的话,我使用虚拟机,是不是收取我虚拟机+云服务=2倍的费用? 2.问题二:我在使用VS2013,将asp.net的应用程序部署到微软的PaaS平台的时候,只会有Cloud Se

Java Service Wrapper 浅谈

在实际开发过程中很多模块需要独立运行,他们并不会以web形式发布,传统的做法是将其压缩为jar包独立运行,这种形式简单易行也比较利于维护,但是 一旦服务器重启或出现异常时,程序往往无法自行修复或重启.解决服务器重启的传统做法是编写一段shell脚本随服务器启动而运行.但现在我们有一种更加简洁实用的方法可以解决上述问题-- Java Service Wrapper (JSW). Java Service Wrapper 顾名思义就是将java程序包装成系统程序,这样可以随着系统的运行而运行.换句话

Android 开发笔记“浅谈DDMS视图”

DDMS 的全称是Dalvik Debug Monitor Service,即Dalvik调试监控服务,是一个可视化的调试监控工具.它主要是对系统运行后台日志的监控,还有系统线程,模拟器状态的监控.此外,它还可以模拟收发短信,拨打电话和发送GPS位置信息等. 在eclipse中启动DDMS 1.在eclipse界面的右上角,点击,出现下面的界面 2.选择other,这时界面如下图所示,双击DDMS就可以启动  DDMS各部分组成的功能简介 1.Devices    可以查看到所有与DDMS连 接

Android事件总线 浅谈 EventBus

EventBus官方文档是这么写的:EventBus is a publish/subscribe event bus optimized for Android. 也就是说EventBus是Android下高效的发布/订阅事件总线机制. EventBus可以代替传统的Intent,Handler,Broadcast或接口函数在Fragment,Activity,Service,线程之间传递数据,执行方法. 我们先来看看官方文档对EventBus的介绍: simplifies the commu

Android移动客户端性能测试浅谈——电量

本文由作者张迎贞授权网易云社区发布. APP性能测试除了需要监控PCU.内存占用.流量等,还需要获取APP的电量数据,测试在可接受范围内,避免APP出现过度消耗电量的现象.手机有很多硬件模块:CPU,蓝牙,GPS,显示屏,Wifi,射频(Cellular Radio)等,在手机使用过程中,这些硬件模块可能处于不同的状态,譬如WIFI打开或关闭,屏幕是亮还是暗,CPU运行或休眠. 硬件模块在不同的状态下的耗电量是不同的.Android在进行电量统计时,并不是采用直接记录电流消耗量的方式,而是跟踪硬