Android 四大组件 Service 服务

标签：

1.Service简介

按照使用范围分类：

按运行类型分类：

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

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

public class demo1 extends AppCompatActivity {

    private Button start;
    private Button stop;

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

        start = (Button) findViewById(R.id.start_Service1);
        stop = (Button) findViewById(R.id.stop_Service1);

        //1.创建启动Service的Intent
        final Intent intent = new Intent(demo1.this, service1.class);

        start.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //2.启动service
                startService(intent);
            }
        });
        stop.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //3.停止service
                stopService(intent);
            }
        });

    }
}

public class service1 extends Service {
    private final String TAG = "service1";

    //Service被创建时调用
    @Override
    public void onCreate() {
        super.onCreate();
        Log.i(TAG, "onCreate方法被调用");
    }

    //必须要实现的方法
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.i(TAG, "onCreate方法被调用");
        return null;
    }

    //Service被启动时调用
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i(TAG, "onStartCommand方法被调用！");
        return super.onStartCommand(intent, flags, startId);
    }

    //Service被关闭之前回调
    @Override
    public void onDestroy() {
        Log.i(TAG, "onDestroy方法被调用！");
        super.onDestroy();
    }
}

AndroidManifest.xml：

<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

public class demo2 extends AppCompatActivity {

    private Button bind;
    private Button cancel;
    private Intent intent;
    private service2 service2;
    private service2.myBinder myBinder;
    private ServiceConnection conn = new myServiceConnection();
    private boolean mBound;

    //保持所启动的service2的IBinder对象，同时定义一个ServiceConnection对象。
    private class myServiceConnection implements ServiceConnection {

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            System.out.println("----Service Connected----");
            myBinder = (com.guofeng.demo4.Service.service2.myBinder) service;
            service2 = myBinder.getgetService();
            mBound = true;
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            System.out.println("----Service DisConnected----");
            mBound = false;

        }
    }


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.demo2);
        bind = (Button) findViewById(R.id.bind_service2);
        cancel = (Button) findViewById(R.id.cancel_service2);
        intent = new Intent(demo2.this, service2.class);

        bind.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                bindService(intent, conn, BIND_AUTO_CREATE);

            }
        });

        cancel.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                excuteUnbindService();
            }
        });


    }

    private void excuteUnbindService() {
        if (mBound) {
            unbindService(conn);
            mBound = false;
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        excuteUnbindService();
    }
}

public class service2 extends Service {

    private final String TAG = "Service2";
    private myBinder binder = new myBinder();
    public class myBinder extends Binder {
        service2 getgetService() {
            return service2.this;
        }
    }

    @Override
    public void onCreate() {
        Log.i(TAG, "onCreate方法被调用");
        super.onCreate();
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.i(TAG, "onBind方法被调用");
        return binder;
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.i(TAG, "onUnbind方法被调用");
        return super.onUnbind(intent);
    }

    @Override
    public void onRebind(Intent intent) {
        Log.i(TAG, "onRebind方法被调用");
        super.onRebind(intent);
    }

    @Override
    public void onDestroy() {
        Log.i(TAG, "onDestroy方法被调用");
        super.onDestroy();
    }
}

注意：

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

public class demo3 extends AppCompatActivity {
    private Context mContext;

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

        mContext = this;
        Button btn = (Button) findViewById(R.id.btn3);
        assert btn != null;
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent1 = new Intent(mContext, service3.class);
                Bundle bundle1 = new Bundle();
                bundle1.putString("param", "s1");
                intent1.putExtras(bundle1);

                Intent intent2 = new Intent(mContext, service3.class);
                Bundle bundle2 = new Bundle();
                bundle2.putString("param", "s2");
                intent2.putExtras(bundle2);

                Intent intent3 = new Intent(mContext, service3.class);
                Bundle bundle3 = new Bundle();
                bundle3.putString("param", "s3");
                intent3.putExtras(bundle3);

                //接着启动多次IntentService，每次启动，都会创建一个新工作线程
                //但是始终只有一个IntentService实例
                startService(intent1);
                startService(intent2);
                startService(intent3);
            }
        });
    }
}

public class service3 extends IntentService {
    private final String TAG = "IntentService:";

    //必须实现父类的构造方法
    public service3() {
        super("guofeng");
    }

    public service3(String name) {
        super(name);
    }

    //必须重写的核心方法
    @Override
    protected void onHandleIntent(Intent intent) {
        String str = intent.getExtras().getString("param");
        if (str.equals("s1"))
            Log.i(TAG, "启动service1");
        else if (str.equals("s2"))
            Log.i(TAG, "启动service2");
        else if (str.equals("s3"))
            Log.i(TAG, "启动service3");

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    //重写其他方法，用于查看方法的调用顺序
    @Override
    public void onCreate() {
        Log.i(TAG, "onCreate");
        super.onCreate();
    }

    @Override
    public IBinder onBind(Intent intent) {
        Log.i(TAG, "onBind");
        return super.onBind(intent);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i(TAG, "onStartCommand");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void setIntentRedelivery(boolean enabled) {
        Log.i(TAG, "setIntentRedelivery");
        super.setIntentRedelivery(enabled);
    }

    @Override
    public void onDestroy() {
        Log.i(TAG, "onDestroy");
        super.onDestroy();
    }
}

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

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

<span style="font-size:18px;">public class service4 extends Service {
    public static final String TAG = "Service4";

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

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

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i(TAG, "onStartCommand");

        PendingIntent pi = PendingIntent.getActivity(
                this,
                0,
                new Intent(this, demo3.class),
                PendingIntent.FLAG_CANCEL_CURRENT
        );
        //NotificationManager nm = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
        Notification.Builder myBuilder = new Notification.Builder(this);
        myBuilder.setContentTitle("QQ")
                .setContentText("呵呵")
                .setSmallIcon(R.mipmap.ic_launcher)
                .setContentIntent(pi);
        Notification notification = myBuilder.build();
        //nm.notify(1, notification);
        //注意使用startForeground,id为0将不会显示notification
        startForeground(1, notification);
        return START_REDELIVER_INTENT;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.i(TAG, "onDestroy");
    }
}
</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 四大组件 Service 服务

标签：

原文地址：http://blog.csdn.net/plain_maple/article/details/52577816