Service用法概述

迈不过友情╰ 2022-08-20 09:20 198阅读 0赞

## 1.service分类：运行在主线程中 ##

绑定服务与非绑定服务  
区别：  
非绑定的服务能给service传值，service不能给activity传值  
与调用者无关联，调用者退出，服务仍可运行  
绑定的服务service能给activity传值  
与调用者有关联，调用者退出，服务也退出

## 2.服务的生命周期的五个方法： ##

//创建，只会被执行一次  
onCreate()  
//服务被创建之后执行（执行服务的逻辑，例如下载文件，播放音乐等）  
onStartCommand(Intent intent, int flags, int startId)  
//绑定服务执行的方法（通过IBinder可以使 服务器向activity传值）  
onBind(Intent intent)  
//解除绑定执行的方法  
onUnbind(Intent intent)  
//销毁服务  
onDestroy()

## 3.非绑定服务的使用： ##

使用步骤：  
\* 1.写一个类继承service，实现必须重写的onBind(Intent intent)方法；  
重写onStartCommand(Intent intent, int flags, int startId)方法。执行服务的逻辑，如：下载文件，播放音乐  
\* 2.在清单文件中注册  
\* 3.通过Intent开启服务与传值（非绑定的方式开启）  
Intent intent = new Intent(MainActivity.this, MyService.class);  
//通过意图给服务传值(但是绑定服务不能给activity传值)  
intent.putExtra(“play”,”哈哈哈哈”);  
\* 4.开启服务  
startService(intent);  
\* 5.停止服务  
stopService(intent);

非绑定服务的生命周期：  
\* 1.开启服务执行的方法  
\* onCreate()  
\* onStartCommand()  
\* 当服务已经开启，再次开启的时候，不执行onCreate()，只执行onStartCommand()  
\* 如果不调用stopService()方法，服务将一直在后台运行  
\* 2.停止执行的方法  
\* onDestroy()

## 4.绑定服务的使用： ##

使用步骤：  
\* 1.创建服务，写一个类继承Service，实现重写的onBind()方法  
重写onBind(Intent intent)方法，返回IBinder对象，利用该对象向activity传值  
重写其他的方法查看生命周期  
\* 2.在清单文件中注册  
\* 3.通过bindService开启绑定服务，将三个参数传入：  
bindService(intent,serviceconnection,int flag)  
参数说明：  
\* 参数1：intent;  
\* 参数2：ServiceConnection传值的桥梁;一般写一个内部类实现ServiceConnection接口，声明内部类将对象传入  
或者直接new ServiceConnection()实现重写的方法  
\* 参数3：flag服务标志位，一般设置为BIND\_AUTO\_CREATE;  
\* 4.解除绑定：unbindService(myConnection);  
\* 5.进行和activity交互传值  
在service中重写onBind(Intent intent)方法，返回IBinder对象，利用该对象向activity传值  
a：写一个内部类继承Binder，在该内部类里面自定义方法return 值；  
b：声明该内部类对象，在onBind(Intent intent)方法中return 该对象  
通过a，b方法就能通过绑定服务将service的值传给activity了。  
代码如下：

private MyIBinder myIBinder = new MyIBinder();
                         @Override
                        public IBinder onBind(Intent intent) {
                            Log.e("---", "onBind");
                            return myIBinder;
                        }
    
                         /** * 以绑定开启的服务，需要创建一个binder的返回对象 * 可以写携带的数据，也可以把当前的服务带回activity */
                        class MyIBinder extends Binder { 
    
                            //自己写的，返回当前service
                            MyService getService(){
                                return MyService.this;
                            }
    
                            //如果返回为一个String类型的值，可以写一个String类型返回值的方法
                            String getStringData(){
                                return "hahahah";
                            }
                        }

在Activity中得到service传归来的值：在ServiceConnection传值的桥梁中来获得  
写一个内部类实现ServiceConnection接口实现两个重写的方法:  
onServiceConnected(ComponentName name, IBinder service)：接收服务传回来的值  
onServiceDisconnected(ComponentName name)：当服务被异常kill的时候调用的方法  
代码如下：  
class MyConnection implements ServiceConnection \{  
//接收服务传回来的值  
@Override  
public void onServiceConnected(ComponentName name, IBinder service) \{  
//从服务里面拿回值（得到回传过来的服务）  
//强制转换成IBinder对象6  
myIBinder = (MyService.MyIBinder) service;

//得到service  
myService = myIBinder.getService();

//得到String类型数据  
String data = myIBinder.getStringData();  
Log.e(“—”,”binderData:”+data);  
\}

//当服务被异常kill的时候调用的方法  
@Override  
public void onServiceDisconnected(ComponentName name) \{

\}  
\}

绑定服务的生命周期：  
\* 绑定服务启动调用的方法  
\* onCreate()  
\* onBind()  
\* 注意：只会创建一次，绑定一次，不会重复绑定  
\* 解除绑定调用的方法：  
\* onUnbind(Intent intent)  
onDestory()

## 5.服务中进行耗时操作的两种方式：（IntentService） ##

IntentService使用队列的方式将请求的Intent加入队列，然后开启一个worker thread(线程)来处理队列中的Intent，对于异步的  
startService请求，IntentService会处理完成一个之后再处理第二个，每一个请求都会在一个单独的worker thread中处理，不会阻塞应用  
程序的主线程。  
（1）在服务中开启一个线程执行耗时操作  
步骤：  
a：写一个类继承Service;实现重写的方法  
b：在清单文件中注册  
b：根据启动模式重写相应方法，在方法中开启线程执行耗时操作，  
可以将下载的数据保存在sdCard中  
1）非绑定启动  
onCreate()  
onStartCommand(Intent intent, int flags, int startId);线程操作在此进行  
onDestory()  
2）绑定启动  
onBind(Intent intent)  
onUnBind()  
onDestory()

c：在主线程中读取SDCard中的数据，显示在UI上

（2）IntentServie；里面封装了一个Thread  
步骤：  
a：写一个类继承IntentService,实现重写的方法onHandleIntent(Intent intent)  
在这个方法中执行耗时操作  
//下载的逻辑代码  
@Override  
protected void onHandleIntent(Intent intent) \{  
byte\[\] data = HttpURLConnHelper.loadByteFromURL(path);  
boolean flag = SDCardHelper.saveFileToSDCardPublicDir(data, Environment.DIRECTORY\_DOWNLOADS, “haha.jpg”);  
\}  
b：注意必须有一个空的构造方法（将实现的构造方法，改为空的构造方法）

6.Activity、Service、BroadCastReceiver之间的通信  
在主界面上，启动后台服务Service，后台处理数据，前台通过BroadcastReceiver获得数据并更新UI。  
在Service中通过启动广播将数据发送到Activity中步骤：

//a：创建服务，写一个类继承IntentService，实现重写的onHandlerIntent(Intent intent)方法，并在清单文件中注册service
                在此方法中执行耗时操作
            //b：在service中执行完操作后，通过Intent发送广播（设置action，发送广播）
                //设置广播的action
                Intent intent1 = new Intent("com.sendValue.value");
                intent1.putExtra("value",value);
                sendBroadcast(intent1);
            //c：在Activity中通过Intent开启服务
                //开启服务
                Intent intent = new Intent(MainActivity.this, LoadService.class);
                startService(intent);
            //d：在Activity中动态注册广播（注意action要和service中发送过来的action一致），在onReceive()方法里面接收到值
                //通过写一个内部类继承BroadcastReceiver实现onReceive(Context context, Intent intent)方法，来动态注册广播
                //动态注册广播
                intentFilter = new IntentFilter();
                intentFilter.addAction("com.sendValue.value");
                //注册广播
                registerReceiver(myBroadCast, intentFilter);
             //获得service通过广播发送过来的数据，进行UI更新 
                class MyBroadCast extends BroadcastReceiver { 
                    @Override
                    public void onReceive(Context context, Intent intent) {
                        //接收到动态的值
                        int data = intent.getIntExtra("value",1);
                        textView.setText(""+data);
                    }
                }
            //e：在onDestroy()方法中解除广播的注册
                 @Override
                    protected void onDestroy() {
                        super.onDestroy();
                        unregisterReceiver(myBroadCast);
                    }

Demo：Activity

/** * 案例：服务里面一直执行下载操作然后需要把下载的值传回activity中 * 步骤： * 1.创建服务并且实现逻辑 * 2.在服务执行逻辑的时候将值传到广播上 * 3.在activity里动态注册广播，在onReceive()方法里面接收到值 */
    public class MainActivity extends AppCompatActivity { 
    
    private TextView textView;
    
    private MyBroadCast myBroadCast;
    private IntentFilter intentFilter;
    
    private LoadService loadService;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    
    textView = (TextView) findViewById(R.id.text);
    
    myBroadCast = new MyBroadCast();
    loadService = new LoadService();
    //开启服务
    Intent intent = new Intent(MainActivity.this, LoadService.class);
    startService(intent);
    
    //动态注册广播
    intentFilter = new IntentFilter();
    intentFilter.addAction("com.sendValue.value");
    //注册广播
    registerReceiver(myBroadCast, intentFilter);
    }
    
    //广播的内部类
    class MyBroadCast extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
    //接收到动态的值
    int data = intent.getIntExtra("value",1);
    textView.setText(""+data);
    }
    }
    
    @Override
    protected void onDestroy() {
    super.onDestroy();
    unregisterReceiver(myBroadCast);
    }

Manifest.xml清单文件中：

Service中：
                /** * Created by niutingting on 2016/2/19 0019. */
                public class LoadService extends IntentService { 
                    //模拟下载进度的值
                     int value = 0;
    
                    /** * Creates an IntentService. Invoked by your subclass's constructor. */
                    public LoadService() {
                        super("name");
                    }
    
                    @Override
                    protected void onHandleIntent(Intent intent) {
                        //网络逻辑在这里执行
                        while (true) {
                            try {
                                Thread.sleep(1000);
                                value++;
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            //设置广播的action
                            Intent intent1 = new Intent("com.sendValue.value");
                            intent1.putExtra("value",value);
                            sendBroadcast(intent1);
                        }
                    }
                }

7.注意：  
当开启服务并且开启了绑定服务  
生命周期：  
onCreate()  
onStartCommand(Intent intent, int flags, int startId)  
onBind(Intent intent)  
onUnbind(Intent intent)  
onDestroy()  
当绑定之后只有解除绑定，非绑定的服务才能销毁