android中Service使用详解

Posted 心之所善兮

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了android中Service使用详解相关的知识,希望对你有一定的参考价值。

service用于长期在后台处理任务,而不需要对用户可见。
service有2种基本的启动方式:
startService():使用这种方式,来进行单一的任务,不需要返回结果给调用者
bindService():与上面的相反。


下面是一些关于服务的重要说明,非常值得详细了解的:


继承service,实现自己的service;
在manifest中声明service,服务位于主线程,并不会创建自己的子线程。
下面是一些重写的方法:


onCreate();当服务被创建时调用,只调用一次。


onStartCommand();它与startService()对应,当服务启动后调用。如果你重写了该方法,你就有责任自己去
当任务结束以后,调用stopSelf()或者stopService()来停止服务。如果你是绑定的服务,就不需重新该方法了。


onBind();它与bindService()对应,通过返回IBinder,来与service交流。如果你并不像绑定它,就直接返回null


onDestroy();当服务不再被使用时需要销毁时调用,你应该在这里用来停止线程,注销监听器,广播。


如果一个组件如activity使用的是 startService()来启动服务的话,就会触发 onStartCommand(),然后服务就会一直运行,直到任务结束;服务的停止需要
手动控制:在启动服务的组件中调用 stopService()或者在服务本类中调用stopSelf() 


如果一个组件使用的是bindService()来启动服务的话,该服务就会运行,直到组件不约束它。


在系统内存很低的情况下,系统会强制停止服务,来恢复用于运行activity;但是下面这些情况下的服务不易被系统停止:服务与activity绑定或者
服务位于前台。但是如果服务最后还是被停止了,我们要重新启用服务。


service的创建和使用,

也可以使用IntentService,它是service子类,在处理后台任务时,不需要你自己开线程,可以直接在 onHandleIntent()中进行任务。

<span style="font-size:14px;">1.<manifest ... >
  ...
  <application ... >
      <service android:name=".ExampleService" 
      		 android:exported="false"
      />
      ...
  </application>
</manifest>

public class HelloIntentService extends IntentService {

    A constructor is required, and must call the super IntentService(String)
    constructor with a name for the worker thread.
  public HelloIntentService() {
      super("HelloIntentService");
  }

   * The IntentService calls this method from the default worker thread with
   * the intent that started the service. When this method returns, IntentService
   * stops the service, as appropriate.
  @Override
  protected void onHandleIntent(Intent intent) {
      // Normally we would do some work here, like download a file.
      // For our sample, we just sleep for 5 seconds.
      try {
          Thread.sleep(5000);
      } catch (InterruptedException e) {
          // Restore interrupt status.
          Thread.currentThread().interrupt();
      }
  }
}</span>
<span style="font-size:14px;">
</span>

使用intentservice,在任务结束后会自动关闭服务。

2.使用startService()来启动服务,一般在不需要交互的情况下使用这种方式,

在onStartCommand()中接受Intent ;
Intent intent = new Intent(this, HelloService.class);
startService(intent);


如果你的服务没有经过绑定,那么startService(intent)中的intent就是唯一的向service交互的方式;service中通过广播来向外发布回调。如果多次启动服务,会导致onStartCommand()被多次调用。


onStartCommand()必须返回一个整形值,描述这当系统杀掉服务时,系统该如何继续service
START_NOT_STICKY,杀掉后,不再重建
START_STICKY,杀掉后,自动重启,然后接收的intent=null
START_REDELIVER_INTENT,杀掉后,自动重启,然后接收的intent不为空;像文件下载

3.使用bindService()启动;这种方式使用更加复杂,但也更加灵活。

当你需要与服务交互的时候,可以采用这种方式;
必须重写 onBind()方法返回IBinder,来与其他组件交流。在其他组件中获取该IBinder对象
有一种client-server的感觉,可以有多个客户端与server交流


客户端组件,必须创建ServiceConnection,用来监听与service的连接;
可以有多个客户端连接service,但是service的onBind只会执行一次,所以分发给其他客户端的都是同一个IBinder对象
只有在多个客户端都解绑了服务之后,服务才会被销毁。


使用这种服务有个最重要的地方就是定义IBinder;
有3种方式:
a.直接继承Binder,这也是一般app常用的一种方式,适用于你的服务与你的app是处于同一个进程中的。你的服务仅仅是为了
处理后台任务。


b.使用Messenger,适用于需要跨进程通讯且线程安全且非并发,同一个时间只能接受到一个请求,你可以使用Messenger和Handler这2个 类来进行service和client的交互。

服务端建立信使对象,通过通过onbind将服务端信使对象放在IBind中回调给客户端,这样子客户端就可以拿到服务端信使对象,使用服务端信使对象给服务端发信息了。

在客户端连接上服务端后,可以建立客户端信使对象,将客户端信使对象以消息的形式,发送给服务端,服务端拿到客户端信使对象后可以给客户端发消息。

这个是线程安全的。因为都是在同一个队列里,在同一个线程里进行的。它本身是基于AIDL构建的。



c.使用AIDL,适用于需要跨进程,且非线程安全,能够同一时间处理多个请求的场合。
它的使用是创建一个.aidl file文件,里面定义接口,然后android sdk tool使用它来生成一个抽象类,抽象类里实现各种接口方法。
注意:对于大多数应用,我们都不应该使用AIDL来bindservice.因为这会使得结果更复杂。


首先我们看第一种方式;直接继承Binder,

例如一个场景一个app是用来音乐播放,它关联了一个activity。activity启用服务来后台播放音乐。


服务端:

<span style="font-size:14px;">public class LocalService extends Service {
    // Binder given to clients
    private final IBinder mBinder = new LocalBinder();
    // Random number generator
    private final Random mGenerator = new Random();

     //Class used for the client Binder.  Because we know this service always
     //runs in the same process as its clients, we don't need to deal with IPC.
    public class LocalBinder extends Binder {
        LocalService getService() {
            // Return this instance of LocalService so clients can call public methods
            return LocalService.this;
        }
    }

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

    //method for clients 
    public int getRandomNumber() {
      return mGenerator.nextInt(100);
    }
}</span>

客户端:

<span style="font-size:14px;">public class BindingActivity extends Activity {
    LocalService mService;
    boolean mBound = false;

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

    @Override
    protected void onStart() {
        super.onStart();
        // Bind to LocalService
        Intent intent = new Intent(this, LocalService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // Unbind from the service
        if (mBound) {
            unbindService(mConnection);
            mBound = false;
        }
    }

    //** Called when a button is clicked (the button in the layout file attaches to
    //  * this method with the android:onClick attribute) 
    public void onButtonClick(View v) {
        if (mBound) {
            // Call a method from the LocalService.
            // However, if this call were something that might hang, then this request should
            // occur in a separate thread to avoid slowing down the activity performance.
            int num = mService.getRandomNumber();
            Toast.makeText(this, "number: " + num, Toast.LENGTH_SHORT).show();
        }
    }

 // Defines callbacks for service binding, passed to bindService() 
    private ServiceConnection mConnection = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName className,
                IBinder service) {
            // We've bound to LocalService, cast the IBinder and get LocalService instance
            LocalBinder binder = (LocalBinder) service;
            mService = binder.getService();
            mBound = true;
        }

        @Override
        public void onServiceDisconnected(ComponentName arg0) {
            mBound = false;
        }
    };
}</span>


接下来我们看第二种方式;使用Messenger,

如果您只需要在 Activity 可见时与服务交互,则应在 onStart() 期间绑定,在 onStop() 期间取消绑定。

如果您希望 Activity 在后台停止运行状态下仍可接收响应,则可在 onCreate() 期间绑定,在 onDestroy() 期间取消绑定。请注意,这意味着您的 Activity 在其整个运行过程中(甚至包括后台运行期间)都需要使用服务,因此如果服务位于其他进程内,那么当您提高该进程的权重时,系统终止该进程的可能性会增加

下面是个完整的例子;客户端和服务端使用Messenger来通讯。

服务端:Server_Service

<span style="font-size:14px;">package com.example.administrator.service_messenger;

import android.app.Service;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.widget.Toast;

/**
 * 在manifest清单文件中声明service为另起新的进程。
 */
public class Server_Service extends Service {

    private Messenger clientMessenger;

    /**
     * 服务端的handler
     */
    class ServerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case Client.MSG_FROM_CLIENT:

                    String fromClient = msg.getData().getString("msgFromClient");
                    //收到来自客户端的信息
                    Toast.makeText(getApplicationContext(), fromClient, Toast.LENGTH_SHORT).show();

                    //回复一下客户端
                    Message msgFromServer = Message.obtain(null, Client.MSG_FROM_SERVER);
                    msgFromServer.arg1 =200;
                    try {
                        clientMessenger.send(msgFromServer);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                case Client.MSG_FROM_CLIENT_MESSE:  //得到客户端的信使对象
                    clientMessenger = msg.replyTo;
                    break;
            }
        }
    }

    /**
     * 服务端的Messenger,使用服务端的handler做参数构造。
     */
    final Messenger serverMessenger = new Messenger(new ServerHandler());

    /**
     * 我们在这里使用服务端的信使对象serverMessenger的IBinder,将其返回给客户端中的
     * serviceConntected
     */
    @Override
    public IBinder onBind(Intent intent) {
        Toast.makeText(getApplicationContext(), "客户端绑定服务端成功", Toast.LENGTH_SHORT).show();
        return serverMessenger.getBinder();
    }

    @Override
    public void unbindService(ServiceConnection conn) {
        super.unbindService(conn);
        Toast.makeText(getApplicationContext(), "客户端取消了服务绑定", Toast.LENGTH_SHORT).show();
    }
}
</span>
在manifest下配置:

<span style="font-size:14px;"><service android:name=".Server_Service"
            android:process=":v1"/></span>

客户端:Client
<span style="font-size:14px;">package com.example.administrator.service_messenger;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Toast;

import java.io.UnsupportedEncodingException;
import java.util.Calendar;

public class Client extends AppCompatActivity {

    public static final int MSG_FROM_CLIENT = 1;

    public static final int MSG_FROM_CLIENT_MESSE = 2;

    public static final int MSG_FROM_SERVER = 3;
    //在客户端里拿到了服务端的信使对象
    Messenger serverMessenger = null;

    //标记是否已经连上了服务端
    boolean mBound;

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

        //绑定服务
        findViewById(R.id.bt_bind).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                bindService();
            }
        });

        //通过服务端的信使来发信息给服务端
        findViewById(R.id.bt_send).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    sendInfoToServer();
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
            }
        });


        //手动解绑服务
        findViewById(R.id.bt_unbind).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                unBindService();
            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //在activity销毁时,可以选择取消绑定服务
        unBindService();
    }

    //客户端的handler
    private Handler clientHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_FROM_SERVER:
                    Toast.makeText(getApplicationContext(),  "server received :"+msg.arg1+"", Toast.LENGTH_SHORT).show();
                    break;

            }
        }
    };

    /**
     * 客户端的Messenger,使用客户的handler做参数构造。
     */
    final Messenger clientMessenger = new Messenger(clientHandler);

    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            //当我们连接上服务端后,会调用该方法。在方法里会回调给我们IBinder对象,
            //由于bindservice绑定服务后,服务端返回给客户端的IBinder是同一个。
            //所以这里我们可以利用IBinder来构建服务端里的信使对象。
            //之后有了服务端的信使对象,就可以随便网服务端发送信息了。

            //构建服务端信使对象
            serverMessenger = new Messenger(service);
            mBound = true;

            //并将客户端的messenger发给服务端,让服务端也可以给客户端发送消息
            Message msg = Message.obtain(null, MSG_FROM_CLIENT_MESSE);
            msg.replyTo = clientMessenger;
            try {
                serverMessenger.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        public void onServiceDisconnected(ComponentName className) {
            // 当连接服务端异常时调用
            serverMessenger = null;
            mBound = false;
        }
    };

    private void sendInfoToServer() throws UnsupportedEncodingException {
        if (!mBound) return;
        Message msg = Message.obtain(null, MSG_FROM_CLIENT, 0, 0);
        String strMsg = "server received:" + Calendar.getInstance().getTime();
        Bundle data = new Bundle();
        data.putString("msgFromClient", strMsg);
        msg.setData(data);
        try {
            serverMessenger.send(msg);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void onStart() {
        super.onStart();
        // 在界面可见时,可以选择去绑定服务
    }

    @Override
    protected void onStop() {
        super.onStop();
        // 在界面不可见时,可以选择去解绑服务
    }

    private void bindService() {
        bindService(new Intent(this, Server_Service.class), mConnection,
                Context.BIND_AUTO_CREATE);
    }

    private void unBindService() {
        if (mBound) {
            unbindService(mConnection);
            mBound = false;
        }
    }

}
</span>


最后我们来看第三种方式使用AIDL:







以上是关于android中Service使用详解的主要内容,如果未能解决你的问题,请参考以下文章

java [Intent] Intent片段以启动Activity,Service或发送广播。 #android_snippet #android

Android Service demo例子使用详解

Android 中的 Service 全面总结详解下

android service使用详解一

Android Service的分类详解

Android Service 流程分析