GL_BOOK_8

最新推荐文章于 2021-04-17 19:37:50 发布

慢慢_恢复

最新推荐文章于 2021-04-17 19:37:50 发布

阅读量803

点赞数

分类专栏：情感系列

本文链接：https://blog.csdn.net/three_trees_yuan/article/details/51690804

版权

情感系列专栏收录该内容

12 篇文章 0 订阅

订阅专栏

Chapter 9

AsyncTask<Params, Progress, Result>()

new AsyncTask<Void, Integer, Boolean>() {

            @Override
            protected Boolean doInBackground(Void... params) {
                Log.i("haha","doInBackground");
                publishProgress(50);
                return null;
            }
            @Override
            protected void onProgressUpdate(Integer... values) {
                Log.i("haha","onProgressUpdate");
                Log.i("haha", ""+values[0]);
                super.onProgressUpdate(values);
            }
            @Override
            protected void onPreExecute() {
                Log.i("haha","onPreExecute");
                super.onPreExecute();
            }
            @Override
            protected void onPostExecute(Boolean result) {
                super.onPostExecute(result);
                Log.i("haha","onPostExecute");
            }

        }.execute();

当后台任务中调用了 publishProgress 方法，onProgressUpdate 就会很快被调用

服务Service

onCreate onStartCommand
startService 时服务未从创建过第一次创建时调用 onCreate onStartCommand ，之后多次调用startService , 只有 onStartCommand 得以执行
context.stopService 或者在service内部调用 stopSelf方法

活动和服务的关联

public class LhyService extends Service {

    MyBinder mBinder = new MyBinder();

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }
    @Override
    public void onCreate() {
        super.onCreate();
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }

    class MyBinder extends Binder{
        public void startToDo(){
            Log.i("haha", "startToDo");
        };
        public void stopToDo(){
            Log.i("haha", "stopToDo");
        };
    }

}

ServiceConnection conn=  new ServiceConnection() {

        @Override
        public void onServiceDisconnected(ComponentName name) {

            Log.i("haha", "ComponentName : "+name);
            Log.i("haha", "onServiceDisconnected");

        }

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            LhyService.MyBinder myBinder = (MyBinder) service;
            myBinder.startToDo();
        }
    };

bindService(serviceIntent, conn, BIND_AUTO_CREATE);
unbindService(conn);

任何一个服务在应用程序范围内都是通用的可以和多个活动 activity进行绑定绑定完成后都可以获得相同的Binder实例
每个服务只存在于一个实例所以不管调用了多少次 startService 方法，只要调用一次 stopService 或 stopSelf 方法服务就会停下来

通过调用 bindService 来获取一个服务的持久连接会调用onBind方法如果服务还没有被创建 onCreate 方法会先于onBind方法执行然后再执行 onBind方法
只要调用方和服务之间的连接没有断开服务就会一直保持运行状态

如果一个活动既调用 startService 方法又调用了 bindService 方法如何destroy掉这个服务呢
根据Android系统的机制一个服务只要被启动或者被绑定之后，就会一直处于运行状态，必须要让以上两种条件同时不满足才可以销毁服务，也就是说要同时调用 stopService 和 unbindService 方法，onDestroy 方法才可以被执行

服务的系统优先级

基本后台运行
内存不足的时候有可能被回收
前台服务和普通服务最大区别在于会一直有一个正在运行的图标在系统状态栏显示下拉状态栏会看到更加详细的信息，非常类似通知的效果

创建前台服务

    public void onCreate() {
        super.onCreate();
        NotificationCompat.Builder mBuilder = new Builder(this);
        mBuilder.setSmallIcon(R.drawable.ic_launcher);
        mBuilder.setTicker("foreground service start");
        mBuilder.setContentTitle("foreground service title");
        mBuilder.setContentText("foreground service content");
        Intent intent = new Intent(this,MainActivity.class);
        PendingIntent pi = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
        mBuilder.setContentIntent(pi);
        startForeground(1, mBuilder.build());

    }

就是把通知的 notify方法换为 startForeground方法在onCreate方法里

服务中的代码默认是在主线程中的 ANR 多线程

@Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        new Thread(new Runnable() {

            @Override
            public void run() {
                //TODO 

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

android 提供了一个可以创建一个异步的、会自动停止的服务 IntentService 类
onHandleIntent方法是在子线程中的

public class YssService extends IntentService {

    public YssService(String name) {
        super(name);
    }
    public YssService() {
        super("YssService");
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        Log.i("haha", "ThreadId : "+Thread.currentThread().getId());
    }
    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.i("haha", "onDestroy");
    }
}

后台执行的定时任务
两种方法一种是 Java 的 Timer 类
一种是 Android 的 Alarm 机制

Timer 有一个明显的短板不太适用于那些需要长期在后台运行的定时任务
因为为了让电池耐用 android 手机的休眠策略是长时间不操作的情况自动让 CPU 自动进入睡眠状态，这就有可能导致 Timer 中的定时任务无法正常运行。而Alarm机制则不存在这种情况。Alarm具有唤醒CUP的功能

Alarm 机制的用法：

@Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        new Thread(new Runnable() {

            @Override
            public void run() {
                //异步执行的逻辑功能
                Log.i("haha", "the service executed at "+new Date().toString());
            }
        }).start();

        AlarmManager manager = (AlarmManager) this.getSystemService(ALARM_SERVICE);
        int halfMinute = 30*1000;
//      long triggerAtTime = SystemClock.elapsedRealtime()+halfMinute;
        long triggerAtTime = System.currentTimeMillis()+halfMinute;

        Intent i = new Intent(this,AlarmReceiver.class);
        PendingIntent pi  = PendingIntent.getBroadcast(this, 0, i, 0);

//      manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, pi);
        manager.set(AlarmManager.RTC_WAKEUP, triggerAtTime, pi);
        //      manager.setExact(type, triggerAtMillis, operation);
        return super.onStartCommand(intent, flags, startId);
    }

public class AlarmReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        context.startService(new Intent(context, LongRunService.class));
    }

}