Android中Service的意义及用法

最新推荐文章于 2024-09-11 06:26:28 发布
最新推荐文章于 2024-09-11 06:26:28 发布
阅读量3k 收藏 3
点赞数
分类专栏： Android 文章标签： Service AsyncTask IntentService
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/talk2soul/article/details/45008089
版权

1、下面介绍Service和AsyncTask的用法和比较。

Service没有界面，用于执行一个需要在后台长期运行的任务。AsyncTask用于执行短时间的异步任务，并跟UI线程交互，用于替代Thread和Handler。

1) MainActivity.java

public class MainActivity extends Activity {
	private static final String TAG = MainActivity.class.getSimpleName();
	/**便于多次、多地调用，生命周期伴随Activity*/
	Intent intent;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		Log.i(TAG, "onCreate");
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
//		mAsyncTask.execute("http://www.qinuli.com:83/picture/thumb.jpg", "http://www.qinuli.com:83/picture/hand_in_hand.jpg");
		intent = new Intent(this, MyService.class);
	}
	protected void onDestroy() {
		Log.d(TAG, "onDestroy");
		super.onDestroy();
	};
	/**
	 * 定义一个AsyncTask的子类；实例化并在UI线程调用其execute方法
	 * <li>3个参数：Params、Progress、Result
	 * <li>4 steps：onPreExecute->doInBackground->onProgressUpdate->onPostExecute
	 * <li>功能：用于后台执行前台显示的任务
	 * <li>意义：代替或封装Thread和Handler，方便后台线程和UI线程交互
	 */
	AsyncTask<String, Integer, CharSequence> mAsyncTask = new AsyncTask<String, Integer, CharSequence>() {
		@Override
		protected void onPreExecute() {
			Log.d(TAG, "onPreExecute");
		};
		@Override
		protected CharSequence doInBackground(String... params) {
			//perform a computation on a background thread
			for(int i=0;i<params.length;i++){
				publishProgress(Integer.valueOf(i));
			}
			return "加油！";
		}
		@Override
		protected void onProgressUpdate(Integer... values) {
			Log.d(TAG, "onProgressUpdate-"+values[0]);
		};
		@Override
		protected void onPostExecute(CharSequence result) {
			Log.d(TAG, "onPostExecute-"+result);
		};
	};
	private ServiceConnection mServiceConnection = new ServiceConnection() {
		@Override
		public void onServiceDisconnected(ComponentName name) {
			Log.d(TAG, "onServiceDisconnected-"+name.getClassName());
		}
		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			//由bindService触发，在onBind之后
			MyService myService = ((MyBinder)service).getService();
			Log.d(TAG, "onServiceConnected-"+name.getClassName()+"-"+myService.name);
		}
	};
	public void onClick(View v){
		switch (v.getId()) {
		case R.id.btn_startService:
			//调用Service的空参构造
			startService(intent);
			break;
		case R.id.btn_stopService:
			stopService(intent);
			break;
		case R.id.btn_bindService:
			bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
			break;
		case R.id.btn_unbindService:
			unbindService(mServiceConnection);
		}
	}
}
2) activity_main.xml 
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    xmlns:android="http://schemas.android.com/apk/res/android">
    <Button 
        android:id="@+id/btn_startService"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="onClick"
        android:text="startService"/>
    <Button 
        android:id="@+id/btn_stopService"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="onClick"
        android:text="stopService"/>
    <Button 
        android:id="@+id/btn_bindService"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="onClick"
        android:text="bindService"/>
    <Button 
        android:id="@+id/btn_unbindService"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="onClick"
        android:text="unbindService"/>
</LinearLayout>
3) MyService.java，讲解startService和bindService的原理 
/**
 * <li>Service的意义:perform a longer running operation
 * <li>Service和AsyncTask的区别:Service运行在主线程，不会结束
 */
public class MyService extends Service {
	private static final String TAG = MyService.class.getSimpleName();
	private MyBinder myBinder = new MyBinder();
	public String name = "ShiXin";
	
	public MyService(){
		super();
		Log.d(TAG, "MyService");
	}
	
	/**继承Binder类，Binder类实现IBinder接口。实例化该类供onBind使用*/
	public class MyBinder extends Binder{
		/**返回Service的实例，进而调用其方法和属性，实现一些数据通信和功能操作*/
		public MyService getService(){
			return MyService.this;
		}
	}
	
	@Override
	public IBinder onBind(Intent intent) {
		Log.d(TAG, "onBind");
		//由bindService触发
		return myBinder;
	}

	@Override
	public boolean onUnbind(Intent intent) {
		Log.d(TAG, "onUnbind");
		return super.onUnbind(intent);
	}
	
	@Override
	public void onCreate() {
		Log.d(TAG, "onCreate");
		//重新实例化新的Service
		super.onCreate();
	}
	
	public void onDestroy() {
		Log.d(TAG, "onDestroy");
		super.onDestroy();
	};
	
	@Override
	public void onStart(Intent intent, int startId) {
		//deprecated 被onStartCommand代替
		super.onStart(intent, startId);
	}
	
	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		//每次startService都会触发，bindService不会触发
		//startId:unique integer token,标记每次startService，Service创建后从1开始计数
		//START_STICKY_COMPATIBILITY 0;Service.START_STICKY 1
		stopSelfResult(3);//onStartCommand执行3次
		int state = super.onStartCommand(intent, flags, startId);
		Log.d(TAG, "onStartCommand-"+intent.getComponent().getClassName()+"-"+flags+"-"+startId+"-"+state);
		return state;//1
	}
}
4) MyIntentService.java，IntentService用于在后台线程执行异步任务，执行完Service自动destroy 
/**
 * handle asynchronous requests
 */
public class MyIntentService extends IntentService {

	private static final String TAG = MyIntentService.class.getSimpleName();
	
	public MyIntentService() {
		//name worker thread
		super("worker thread");
	}
	@Override
	protected void onHandleIntent(Intent intent) {
		//代替onStartCommand；执行完调用stopSelf()
		Log.d(TAG, Thread.currentThread().getName()+"-onHandleIntent");
	}
	@Override
	public void onCreate() {
		Log.d(TAG, "onCreate");
		super.onCreate();
	}
	@Override
	public void onDestroy() {
		Log.d(TAG, "onDestroy");
		super.onDestroy();
	}
}
5) AndroidManifest.xml 
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.qinuli.testproject"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="19" />
    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity android:name="com.qinuli.testproject.MainActivity">
            <intent-filter >
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
        <service android:name="com.qinuli.testproject.MyService"></service>
        <service android:name="com.qinuli.testproject.MyIntentService"></service>
    </application>

</manifest>

2、如何让服务永久运行

本示例介绍了TIME_TICK和BOOT_COMPLETED广播的用法

public class MainActivity extends Activity {
	private static final String TAG = MainActivity.class.getSimpleName();
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		Log.d(TAG, "onCreate");
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
	}
	@Override
	protected void onDestroy() {
		Log.d(TAG, "onDestroy");
		super.onDestroy();
	}
	public void onClick(View v){
		switch(v.getId()){
		case R.id.btn_killProcess:
			Process.killProcess(Process.myPid());
		}
	}
}
MyService.java 

public class MyService extends Service {

	private static final String TAG = MyService.class.getSimpleName();
	private MyBinder myBinder = new MyBinder();
	public class MyBinder extends Binder{
		public MyService getService(){
			return MyService.this;
		}
	}
	@Override
	public IBinder onBind(Intent intent) {
		return myBinder;
	}
	@Override
	public void onCreate() {
		Log.d(TAG, "onCreate");
		super.onCreate();
	}
	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		Log.d(TAG, "onStartCommand");
		//进程被杀死，服务会重建
		return Service.START_STICKY;
	}
	@Override
	public void onDestroy() {
		Log.d(TAG, "onDestroy");
		super.onDestroy();
	}
}
MyApplication.java 
public class MyApplication extends Application {
	private static final String TAG = MyApplication.class.getSimpleName();
	MyService myService;
	Intent intent;
	@Override
	public void onCreate() {
		Log.d(TAG, "onCreate");
		super.onCreate();
		
		intent = new Intent(this, MyService.class);
		startService(intent);
		bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
		
		registerReceiver(new TimeTickReceiver(), new IntentFilter(Intent.ACTION_TIME_TICK));
	}
	@Override
	public void onTerminate() {
		Log.d(TAG, "onTerminate");
		super.onTerminate();
		stopService(intent);
		//禁用一个manifest receiver，可禁用清单文件里注册的四大组件
		ComponentName componentName = new ComponentName(this, BootCompletedReceiver.class);
		PackageManager pm = getPackageManager();
		pm.setComponentEnabledSetting(componentName, PackageManager.COMPONENT_ENABLED_STATE_DISABLED, 
				PackageManager.DONT_KILL_APP);
	}
	private ServiceConnection mServiceConnection = new ServiceConnection() {
		@Override
		public void onServiceDisconnected(ComponentName name) {
			myService = null;
		}
		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			Log.d(TAG, "onServiceConnected");
			myService = ((MyBinder)service).getService();
		}
	};
}
BootCompleteReceiver.java 
public class BootCompletedReceiver extends BroadcastReceiver {
	private static final String TAG = BootCompletedReceiver.class.getSimpleName();

	public BootCompletedReceiver(){
		super();
		Log.d(TAG, "BootCompletedReceiver");
	}
	
	public void onReceive(Context context, Intent intent) {
		String action = intent.getAction();
		Log.d(TAG, action);
		if (Intent.ACTION_BOOT_COMPLETED.equals(action)) {
			//清单文件注册，开机可收到广播
			boolean isServiceRunning = false;
			ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
			for(RunningServiceInfo runningServiceInfo:activityManager.getRunningServices(Integer.MAX_VALUE)){
				if(MyService.class.getName().equals(runningServiceInfo.service.getClassName())){
					isServiceRunning = true;
				}
			}
			if(!isServiceRunning){
				ComponentName comp = new ComponentName(context.getPackageName(), MyService.class.getName());
				context.startService(new Intent().setComponent(comp));
			}
		}else if(ConnectivityManager.CONNECTIVITY_ACTION.equals(action)){
			//在清单文件注册，退出APP或杀死进程依然能收到广播，但清掉内存就收不到了
			ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
			NetworkInfo networkInfo = cm.getActiveNetworkInfo();
			if(networkInfo!=null)
				Log.d(TAG, "networkstate:"+networkInfo.isConnectedOrConnecting()+"-"+(networkInfo.getType()==ConnectivityManager.TYPE_MOBILE));
		}
	}
}
TimeTickReceiver.java 
public class TimeTickReceiver extends BroadcastReceiver {
	private static final String TAG = TimeTickReceiver.class.getSimpleName();

	public TimeTickReceiver(){
		super();
		Log.d(TAG, "TimeTickReceiver");
	}
	
	@Override
	public void onReceive(Context context, Intent intent) {
		String action = intent.getAction();
		Log.d(TAG, action);
		if (Intent.ACTION_TIME_TICK.equals(action)) {
			boolean isServiceRunning = false;
			//拿到所有正在运行的服务
			ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
			for(RunningServiceInfo runningServiceInfo:activityManager.getRunningServices(Integer.MAX_VALUE)){
				if(MyService.class.getName().equals(runningServiceInfo.service.getClassName())){
					isServiceRunning = true;
				}
			}
			Log.d(TAG, "isServiceRunning="+isServiceRunning);
			if(!isServiceRunning){
				ComponentName comp = new ComponentName(context.getPackageName(), MyService.class.getName());
				context.startService(new Intent().setComponent(comp));
			}
		}
	}
}
AndroidManifest.xml 
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.qinuli.servicetest"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="21" />

    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
    
    <application
        android:name="com.qinuli.servicetest.MyApplication"
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity android:name="com.qinuli.servicetest.MainActivity">
            <intent-filter >
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
        <service android:name="com.qinuli.servicetest.MyService"
            android:enabled="true"
            android:exported="false"/>
        <receiver
            android:name="com.qinuli.servicetest.BootCompletedReceiver"
            android:permission="android.permission.RECEIVE_BOOT_COMPLETED"
            android:enabled="true" >
            <intent-filter>
                <action android:name="android.intent.action.BOOT_COMPLETED" />
                <action android:name="android.net.conn.CONNECTIVITY_CHANGE"/>
            </intent-filter>
        </receiver>
    </application>

</manifest>


艟粼
关注
专栏目录
服务的作用android,简析安卓Android服务Service
weixin_30061949的博客
05-25 1258
前言平时的开发中，我们用的最多就是在Activity中进行开发。当我们需要处理一个耗时的逻辑的时候，为防止ANR我们会开启一个子线程来执行，例如网络请求等。但是当我们需要一个逻辑在后台持续运行，并且能和多个活动进行通信，例如后台播放器，子线程貌似就显得无能为力了。这个时候就需要用到服务了。顾名思义，他作为后台逻辑，为前台的Activity服务。接下来看看什么是服务。什么是service？简介服务S...
android中为什么使用service？
mxw3755的专栏
12-03 1229
把Service等同于thread或process是一个非常常见的误解。需要强调又强调的第一点是，Android的Service是一个Context，并不必然等于一个额外的thread。如果你有仔细看文档(Service | Android Developers)，里面专门强调 A Service is not a separate process. The Service object
Android——service使用详解
最新发布
2401_86637658的博客
09-11 1607
如果服务同时处理多个 onStartCommand() 请求，则不应在处理完一个启动请求之后立即销毁服务，因为此时可能已经收到了新的启动请求，在第一个请求结束时停止服务会导致第二个请求被终止。通过Log日志可以发现，多次点击“播放音乐”按钮，“onCreate()”方法只会在初始时调用一次，“onStartCommand(Intent intent, int flags, int startId)”方法会在每次点击时都被调用，点击“停止音乐”按钮，“onDestroy()”方法会被调用。
Android Service 的几个用途
luoxianfeng89的专栏
02-27 4318
Android Service 一般有三个用途，分别是功能调度，功能提供、远程调用（进程通信、aidl） 功能调度是指：Service接收指定的广播信息，从而进一步分析和处理事件，最后修改数据、更新界面或者过行其他相关的操作，调度整个应用使其保持正确的状态。 功能提供是指：Service并没有接收任何的广播，只是提供状态数据，这时候需要绑定Service，也就是binderService，这时
Service的作用
JavaLive09的专栏
04-30 2350
应用场景： 1.需要不被kill的权限高。
Android Service中方法使用详细介绍
01-05
在Android中，Activity主要负责前台页面的展示，Service主要负责需要长期运行的任务。例如，一个从service播放音乐的音乐播放器，应被设置为前台运行，因为用户会明确地注意它的运行．在状态栏中的通知可能会显示...
浅谈Android中Service的注册方式及使用
08-27
Android中Service的注册方式及使用是非常重要的知识点，在实际开发中，我们常常需要使用Service来实现一些后台服务的功能。了解Service的注册方式和使用场景可以帮助我们更好地实现应用程序的功能。
Android Service中使用Toast无法正常显示问题的解决方法
09-01
2. 创建一个Runnable对象，然后在run()方法中使用`Toast.makeText()`创建并显示Toast。这样，Runnable会在主线程上执行，确保Toast的显示操作发生在正确的上下文中。 ```java handler.post(new Runnable() { @...
Service的作用是什么？
06-17 474
在这个示例中，我们创建了一个名为MyService的Service，并在其内部使用HandlerThread来执行耗时操作。在Handler的handleMessage()方法中，我们可以执行实际的耗时操作，并在操作完成后调用stopSelf()来停止服务。在Android开发中，Service是一个重要的组件，它允许应用在后台执行长时间运行的操作，同时不向用户显示界面。以下是关于Service的作用的详细描述，包括技术难点、面试官关注点、回答吸引力和代码举例。
前台service的使用
mb061的博客
01-12 437
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
AndroidService
SueAnthony223的专栏
10-08 500
入门请登陆A安卓巴士 http://www.apkbus.com/forum.php?mod=viewthread&tid=654&fromuid=117522 Service的作用：比如播放音乐，或者记录你地理信息位置的改变，或者启动一个服务来运行并一直监听某种动作！ Service的生命周期： context.startService() ->onCreate()- >
聊一聊：Service层你觉得有用吗？
程序猿DD
01-27 1228
前段日子在社群（点击加入）里看到有人讨论关于Service层接口的问题，DD也经常碰到周围的新人有问过一些类似的问题：一定要写个Service层的接口吗？Service层的接口到底用做什么用的呢？好像都没什么用啊？ 说说我的看法： Service层在业务逻辑不复杂的时候，似乎是没有什么用，但是随着应用迭代，业务逻辑变得复杂了之后，这一层是非常有用的。 主要表现在这几个方面： 1、更适合用来处理复杂的业务逻辑，可能会涉及多张表的操作，甚至还混杂着消息投递、接口调用等一系列的复杂综合性事务，这也是我们常说的事务
android service 优点,Android之Service
weixin_36179469的博客
05-27 239
startService()： run indefinetly, 需要在适当时候stopSelf()onBind(): 提供一个CS模式的服务，runs as long as the component bound to it. 当所有组件都unBind() 时，Service也就destroy了。Service运行于主进程，因此勿做耗时工作，如果需要，可以开启新的线程来做耗时的work，以避免A...
第十四单元：Service生命周期和启动方式
shuai_ge_feng的博客
07-21 1829
Service生命周期和启动方式Service介绍Service特点如何创建ServiceService的启动方式以及生命周期启动方式一 (startService)启动方式二 (bindService) Service介绍 1.Service，服务，是四大组件之一, 和Activity 非常相似, 一般运行在后台, 没有用户界面, 可执行的程序 2.Activity 和 Service的区别...
android：Service介绍
Mario_faker的博客
03-22 485
下面主要讲本地Service：什么是Service：Service是android系统四大组件之一， Service主要有两个作用：长驻后台，运行一些任务（例如：1. 你需要在后台每隔一段时间就执行某个任务，即使activity退出了）Service可以被跨进程访问注意：Service不是一个单独的进程，它和应用程序共享同一个进程。Service不是一个线程，它运行在应用程序的主线程（所以你要进行...
Service概念及用途:
cptianyu的博客
06-07 3479
Service概念及用途: A service is an application component that can perform long-running operations in the background and does not provide a user interface。 通常service用来执行一些耗时操作，或者后台执行不提供用户交互界面的操作，例如：下载
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值