Android——服务

服务默默的在后台工作着，执行着不需要和用户交互的工作。

服务依赖于应用程序进程而存活

作为四大组件之一，服务具备共同的特点——需要在AndroidManifest中注册

Android多线程编程

 需要注意的是——一定不要在子线程中进行UI操作，否则会阻塞主线程出现异常

    /** 主要的逻辑是在这里完成，但是考虑到：服务默认是在主线程执行的，如果在这里进行比较费时的操作<br/>
     * 就容易出现ANR(Application Not Responding).<br/>
     * 所以标准的写法是在这里新建一个子线程执行逻辑处理<br/>
     * 但是：这样做了之后，必须要使用stopService或stopSelf才能停得下来
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d("test", "service onStartCommand");
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                // 逻辑处理——不能进行UI更新
                // ...
                // 这里处理完之后调用停止服务
                stopSelf();
                
            }
        }).start();
        return super.onStartCommand(intent, flags, startId);
    }

通过异步消息处理机制进行UI操作

在主线程定义一个handler

    public static final int SHOW_RESPONSE = 0;
    private Handler handler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case SHOW_RESPONSE:
                String response = (String) msg.obj;
                // 进行UI更新：根据子线程换回来的msg.obj的值和msg.what的值break;

            default:
                break;
            }
        }

    };

子线程通过handler发送数据

        new Thread(new Runnable() {

            @Override
            public void run() {try {
// 将获取到的数据交给Handler处理
                    Message msg = new Message();
                    msg.what = SHOW_RESPONSE;
                    msg.obj = 对象; 
                    handler.sendMessage(msg);
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    }
                }

            }
        }).start();

1.在主线程中创建Handler（处理者）对象，重写handMessage()方法，在该方法中进行UI操作

2.当子线程需要UI更新时，new一个Message（消息）对象，通过handler发送这个消息，包括.what,.obj等

3.消息会被发送到消息队列中，Looper（消息队列管家）会循环从队列中尝试取出消息，并转给handler

4.handler收到消息后，就会调用handMessage方法，进行UI更新操作

使用AsyncTask

主要方法

1.onPreExecute()，在execute(Params... params)被调用后立即执行，一般用来在执行后台任务前对UI做一些标记。

2.doInBackground(Params... params)，在onPreExecute()完成后立即执行，用于执行较为费时的操作，此方法将接收输入参数和返回计算结果。在执行过程中可以调用publishProgress(Progress... values)来更新进度信息。

3.onProgressUpdate(Progress... values)，在调用publishProgress(Progress... values)时，此方法被执行，直接将进度信息更新到UI组件上。

4.onPostExecute(Result result)，当后台操作结束时，此方法将会被调用，计算结果将做为参数传递到此方法中，直接将结果显示到UI组件上。

后续待看

：在doInBackground中进行耗时逻辑操作，在onProgressUpdate中进行UI操作

服务的基本用法

定义服务

public class MyService extends Service {

    @Override
    public IBinder onBind(Intent intent) {
        // 当活动与服务绑定的时候，这个方法就会被执行
        return null;
    }

    @Override
    public void onCreate() {
        // 主要初始化
        super.onCreate();
        Log.d("test", "service onCreate");
    }

    /** 主要的逻辑是在这里完成，但是考虑到：服务默认是在主线程执行的，如果在这里进行比较费时的操作，
     * 就容易出现ANR(Application Not Responding).<br/>
     * 所以标准的写法是在这里新建一个子线程执行逻辑处理<br/>
     * 但是：这样做了之后，必须要使用stopService或stopSelf才能停得下来
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d("test", "service onStartCommand");
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                // 逻辑处理
                // ...
                // 处理完之后调用停止服务
                stopSelf(); 
            }
        }).start();
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        // 摧毁前调用
        super.onDestroy();
        Log.d("test", "service onDestroy"); 
    }
    

}

开启服务——和活动很相似！！

            intent = new Intent(MainActivity.this, MyService.class);
            // 启动服务
            startService(intent);

停止服务

            intent = new Intent(MainActivity.this, MyService.class);
            // 暂停服务，也可用stopSelf()
            stopService(intent);

注册服务——在application中

<service android:name="com.example.servicetest.MyService"></service>

活动与服务的通信——Binder

通常要做到：活动要让服务干活了，说一下立马行动；活动要知道服务的活干的怎么样了，服务要能立马汇报

1.在服务中定义一个Binder对象，该对象具有干活的方法

2.在onBind方法中，将改对象返回

3.在活动中也定义一个该Binder对象，用于接收onBind返回的对象

4.活动中定义一个ServiceConnection对象，重写onServiceConnected，onServiceDisconnected方法，并在onServiceConnected中为Binder对象赋值

5.调用bindService(intent, conn, BIND_AUTO_CREATE)绑定，绑定之后，就可以通过binder对象干活了

package com.example.servicetest;

import com.example.servicetest.MyService.DownloadBinder;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;


public class MainActivity extends Activity implements OnClickListener{

    private Button startButton;
    private Button stoptButton;
    private Button bindButton;
    private Button unbindButton;
    private Button workButton;
    private Button progressButton;
    private Button intentServiceButton;
    private MyService.DownloadBinder downloadBinder = null;
    private  ServiceConnection conn = new ServiceConnection() {
        
        @Override
        public void onServiceDisconnected(ComponentName name) {
            // 连接意外丢失时
            
        }
        
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            // 连接成功时
            downloadBinder = (DownloadBinder) service;
            
        }
    };
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        startButton = (Button) findViewById(R.id.start);
        stoptButton = (Button) findViewById(R.id.stop);
        bindButton = (Button) findViewById(R.id.bind);
        unbindButton = (Button) findViewById(R.id.unbind);
        workButton = (Button) findViewById(R.id.start_work);
        progressButton = (Button) findViewById(R.id.re_progress);
        intentServiceButton = (Button) findViewById(R.id.start_intent_service);
        startButton.setOnClickListener(this);
        stoptButton.setOnClickListener(this);
        bindButton.setOnClickListener(this);
        unbindButton.setOnClickListener(this);
        workButton.setOnClickListener(this);
        progressButton.setOnClickListener(this);
        intentServiceButton.setOnClickListener(this);
        
    }

    @Override
    public void onClick(View v) {
        Intent intent;
        switch (v.getId()) {
        case R.id.start:
            intent = new Intent(this, MyService.class);
            // 启动服务
            startService(intent);
            break;
        case R.id.stop:
            intent = new Intent(this, MyService.class);
            // 暂停服务
            stopService(intent);
            break;
        case R.id.bind:
            intent = new Intent(this, MyService.class);
            // 绑定服务——BIND—_AUTO_CREATE标志位，表示活动与服务绑定后自动创建服务，调用服务的onCreate方法，但不调用onStartCommand
            bindService(intent, conn, BIND_AUTO_CREATE);
            break;
        case R.id.unbind:
            // 解除绑定服务
            unbindService(conn);
            break;
        case R.id.start_work:
            // 让服务开始干活——这里的判断条件还不明白
            if(downloadBinder!=null){
                downloadBinder.startDownload();
            }else {
                Toast.makeText(this, "ensure binded?", Toast.LENGTH_SHORT).show();
            }
            break;
        case R.id.re_progress:
            // 让服务汇报进度
            if(downloadBinder!=null){
                downloadBinder.getProgress();
            }else {
                Toast.makeText(this, "ensure binded?", Toast.LENGTH_SHORT).show();
            }
            break;
        case R.id.start_intent_service:
            // 让intentservice服务工作
            Log.d("test", "MainActivity Thread name："+Thread.currentThread().getName());
            Intent intent2 =new Intent(this, MyIntentService.class);
            startService(intent2);
            break;

        default:
            break;
        }
        
    }

}

package com.example.servicetest;


import android.app.Notification;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.support.v4.app.NotificationCompat;
import android.support.v4.app.NotificationCompat.Builder;
import android.util.Log;


public class MyService extends Service {
    private DownloadBinder mBinder = new DownloadBinder();
    class DownloadBinder extends Binder{
        public void startDownload(){
            Log.d("test", "startDownload is work  by DownloadBinder");
            
        }
        public int getProgress(){
            Log.d("test", "getProgress is work  by DownloadBinder");
            return 0;
        }
    }
    @Override
    public IBinder onBind(Intent intent) {
        // TODO Auto-generated method stub
        return mBinder;
    }

    @Override
    public void onCreate() {
        // 主要初始化
        // 这里创建一个前台服务：后台服务可能会因系统内存不足而回收，如果希望一直运行，可以考虑前台服务，类似通知
        super.onCreate();
        NotificationCompat.Builder mbuilder = new NotificationCompat.Builder(this);
        mbuilder
        .setTicker("this is ticker")
        .setWhen(System.currentTimeMillis())
        .setContentTitle("this is title")
        .setContentText("this is content")
        .setSmallIcon(R.drawable.ic_launcher)
        .setContentIntent(PendingIntent.getActivity(this, 0, new Intent(this, MainActivity.class), 0));
        
        Notification notification = mbuilder.build();
        startForeground(1, notification);// 将MyService变成一个前台服务!!
        Log.d("test", "service onCreate");
    }

    /** 主要的逻辑是在这里完成，但是考虑到：服务默认是在主线程执行的，如果在这里进行比较费时的操作，
     * 就容易出现ANR(Application Not Responding).<br/>
     * 所以标准的写法是在这里新建一个子线程执行逻辑处理<br/>
     * 但是：这样做了之后，必须要使用stopService或stopSelf才能停得下来
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d("test", "service onStartCommand");
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                // 逻辑处理
                // ...
                // 处理完之后调用停止服务
                stopSelf();
                // 但是如果再这里调用了停止服务的话，新的服务请求将得不到执行，因为服务将会停止
                
            }
        }).start();
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        // 摧毁前调用
        super.onDestroy();
        Log.d("test", "service onDestroy");
        
    }
    

}

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <Button
        android:id="@+id/start"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="start service" />

    <Button
        android:id="@+id/stop"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="stop service" />

    <Button
        android:id="@+id/bind"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Bind service" />

    <Button
        android:id="@+id/unbind"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Unbind service" />

    <Button
        android:id="@+id/start_work"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="let service do work!" />

    <Button
        android:id="@+id/re_progress"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="See the progress of service" />

    <Button
        android:id="@+id/start_intent_service"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="let IntentService go work" />

</LinearLayout>

注意：

MyService可以和应用程序内的任何活动进行绑定

服务的生命周期

当startService(...)时

onCreate()——只会执行一次，服务若已创建，则不再执行

onStartCommand()——startService一次就执行一次

当stopService()或stopSelf()时

onDestroy()会被执行

当binService()时

前台服务

 后台的服务可能会由于系统回收内存而kill掉，使用前台服务则不会，前台服务类似于通知一样，会在状态栏一直显示信息

 改变MyService的onCreate方法为：

    @Override
    public void onCreate() {
        // 主要初始化
        // 这里创建一个前台服务：后台服务可能会因系统内存不足而回收，如果希望一直运行，可以考虑前台服务，类似通知
        super.onCreate();
        NotificationCompat.Builder mbuilder = new NotificationCompat.Builder(this);
        mbuilder
        .setTicker("this is ticker")
        .setWhen(System.currentTimeMillis())
        .setContentTitle("this is title")
        .setContentText("this is content")
        .setSmallIcon(R.drawable.ic_launcher)
        .setContentIntent(PendingIntent.getActivity(this, 0, new Intent(this, MainActivity.class), 0));
        
        Notification notification = mbuilder.build();
        startForeground(1, notification);// 将MyService变成一个前台服务!!
        Log.d("test", "service onCreate");
    }

可以看到，只需要创建一个Notification对象，然后调用startForeground方法即可！简直不要和通知太像！！

IntentService

当需要服务执行一次任务之后就停止服务的时候——可以使用IntentService

当然，之前开起子线程的方法同样可用，只是需要在执行完之后添加一句stopSelf()

IntentService只不过是封装得比较好一点，仅此而已

定义一个服务类继承抽象类IntentService

package com.example.servicetest;

import android.app.IntentService;
import android.content.Intent;
import android.util.Log;

public class MyIntentService extends IntentService {

    /**
     * 无参构造函数，利用父类的有参构造函数
     */
    public MyIntentService() {
        super("MyIntentService");
    }

    /**
     * 异步处理逻辑，不用担心ANR的问题
     */
    @Override
    protected void onHandleIntent(Intent intent) {
        Log.d("test", "MyIntentService's onHandleIntent is executed");
        Log.d("test", "MyIntentService Thread name:"+Thread.currentThread().getName());
    }

    /**
     * 验证一下，当IntentService执行完毕之后会不会自动执行停止服务的操作
     */
    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d("test", "MyIntentService is sure stopped");
    }

开启这个服务，和开启普通服务并没有什么两样

        case R.id.start_intent_service:
            // 让intentservice服务工作
            Log.d("test", "MainActivity Thread name："+Thread.currentThread().getName());
            Intent intent2 =new Intent(this, MyIntentService.class);
            startService(intent2);
            break;

最佳实例——后台定时执行任务

      MainActivity——创建时，直接开启服务　

package com.example.servicebesttest;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;


public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent service = new Intent(this, LongRunningService.class);
        startService(service);
    }

}

　　

　　LongRunningService——输出当前时间，并通过Alarm机制定时开启广播接收器

package com.example.servicebesttest;

import java.text.SimpleDateFormat;
import java.util.Date;

import android.app.AlarmManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.os.IBinder;
import android.os.SystemClock;
import android.util.Log;

public class LongRunningService extends Service {

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

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 输出当前时间
        new Thread(new Runnable() {

            @Override
            public void run() {
                Log.d("test","executed at:"
                                + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            }
        }).start();
        // 定时打开广播接收器——10s一次
        AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
        /*
         * type还可以用RTC，RTC_WAKEUP，对应的触发时间应该使用System.currenTimetMillis()
         */
        // (int type, long triggerAtMillis, PendingIntent operation)
        int type = AlarmManager.ELAPSED_REALTIME_WAKEUP; // 从系统开机时累积的总时间
        long triggerAtMillis = SystemClock.elapsedRealtime() + 10 * 1000;
        Intent i = new Intent(this, ServiceReceiver.class);
        PendingIntent operation = PendingIntent.getBroadcast(this, 0, i, 0);

        // 通过set定时执行可能会延迟，4.4之后，因为手机会有省电设计，如果要准确无误，用setExact()
        alarmManager.set(type, triggerAtMillis, operation);

        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
    }

}

　　ServiceReceiver——激活就开启服务，从而达到循环执行

package com.example.servicebesttest;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;

public class ServiceReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        // 被激活则直接开启服务
        Intent service = new Intent(context, LongRunningService.class);
        context.startService(service);
    }

}

　　最后：服务需要注册，广播接收器需要注册

　　

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.servicebesttest"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="14"
        android:targetSdkVersion="19" />

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <service android:name="com.example.servicebesttest.LongRunningService" >
        </service>

        <receiver android:name="com.example.servicebesttest.ServiceReceiver" >
        </receiver>
    </application>

</manifest>