Service

最新推荐文章于 2024-05-02 18:50:32 发布

转载最新推荐文章于 2024-05-02 18:50:32 发布 · 56 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/chhom/p/4717832.html

本文详细介绍了Android服务的概念、分类、启动方式及其生命周期，并对比了服务与Activity、线程的区别。此外，还深入探讨了IntentService的特性及使用场景，并通过实例展示了如何实现服务的绑定与解绑。

一、

1、概念：Android的四大组件之一，是一个没有用户界面长期在后台运行执行“耗时操作”的应用组件

2、服务与Activity的区别：

相同点：都是四大组件，需要在清单文件中注册，都运行在主线程，都有生命周期

        <service
            android:name=".service.MyService"
            android:enabled="true"
            android:exported="true" />

不同点：Activity有界面，Service没有界面，Activity运行在前台与用户进行交互，Service运行在后台。

3、服务与线程的区别：

Thread：是程序执行的最小单元，他是分配CPU的基本单位，可以做一些耗时操作（异步任务）

Service更多的时候充当线程管理者的角色。

4、服务的分类

运行的位置：本地服务（Local Service）、远程服务remote

启动方式：startService和BindService

5、启动的特点：

startService：服务一旦被启动就与启动他的组件失去了关系。

bindService：与启动他的组件绑在一起（同进退。共生死）

6、服务只能被解绑一次，多次解绑会抛出异常。

二、服务的生命周期

1、startService

onCreate -->onStartConmmand(可以执行多次) -->onDestroy(stopService,stopSelf)

开启服务startService：onCreate，onStartCommand

返回键：没有变化，在后台运行

多次点击开启服务：onStartCommand

结束服务stopService：onDestroy；还有一种自杀stopSelf

2、bindService

onCreate-->onbind-->onUnbind-->ondestroy

        <service
            android:name=".service.MyService"
            android:enabled="true"
            android:exported="true" />

        //启动一个服务
        btnStart.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(MainActivity.this, MyService.class);
                intent.putExtra("info", "ssssssssssss");
                startService(intent);
            }
        });
        //停止一个服务
        butStop.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(MainActivity.this, MyService.class);
                stopService(intent);
            }
        });

/**
 * started service:
 * 1.服务同时只会被创建一次，可以通过外部调用stopService或调用stopSelf来终止服务
 * 2.当执行一个已启动的服务，会直接调用onStartCommand方法来执行业务
 * 3.默认情况下服务与主线程在同一个进程中的同一个线程中运行，如果服务执行一个比较耗时的操作，我们必须使子线程来完成工作，避免主线程被阻塞
 * 4.使用started Service启动的一个服务，在没有关闭之前会一直在后台运行
 */
public class MyService extends Service {
    public MyService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        // TODO: Return the communication channel to the service.
        throw new UnsupportedOperationException("Not yet implemented");
    }

    @Override
    public void onCreate() {
        super.onCreate();
        System.out.println("!!!my service create");
    }


    //在该方法中实现服务的核心业务
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {

        System.out.println("!!!!!!" + intent.getStringExtra("info"));


        //这个阻塞主线程
//        for (int i = 0; i < 10; i++) {
//            System.out.println("!!!" + "onStartCommand" +i+Thread.currentThread().getName());
//            try {
//                Thread.sleep(500);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//
////            if (i == 5) {
////                this.stopSelf();//终止服务
////                break;
////            }
//        }

        //使用线程完成长时间的工作
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    System.out.println("!!!" + "onStartCommand" + i + Thread.currentThread().getName());
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    if (i == 10) {
                        MyService.this.stopSelf();//终止服务
                        break;
                    }
                }
            }
        }).start();

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

    @Override
    public void onDestroy() {
        super.onDestroy();
        System.out.println("!!!my service destroy");
    }
}

三、IntentService

是Service的子类

特点：

1、其他组件调用startService启动IntentService服务时，会依次执行onCreate-->onStartCommand-->onHandleIntent-->onDestroy,说明IntetnService在onHandleIntent方法中处理完成意图对象后会销毁服务

2、IntentService底层采用请求队列对Intent请求意图对象进行管理

        <service
            android:name=".service.MyIntentService"
            android:exported="false" />

//启动一个IntentService服务
        btnStartIntent.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(MainActivity.this, MyIntentService.class);
                startService(intent);
            }
        });

/**
 * IntentService:
 * 1.内部有一个工作线程来完成耗时操作，只需实现onHandleIntent方法即可
 * 2.完成工作后会自动停止服务
 * 3.如果同时执行多个任务时，会以队列的方式，依次执行
 * 4.通常使用该类来完成本APP中的耗时工作
 */
public class MyIntentService extends IntentService {

    public MyIntentService() {
        super("MyIntentService");
    }

    @Override
    protected void onHandleIntent(Intent intent) {

        for (int i = 0; i < 30; i++) {
            System.out.println("!!!" + i + Thread.currentThread().getName());
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

}

绑定一个Service

        //绑定一个服务
        btnBind.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(MainActivity.this, MyBindService.class);
                //异步绑定,绑定成功会回调onServiceConnected
                bindService(intent, connection, Context.BIND_AUTO_CREATE);
            }
        });

        //绑定服务的连接回调
        connection = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName componentName, IBinder iBinder) {

                //绑定成功后的回调方法
                iCat = ICat.Stub.asInterface(iBinder);
                mBound = true;
            }

            @Override
            public void onServiceDisconnected(ComponentName componentName) {

                //服务异常时回调
                mBound = false;
            }
        };

        //通过IPC调用业务方法
        btnCallClick.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if (iCat == null) {
                    return;
                }
                try {
                    iCat.setName("小猫");
                    Toast.makeText(MainActivity.this, iCat.desc().toString(), Toast.LENGTH_SHORT).show();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        //解绑一个服务
        btnUnbind.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if (mBound) {
                    unbindService(connection);
                }
            }
        });

/**
 *绑定服务：
 * 通过绑定服务实现功能的步骤：
 * 1、客户端通过bindService方法来绑定一个服务对象，如果绑定成功，会回调ServiceConnection接口方法onServiceConnected
 * 2、通过Service组件来暴露业务接口
 * 3、服务端通过创建一个*.aidl文件来定义一个可以被客户端调用的业务接口
 *   一个aidl文件：
 *   （1）不能有修饰符，类似接口写法
 *   （2）支持类型有：8中基本数据类型，String，CharSequeue，List<String> map，自定义类型
 * 4、服务端需要提供一个业务接口的实现类，通过我么会继承Stub类
 * 5、通过Service的onBind方法返回被绑定的业务对象
 * 6、客户端如果绑定成功，就可以像调用自己的方法一样调用远程的方法
 */

public class MyBindService extends Service{

    public MyBindService() {
        super();
    }

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

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

    @Override
    public boolean onUnbind(Intent intent) {
        return super.onUnbind(intent);
    }

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

interface ICat {

    void setName(String name);
    String desc();
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);
}

public class CatImpl extends ICat.Stub {
    private String name;

    @Override
    public void setName(String name) throws RemoteException {
        this.name = name;
    }

    @Override
    public String desc() throws RemoteException {
        return "hello ,my name is " + name;
    }

    @Override
    public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {

    }
}

2.Android多线程编程

2.1.线程的基本用法：

匿名类的方式定义和实现一个线程：

new Thread(new Runnable(){

@Override

public void run(){

//处理具体逻辑

}

}).start();

2.2在子线程中更新UI

public class MainActivity extends Activity implements OnClickListener{
    public static final int UPDATE_TEXT=1
    //先定义一个UPDATE_TEXT，用于表示更新TextView这个动作
    private TextView text;
    private Buuton changeText;
    private Handler handler=new Handler(){

        //新增一个handler对象，并重写父类的handleMessage方法，在这里对具体的Message进行处理
        public void handleMessage(Message msg){
            switch(msg.what){
                case UPDATE_TEXT:
                //在这里进行UI操作
                //如果发现Message的what字段值等于UPDATE_TEXT，就将TextView显示的内容改成nice
                text.setText("nice");
                break;
            }
        }
    };

    @Override

    public void onClick(View v){
        switch(v.getId){
            case R.id.change_text:
            new Thread(new Runnable(){
                @Override
                public void run(){
                    Message message=new Message();
                    message.what=UPDATE_TEXT;
                    handler.sendMessage(message);//将Message对象发送出去
                }
            });
            break;
        default:
            break;
        }
    }
}