七乐彩复式中奖规则: Android 四大组件 Service 服务

主页 > 山东快乐扑克3 > 学习经验 > 学Java学Android经验 >

Android 四大组件 Service 服务

山东快乐扑克3 www.rn5v7.cn 1.Service简介

 

按照使用范围分类:

 

类别 优点 缺点 区别 应用
本地服务 Local  Service 本地服务在一定程度上节约了资源,另外本地服务因为是在同一进程,因此不需要IPC,也不需要AIDL。相应bindService会方便很多。 主进程被Kill后,服务便会终止。

本地服务依附在主进程上,而不是独立的进程,用于应用程序内部

。
音乐播放服务

远程服务

Remote Service
对应进程名格式为所在包名加上指定的android:process字符串。由于是独立的进程,因此在Activity所在进程被Kill的时候,该服务依然在运行,不受其他进程影响,有利于为多个进程提供服务,具有较高的灵活性。 会占用一定资源,并且使用AIDL进行IPC稍微麻烦一点。

远程服务是独立的进程,用于android系统内部的应用程序之间,可被其他应用程序复用

。
提供天气状况、时间日历的系统服务,这种Service是常驻的。

 

 

按运行类型分类:

类别 区别 应用
前台服务 会在通知栏显示正在运行的Notification 当服务被终止的时候,通知一栏的 Notification 也会消失,对于用户有一定的通知作用。如音乐播放服务。
后台服务 默认的为后台服务,没有Notification 某些不需要提示的服务运行或终止时,用户看不到效果,如天气更新,日期同步,邮件同步等

 

服务是在调用 startForeground(android 2.0 及其以后版本)使服务成为前台服务。这样做的好处在于,当服务被外部强制终止掉的时候,ONGOING 的 Notification 会被移除掉。

 

按照使用方式分类:

 

类别 区别
startService 启动的服务 主要用于启动一个服务执行后台任务,不进行通信。停止服务使用stopService
bindService 启动的服务 该方法启动的服务要进行通信,停止服务使用unbindService

 

 

 

2.Service 与 Thread 的区别(总结于网络)

 

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

2). Service:Service 是android的一种机制,

如果运行的是Local Service,那么对应的 Service 是运行在主进程的 main 线程上的。如:onCreate,onStartCommand这些函数在被系统调用的时候都是在主进程的 main 线程上运行的。

如果运行是Remote Service,那么对应的 Service 则是运行在独立进程的 main 线程上。

 

为什么 Thread替代不了Service 呢?

一方面,Thread 的运行是独立于 Activity 的,也就是说当一个 Activity 被 finish 之后,如果你没有主动停止 Thread 或者 Thread 里的 run 方法没有执行完毕的话,Thread 也会一直执行,因此这里会出现一个问题:当 Activity 被 finish 之后,你不再持有该 Thread 的引用。另
如果创建的 Thread 需要不停地隔一段时间就要连接服务器做某种同步的话,该 Thread 需要在 Activity 没有start的时候也在运行。这个时候当你 start 一个 Activity 就没有办法在该 Activity 里面控制之前创建的 Thread。

 

另一方面,因此你便需要创建并启动一个 Service ,在 Service 里面创建、运行并控制该 Thread,这样便解决了该问题,因为任何 Activity 都可以控制同一 Service,而系统也只会创建一个对应 Service 的实例。

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

 

3.startService

 

被启动的服务的生命周期:onCreate -> onStartCommand -> onDestroy

 

如果Service被startService方法启动多次,其中只会调用一次onCreate方法,但是会调用多次onStartCommand,此时系统只会创建一个Service实例,因此只需要调用一次stopService方法就可以停掉服务。

如果Service被某个Activity 调用startService方法启动,不管是否有Activity使用bindService绑定或unbindService解除绑定到该Service,该Service都在后台运行。

startService启动的Service将会一直在后台运行,而不管对应程序的Activity是否在运行,直到被调用stopService、或自身的stopSelf方法、或系统资源不足android系统也可能结束该服务。

 

demo1.java

 

[java] view plain copy
 
  1. public class demo1 extends AppCompatActivity {  
  2.   
  3.     private Button start;  
  4.     private Button stop;  
  5.   
  6.     @Override  
  7.     protected void onCreate(Bundle savedInstanceState) {  
  8.         super.onCreate(savedInstanceState);  
  9.         setContentView(R.layout.demo1);  
  10.   
  11.         start = (Button) findViewById(R.id.start_Service1);  
  12.         stop = (Button) findViewById(R.id.stop_Service1);  
  13.   
  14.         //1.创建启动Service的Intent  
  15.         final Intent intent = new Intent(demo1.this, service1.class);  
  16.   
  17.         start.setOnClickListener(new View.OnClickListener() {  
  18.             @Override  
  19.             public void onClick(View v) {  
  20.                 //2.启动service  
  21.                 startService(intent);  
  22.             }  
  23.         });  
  24.         stop.setOnClickListener(new View.OnClickListener() {  
  25.             @Override  
  26.             public void onClick(View v) {  
  27.                 //3.停止service  
  28.                 stopService(intent);  
  29.             }  
  30.         });  
  31.   
  32.     }  
  33. }  

service1.java

 

 

[java] view plain copy
 
  1. public class service1 extends Service {  
  2.     private final String TAG = "service1";  
  3.   
  4.     //Service被创建时调用  
  5.     @Override  
  6.     public void onCreate() {  
  7.         super.onCreate();  
  8.         Log.i(TAG, "onCreate方法被调用");  
  9.     }  
  10.   
  11.     //必须要实现的方法  
  12.     @Nullable  
  13.     @Override  
  14.     public IBinder onBind(Intent intent) {  
  15.         Log.i(TAG, "onCreate方法被调用");  
  16.         return null;  
  17.     }  
  18.   
  19.     //Service被启动时调用  
  20.     @Override  
  21.     public int onStartCommand(Intent intent, int flags, int startId) {  
  22.         Log.i(TAG, "onStartCommand方法被调用!");  
  23.         return super.onStartCommand(intent, flags, startId);  
  24.     }  
  25.   
  26.     //Service被关闭之前回调  
  27.     @Override  
  28.     public void onDestroy() {  
  29.         Log.i(TAG, "onDestroy方法被调用!");  
  30.         super.onDestroy();  
  31.     }  
  32. }  
还有注册一下!

 

AndroidManifest.xml:

[html] view plain copy
 
  1. <span style="font-size:18px;"><service android:name=".Service.service1"/></span>  

注意:

当Service需要运行在单独的进程中,AndroidManifest.xml声明时需要通过android:process指明此进程名称。

当Service需要对其他App开放时,android:exported属性值需要设置为true(当然在有intent-filter时默认值就是true)。

 

4.bindService

 

被绑定的服务的生命周期:onCreate-> onBind-> onUnbind

 

如果Service被某个Activity调用bindService方法绑定启动,不管调用bindService几次,只会调用一次onCreate方法,同时始终不会调用onStartCommand方法。

当连接建立之后,Service将会一直运行,除非调用unbindService断开连接、或之前调用bindService的Context 不存在了,如Activity被finish的时候,系统将会自动停止Service,对应的将被调用onDestroy方法。

 

根据onBind(Intentintent)方法放回的Binder对象的定义方式不同,又可以将其分为以下三种方式,这里,先写第一种方式,此方式Clinet与Service必须同属于同一个进程,不能实现进程间通信(IPC)。否则会出现类似于“android.os.BinderProxycannot be cast to xxx”错误。

demo2.java

 

[java] view plain copy
 
  1. public class demo2 extends AppCompatActivity {  
  2.   
  3.     private Button bind;  
  4.     private Button cancel;  
  5.     private Intent intent;  
  6.     private service2 service2;  
  7.     private service2.myBinder myBinder;  
  8.     private ServiceConnection conn = new myServiceConnection();  
  9.     private boolean mBound;  
  10.   
  11.     //保持所启动的service2的IBinder对象,同时定义一个ServiceConnection对象。  
  12.     private class myServiceConnection implements ServiceConnection {  
  13.   
  14.         @Override  
  15.         public void onServiceConnected(ComponentName name, IBinder service) {  
  16.             System.out.println("----Service Connected----");  
  17.             myBinder = (com.guofeng.demo4.Service.service2.myBinder) service;  
  18.             service2 = myBinder.getgetService();  
  19.             mBound = true;  
  20.         }  
  21.   
  22.         @Override  
  23.         public void onServiceDisconnected(ComponentName name) {  
  24.             System.out.println("----Service DisConnected----");  
  25.             mBound = false;  
  26.   
  27.         }  
  28.     }  
  29.   
  30.   
  31.     @Override  
  32.     protected void onCreate(Bundle savedInstanceState) {  
  33.         super.onCreate(savedInstanceState);  
  34.         setContentView(R.layout.demo2);  
  35.         bind = (Button) findViewById(R.id.bind_service2);  
  36.         cancel = (Button) findViewById(R.id.cancel_service2);  
  37.         intent = new Intent(demo2.this, service2.class);  
  38.   
  39.         bind.setOnClickListener(new View.OnClickListener() {  
  40.             @Override  
  41.             public void onClick(View v) {  
  42.                 bindService(intent, conn, BIND_AUTO_CREATE);  
  43.   
  44.             }  
  45.         });  
  46.   
  47.         cancel.setOnClickListener(new View.OnClickListener() {  
  48.             @Override  
  49.             public void onClick(View v) {  
  50.                 excuteUnbindService();  
  51.             }  
  52.         });  
  53.   
  54.   
  55.     }  
  56.   
  57.     private void excuteUnbindService() {  
  58.         if (mBound) {  
  59.             unbindService(conn);  
  60.             mBound = false;  
  61.         }  
  62.     }  
  63.   
  64.     @Override  
  65.     protected void onDestroy() {  
  66.         super.onDestroy();  
  67.         excuteUnbindService();  
  68.     }  
  69. }  

service2.java

 

 

[java] view plain copy
 
  1. public class service2 extends Service {  
  2.   
  3.     private final String TAG = "Service2";  
  4.     private myBinder binder = new myBinder();  
  5.     public class myBinder extends Binder {  
  6.         service2 getgetService() {  
  7.             return service2.this;  
  8.         }  
  9.     }  
  10.   
  11.     @Override  
  12.     public void onCreate() {  
  13.         Log.i(TAG, "onCreate方法被调用");  
  14.         super.onCreate();  
  15.     }  
  16.   
  17.     @Nullable  
  18.     @Override  
  19.     public IBinder onBind(Intent intent) {  
  20.         Log.i(TAG, "onBind方法被调用");  
  21.         return binder;  
  22.     }  
  23.   
  24.     @Override  
  25.     public boolean onUnbind(Intent intent) {  
  26.         Log.i(TAG, "onUnbind方法被调用");  
  27.         return super.onUnbind(intent);  
  28.     }  
  29.   
  30.     @Override  
  31.     public void onRebind(Intent intent) {  
  32.         Log.i(TAG, "onRebind方法被调用");  
  33.         super.onRebind(intent);  
  34.     }  
  35.   
  36.     @Override  
  37.     public void onDestroy() {  
  38.         Log.i(TAG, "onDestroy方法被调用");  
  39.         super.onDestroy();  
  40.     }  
  41. }  
当然要记得注册Service。

 

 

注意:

1.自定义Service继承基类Service,并重写onBind(Intentintent)方法,此方法中需要返回具体的Binder对象;

2.Client通过实现ServiceConnection接口来自定义ServiceConnection,并通过bindService(Intent service, ServiceConnection sc, int flags)方法将Service绑定到此Client上;

3.自定义的ServiceConnection中实现onServiceConnected(ComponentNamename, IBinder binder)方法,获取Service端Binder实例;

4.通过获取的Binder实例进行Service端其他公共方法的调用,以完成Client-Service通信;

5.当Client在恰当的生命周期(如onDestroy等)时,此时需要解绑之前已经绑定的Service,通过调用函数unbindService(ServiceConnectionsc)。

 

其他:

1.如果Service又被启动又被绑定,则该Service将会一直在后台运行。不管如何调用,始终只会调用一次onCreate,对应调用多少次startService,Service便会调用多少次onStartCommand。

调用unbindService将不会停止Service,而必须调用stopService 、或Service的stopSelf 来停止服务。

2.当服务的onDestroy方法被调用时,应做一些清除工作,如:停止在Service中创建并运行的线程。

3. 想要用startService启动服务,不管Local还是Remote记得在Androidmanifest.xml 中注册service。

4. Service本身都是运行在其所在进程的主线程(如果Service与Clinet同属于一个进程,则是运行于UI线程),但Service一般都是需要进行“长期”操作,所以经常写法是在自定义Service中处理“长期”操作时需要新建线程,以免阻塞UI线程或导致ANR。

 

5.IntentService

 

IntentService是系统提供给我们的一个已经继承自Service类的特殊子类,主要用于防止线程阻塞,处理异步请求。所有的请求将在一个工作线程HandlerThread中处理,工作完成了,线程也就结束了。

1.默认直接实现了onBind方法,直接返回null,并定义了抽象方法onHandlerIntent,用户自定义子类时,需要实现此方法。

2.onHandlerIntent主要就是用来处于相应的”长期“任务的,并且已经自动在新的线程中,用户无语自定义新线程;

3.当”长期“任务执行完毕后,也就是onHandlerIntent执行完毕后,此IntentService将自动结束,无需人为调用方法使其结束。

4.IntentService处于任务时,也是按照队列的方式一个个去处理,并非真正意义上的多线程并发方式。

 

demo3.java

 

[java] view plain copy
 
  1. public class demo3 extends AppCompatActivity {  
  2.     private Context mContext;  
  3.   
  4.     @Override  
  5.     protected void onCreate(Bundle savedInstanceState) {  
  6.         super.onCreate(savedInstanceState);  
  7.         setContentView(R.layout.demo3);  
  8.   
  9.         mContext = this;  
  10.         Button btn = (Button) findViewById(R.id.btn3);  
  11.         assert btn != null;  
  12.         btn.setOnClickListener(new View.OnClickListener() {  
  13.             @Override  
  14.             public void onClick(View v) {  
  15.                 Intent intent1 = new Intent(mContext, service3.class);  
  16.                 Bundle bundle1 = new Bundle();  
  17.                 bundle1.putString("param""s1");  
  18.                 intent1.putExtras(bundle1);  
  19.   
  20.                 Intent intent2 = new Intent(mContext, service3.class);  
  21.                 Bundle bundle2 = new Bundle();  
  22.                 bundle2.putString("param""s2");  
  23.                 intent2.putExtras(bundle2);  
  24.   
  25.                 Intent intent3 = new Intent(mContext, service3.class);  
  26.                 Bundle bundle3 = new Bundle();  
  27.                 bundle3.putString("param""s3");  
  28.                 intent3.putExtras(bundle3);  
  29.   
  30.                 //接着启动多次IntentService,每次启动,都会创建一个新工作线程  
  31.                 //但是始终只有一个IntentService实例  
  32.                 startService(intent1);  
  33.                 startService(intent2);  
  34.                 startService(intent3);  
  35.             }  
  36.         });  
  37.     }  
  38. }  

 

 

service3.java

 

[java] view plain copy
 
  1. public class service3 extends IntentService {  
  2.     private final String TAG = "IntentService:";  
  3.   
  4.     //必须实现父类的构造方法  
  5.     public service3() {  
  6.         super("guofeng");  
  7.     }  
  8.   
  9.     public service3(String name) {  
  10.         super(name);  
  11.     }  
  12.   
  13.     //必须重写的核心方法  
  14.     @Override  
  15.     protected void onHandleIntent(Intent intent) {  
  16.         String str = intent.getExtras().getString("param");  
  17.         if (str.equals("s1"))  
  18.             Log.i(TAG, "启动service1");  
  19.         else if (str.equals("s2"))  
  20.             Log.i(TAG, "启动service2");  
  21.         else if (str.equals("s3"))  
  22.             Log.i(TAG, "启动service3");  
  23.   
  24.         try {  
  25.             Thread.sleep(2000);  
  26.         } catch (InterruptedException e) {  
  27.             e.printStackTrace();  
  28.         }  
  29.   
  30.     }  
  31.   
  32.     //重写其他方法,用于查看方法的调用顺序  
  33.     @Override  
  34.     public void onCreate() {  
  35.         Log.i(TAG, "onCreate");  
  36.         super.onCreate();  
  37.     }  
  38.   
  39.     @Override  
  40.     public IBinder onBind(Intent intent) {  
  41.         Log.i(TAG, "onBind");  
  42.         return super.onBind(intent);  
  43.     }  
  44.   
  45.     @Override  
  46.     public int onStartCommand(Intent intent, int flags, int startId) {  
  47.         Log.i(TAG, "onStartCommand");  
  48.         return super.onStartCommand(intent, flags, startId);  
  49.     }  
  50.   
  51.     @Override  
  52.     public void setIntentRedelivery(boolean enabled) {  
  53.         Log.i(TAG, "setIntentRedelivery");  
  54.         super.setIntentRedelivery(enabled);  
  55.     }  
  56.   
  57.     @Override  
  58.     public void onDestroy() {  
  59.         Log.i(TAG, "onDestroy");  
  60.         super.onDestroy();  
  61.     }  
  62. }  

6.前台服务

 

 

在 SDK 2.0 及其以后版本使用的方法是 startForeground 与 stopForeground

NotificationListenerService和Android 通知栏Notification有关,它主要用于接收来自系统调用的服务及新通知的发布或删除。

 

service4.java
[java] view plain copy
 
  1. <span style="font-size:18px;">public class service4 extends Service {  
  2.     public static final String TAG = "Service4";  
  3.   
  4.     @Override  
  5.     public IBinder onBind(Intent intent) {  
  6.         return null;  
  7.     }  
  8.   
  9.     @Override  
  10.     public void onCreate() {  
  11.         super.onCreate();  
  12.         Log.i(TAG, "in onCreate");  
  13.     }  
  14.   
  15.     @TargetApi(Build.VERSION_CODES.JELLY_BEAN)  
  16.     @Override  
  17.     public int onStartCommand(Intent intent, int flags, int startId) {  
  18.         Log.i(TAG, "onStartCommand");  
  19.   
  20.         PendingIntent pi = PendingIntent.getActivity(  
  21.                 this,  
  22.                 0,  
  23.                 new Intent(this, demo3.class),  
  24.                 PendingIntent.FLAG_CANCEL_CURRENT  
  25.         );  
  26.         //NotificationManager nm = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);  
  27.         Notification.Builder myBuilder = new Notification.Builder(this);  
  28.         myBuilder.setContentTitle("QQ")  
  29.                 .setContentText("呵呵")  
  30.                 .setSmallIcon(R.mipmap.ic_launcher)  
  31.                 .setContentIntent(pi);  
  32.         Notification notification = myBuilder.build();  
  33.         //nm.notify(1, notification);  
  34.         //注意使用startForeground,id为0将不会显示notification  
  35.         startForeground(1, notification);  
  36.         return START_REDELIVER_INTENT;  
  37.     }  
  38.   
  39.     @Override  
  40.     public void onDestroy() {  
  41.         super.onDestroy();  
  42.         Log.i(TAG, "onDestroy");  
  43.     }  
  44. }  
  45. </span>  

关注一下onStartCommand(Intent intent, int flags, int startId)方法:

 

flags默认情况下是0,对应的常量名为START_STICKY_COMPATIBILITY。

startId是一个唯一的整型,用于表示此次Client执行startService方法的请求标识,在多次调用startService的情况下,呈现0,1,2....递增。另外,此函数具有一个int型的返回值,具体的可选值及含义如下:

 

START_NOT_STICKY:当Service因为内存不足而被系统kill后,接下来的某个时间内,即使系统内存足够可用,系统也不会尝试重新创建此Service。除非程序中Client明确再次调用startService启动此Service。

 

START_STICKY:当Service因为内存不足而被系统kill后,接下来的某个时间内,当系统内存足够可用的情况下,系统将会尝试重新创建此Service,一旦创建成功后将回调onStartCommand方法,但其中的Intent将是null,pendingintent除外。

 

START_REDELIVER_INTENT:与START_STICKY唯一不同的是,回调onStartCommand方法时,其中的Intent将是非空,将是最后一次调用startService中的intent。

 

 

7.在 AndroidManifest.xml 里 Service 元素的常见选项:

android:name:服务类名

android:label:服务的名字,如果此项不设置,那么默认显示的服务名则为类名

android:icon:服务的图标

android:permission:申明此服务的权限,这意味着只有提供了该权限的应用才能控制或连接此服务

android:process:表示该服务是否运行在另外一个进程,如果设置了此项,那么将会在包名后面加上这段字符串表示另一进程的名字

android:enabled:如果此项设置为 true,那么 Service 将会默认被系统启动,不设置默认此项为 false

android:exported:表示该服务是否能够被其他应用程序所控制或连接,不设置默认此项为 false。



上一篇: Android —— 内存泄漏检查   下一篇:没有了
504| 453| 700| 348| 664| 105| 244| 118| 321| 13|