Android Day08四大组件之服务Service

  1. 云栖社区>
  2. 博客>
  3. 正文

Android Day08四大组件之服务Service

技术小胖子 2017-11-07 22:22:00 浏览911
展开阅读全文

拓展:

  Android之Service与IntentService的比较

       http://blog.csdn.net/smile3670/article/details/7702521

       

Java并发编程:volatile关键字解析

http://www.cnblogs.com/dolphin0520/p/3920373.html


java中volatile关键字的含义

http://www.cnblogs.com/aigongsi/archive/2012/04/01/2429166.html



保证服务不被杀死:

http://blog.csdn.net/mad1989/article/details/22492519    (提高优先级,服务死掉的时候发送广播,重启服务)


    

1.什么是服务

  就把服务理解为在后台长期运行但是没有界面的Activity,因为Service与Activity有很多相似的地方。

   1)启动一个activity或service都要通过Intent

   2) 如果想打开一个activity/service,按是否返回数据,需要采用不同的方法。

  ■服务的作用

    让某些逻辑在后台(长期)执行。

    服务可以结合广播接收者碰撞出各种效果(看你的想像力了!)


2.进程


    1. Foreground process 前台进程  相当于Activity执行了onResume方法 用户正在操作页面 前台进程的优先级最高

    2. Visible process 可视进程 相当于Activity执行了onPasue方法  用户依然能看的见屏幕

    3. Service process 服务进程 相当于通过startservice方式开启了一个服务 在当前进程里面运行

    4. Background process 后台进程  相当于Activity执行了onStop方法  用户看不见页面 但是注意Activity没有执行ondestroy方法 

    5. Empty process 空进程 后台没有任何组件运行 这个时候属于空进程 


3.服务的创建和开启

  ■服务的创建:

    定义一个类继承Service,在清单文件里注册这个类,<service>标签。

     

  ■服务的开启:

     服务的开启属于Context里的方法,所以继承了Context的类Activity、Service或者是拥有Context对象的类

   都可以开启一个服务(如广播接收者的onReceive方法里有Context对象,所以广播接收者也可以开启一个服务)

   开启服务的方式有2种:startService和bindService。
     不同的方式开启的服务,作用不同,服务的生命周期不同,服务需要复写的方法也不同,掌握

   这两种开启服务的方式区别十分地重要。(********重点*********

    如果想要服务长期运行,就用startService方法;如果想调用服务里的方法,就用bindService

   方法来开启服务。

    不同方式开启服务的生命周期图:

     wKiom1XEfU7ybdFiAAG6ul7igOM360.jpg 

     1)startService方式开启服务

        当用户第一次调用start-service方法 服务会执行onCreate、onStartCommand、onStart方法 

        当用户第二次调用start-service方法 服务只会走onStartCommand、onStart方法 

        服务一旦通过start-service方法开启后 服务就会在后台长期运行 直到用户手工停止或调用

           stopService方法停止,或者服务调用自身的stopSelf()方法。如下图,手动关闭service:

        wKioL1XEgZrzl73TAAD-4V3iLCw614.jpg

       start开启服务代码

1
2
3
            //启动服务
                Intent intent = new Intent(this,CallService.class);
                startService(intent);

    

     

     2)bindService方式开启服务   

    第一次点击按钮 通过bindservice开启服务 服务只会走 onCreate 和 onbind方法

    第二次点击按钮 通过bindservice开启服务  服务没有反应 

    不求同时生 但求同时死  只的是Activity和服务之间,Activity一挂掉,bind方式开启的服务也会

      随之挂掉

    服务只能解绑一次 多次解绑会报异常 

    通过bindservice方式开启服务 在设置页面找不到 他可以理解成是一个隐形的服务  

    当服务的onbind方法返回null的时候onServiceConnected方法不执行 

      

    ▇bindservice方式调用服务方法里面的流程(**********重点**********

        (1)定义一个服务 在清单文件里面配置  在服务里面定义一个方法  

        (2)Activity想调用服务里面的方法 

        (3)在服务的内部定义一个中间人对象(IBinder) 在这个实现类里面可以间接的调用到服务里面的

           方法

        (4)在onbind方法中把我们自己定义的这个中间人对象返回 

        (5)当Activity想调用服务里面方法的时候  先通过bindservice方法获取中间人对象 

        (6)通过我们获取的中间人对象就可以间接调用到服务里面的方法了 

        
         一般写在"中间人"对象(IBinder)里的方法,都是实现接口里的方法,再在方法里调用服

       务里定义的方法。

     ■绑定服务抽取接口

        接口可以隐藏代码内部的细节 让程序员暴露只想暴露的方法

        实现步骤

        (1)定义一个接口 把服务里面想暴露方法都定义在接口里  

        (2)我们定义的这个中间人对象实现我们定义的这个接口 

        (3)还是通过bindservice方式获取我们中间人的对象

        (4)还是通过中间人对象间接调用服务里面的方法

 

4.应用1_电话窃听器案例(startService开启服务方式)

    需求:手机一接听电话就把通话进行录音,保存起来。

    实现思路:电话窃听,肯定不希望用户看到,所以不需要界面,那么窃听录音的逻辑应写在服务里。服务有了,

          需要被开启,为了显得应用更智能一些,就定义一个广播接收者来接收开机广播来开启服务了。

    具体实现步骤:

    1)定义电话窃听录音逻辑的服务类

     创建服务类之后,按照好的编程习惯,立马在清单里配置service标签。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
public class CallService extends Service {
    private MediaRecorder recorder = null;
    @Override
    public IBinder onBind(Intent arg0) {
        return null;
    }
 
    @Override
    public void onCreate() {
        super.onCreate();
        //创建一个TelephonyManager对象
        //注意要强转
        TelephonyManager manager = (TelephonyManager) this.getSystemService(this.TELEPHONY_SERVICE);
         
        //通过TelephonyManager来获取通话的状态?????????????????????/
        manager.listen(new MyPoneListener(), PhoneStateListener.LISTEN_CALL_STATE);   //注意常量是PhoneStateListener的常量。
    }
     
     
    //定义一个类继承PhoneListener
    private class MyPoneListener extends PhoneStateListener{
         
         
        //复写它的一个监听通话状态的方法
        @Override
        public void onCallStateChanged(int state, String incomingNumber) {
            //判断状态
            /*int  CALL_STATE_IDLE    Device call state: No activity.
            int    CALL_STATE_OFFHOOK     Device call state: Off-hook.
            int    CALL_STATE_RINGING     Device call state: Ringing.*/
             
            //代表空闲状态
            if(state == TelephonyManager.CALL_STATE_IDLE)
            {
                System.out.println("结束录音");
                if(recorder != null)
                {
                     recorder.stop();
                     recorder.reset();   // You can reuse the object by going back to setAudioSource() step
                     recorder.release(); // Now the object cannot be reused
                }
            }
            //接听状态
            else if(state == TelephonyManager.CALL_STATE_OFFHOOK)
            {
                System.out.println("开始录音");
                if(recorder != null)
                {
                    recorder.start();   // Recording is now started
                }
            }
            //响铃状态
            if(state == TelephonyManager.CALL_STATE_RINGING)
            {
                System.out.println("准备录音,创建录音机。");
                recorder = new MediaRecorder();
                //设置录音录制的是双方的还是单方的。
                recorder.setAudioSource(MediaRecorder.AudioSource.MIC);
                //设置录音的保存格式3GP
                recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
                //设置录音的编码方式
                 recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
                //设置录音的保存位置 
                 recorder.setOutputFile("/mnt/sdcard/record.mp3");
                 try {
                //准备录音 
                    recorder.prepare();
                catch (Exception e) {
                    e.printStackTrace();
                }
            }
 
        }
    }
}

    2)定义广播接收者来启动服务

    创建广播接收者之后,按照好的编程习惯,立马在清单里配置receiver标签,并配置好过滤器过滤开机广播。

1
2
3
4
5
6
7
8
9
10
public class BootReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        //当手机重启后 开启服务 
         
        Intent intent1 = new Intent(context,CallService.class);
        context.startService(intent1);
         
    }
}

    

    3)添加权限 

    像什么配置组件,添加权限能提前完成的东西就提前完成。

1
2
3
4
5
6
7
8
9
10
11
     <!-- 读取电话状态权限  -->
        <uses-permission android:name="android.permission.READ_PHONE_STATE"/>
     
     <!-- 录音权限 -->
        <uses-permission android:name="android.permission.RECORD_AUDIO"/>
     
     <!-- SD卡读写权限 -->
        <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
  
     <!-- 开机启动监听 -->
        <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>

     

5.应用2_百度音乐盒案例(start/bind混合开启服务方式)    

    需求:在activity里定义播放、暂停、继续3个功能按钮,效果如下图所示:

   wKioL1XEmrDw3NKVAABGX6t4dp0131.jpg   

    实现思路:一般音乐播放软件,在界面销毁之后,音乐还能继续在长期运行播放,所以音乐播放的逻辑应该写在服

        务里,用startService方式开启服务;点击按钮还要调用服务里的方法,那么又要用bindService方

        式开启服务。所以要以混合模式开启服务。

    具体实现步骤:

    1)服务相应接口定义

1
2
3
4
5
6
     //定义一个接口来暴露想暴露的方法        
        public interface Iservice {
            public abstract void callPlay();
            public abstract void callPause();
            public abstract void callRePlay();
        }

   2)服务定义  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
      package com.itheima.baidumusic;
 
        import java.io.IOException;
         
        import android.app.Service;
        import android.content.Intent;
        import android.media.MediaPlayer;
        import android.net.Uri;
        import android.os.Binder;
        import android.os.IBinder;
         
        /**
         * 播放音乐的 Service 逻辑写在Service里,通过中间人对象返回。
         
         * 模板步骤: 1.写一个类继承Binder,也就是IBinder(接口)的子类 ,并实现接口,暴露想暴露的方法。 2.返回这个类的对象 。
         
         * @author LENOVO
         
         */
        public class PlayService extends Service {
            private MediaPlayer musicPlayer = null;
         
            @Override
            public IBinder onBind(Intent intent) {
                System.out.println("onBind方法执行了。。。。。。");
                musicPlayer = new MediaPlayer();
                try {
                    musicPlayer.setDataSource("/mnt/sdcard/luanhong.mp3");
                catch (Exception e) {
                    e.printStackTrace();
                }
                return new MyBinder();
            }
         
            // 定义播放音乐的方法
            public void play() {
                System.out.println("播放音乐");
                try {
                    musicPlayer.prepare();
                catch (Exception e) {
                    e.printStackTrace();
                }
                musicPlayer.start();
            }
         
            // 定义暂停音乐的方法
            public void pause() {
                System.out.println("暂停播放");
                musicPlayer.pause();
            }
         
            // 定义继续音乐的方法
            public void rePlay() {
                System.out.println("继续播放");
                musicPlayer.start();
            }
         
            // 定义一个Binder的子类对象<中间人对象>
            public class MyBinder extends Binder implements Iservice {
                @Override
                public void callPlay() {
                    play();
                }
         
                @Override
                public void callPause() {
                    pause();
                }
         
                @Override
                public void callRePlay() {
                    rePlay();
                }
         
            }
        }

   3)Activity里启动服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
      public class MainActivity extends Activity {
    // 定义与服务的连接
    private MyConn conn = null;
 
    // 自定义那个类才会具有独有的播放音乐的功能,直接声明那个类实现的接口,属于多态。
    private Iservice serviceBinder = null;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        // 1.通过startService方法开启服务 为了让音乐盒可以长期的运行,即按下回退键服务不会随之一起销毁。
        Intent intent = new Intent(this, PlayService.class);
        startService(intent);
 
        conn = new MyConn();
        // 2.通过bindService方法开启服务 为了调用服务里的方法
        bindService(intent, conn, BIND_AUTO_CREATE);
 
        // 3.在activity里的onDestroy方法里注销绑定服务。
    }
 
    // 定义一个类实现ServiceConnection接口
    private class MyConn implements ServiceConnection {
 
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            // 注意要最终是要用Iservice的特有方法,所以要强转成Iservice.
            System.out.println("绑定服务成功");
            serviceBinder = (Iservice) service;
        }
 
        @Override
        public void onServiceDisconnected(ComponentName name) {
            System.out.println("绑定服务失败");
        }
 
    }
 
    // 实现点击按钮的方法
    public void click(View v) {
        switch (v.getId()) {
        case R.id.bt_play:
            serviceBinder.callPlay();
            break;
        case R.id.bt_pause:
            serviceBinder.callPause();
            break;
        case R.id.bt_rePlay:
            serviceBinder.callRePlay();
            break;
 
        default:
            break;
        }
    }
 
    // 在activity里的onDestroy方法里注销绑定服务
    @Override
    protected void onDestroy() {
        // 解除绑定服务
        unbindService(conn);
        super.onDestroy();
    }
 
}

      

6.AIDL

Android Interface Definition Language  Android接口定义语言

本地服务:  运行在自己应用(Android)里面的服务

远程服务 : 运行在其他应用(Android)里面的服务

作用:  想解决的问题就是进程间通信,也就是调用其它进程里的服务里的方法。


  AIDL 实现的步骤 

    (1) 在一个应用里面定义一个服务 服务里面有一个方法 这个方法称为远程服务里面的方法

    (2)在这个服务里面定义中间人对象  定义接口iservice.java 把想暴露的方法定义在接口里

    (3)把iservice.java文件改成 aidl文件  注意aidl不支持public、abstract等修饰符

    (4)系统会自动给我们生产一个iservice.java文件 stub extends IBinder imp iservie接口 

    (5)把我们定义的中间人对象直接继承Stub

    (6)我想在另外一个应用里面去调用这个服务里面的方法 要保证2个应用使用的是同一个aidl文件

    (7)如何保证2 个应用使用的是同一个aidl文件谷歌要求   包名相同 

    (8)还是通过bindservice 方式去获取到中间人对象 

    (9)注意获取我们定义的中间人对象的方式不一样了,在服务连接对象ServiceConnection里的onServiceConnected方法里通过

                    stub 的一个静态方法去获取我们定义的中间人对象 Stub.asinterface(Ibinder obj);

    
AIDL的应用场景:支付宝


▼用AIDL模拟调用支付宝服务里的服务方法:   

   第1步:  建立两个应用

    wKioL1XEuazy6cVpAABA6jCswRM335.jpg  

  第2步:  模拟支付宝服务(实际上支付宝是很复杂的)  

    先定义AIDL(相当于接口) 

     定义AIDL之后,程序会自动在gen目录下生成相同包名相同文件名的java文件,可以看到Java

    文件中有一抽象类Stub,既继承了Binder类又实现了IService接口。这就是为什么下面服

    务“中间人”是直接继承Stub的原因。


wKioL1XEvmuBjDLYAANHGGst0Uw806.jpg   

    定义支付宝服务

      注意要为服务配一个过滤器,指定一个action,因为支付宝服务要被另外一个应用所调用,

    要用到隐式意图,那么就必须配置一个过滤器。

1
2
3
4
5
             <service android:name="com.itheima.service.PayService" >
                <intent-filter>
                    <action android:name="com.itheima.MY_ALI_PAY" />
                </intent-filter>
             </service>

      定义支付宝服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
    /**
     * 支付宝服务
     */
    public class PayService extends Service {
     
        @Override
        public IBinder onBind(Intent intent) {
            // TODO Auto-generated method stub
            return new MyBinder();
        }
         
        //定义一个支付的方法
        public boolean Pay(String username,String password,double money)
        {
            //逻辑
            System.out.println("密码加密。。。。。。。。。");
            System.out.println("检查手机有没有病毒。。。。。。。。。");
            System.out.println("判断用户名和密码。。。。。。。。");
            System.out.println("......");
             
            if(!(username.equals("root") && password.equals("1234")))
            {
    //          Toast.makeText(getApplicationContext(),"密码错误.....", 0).show();
                System.out.println("sdggsgggs");
                return false;
            }
            if(money < 4000)
            {
    //          Toast.makeText(getApplicationContext(),"豆子数不足4000.....", 0).show();
                System.out.println("QQQQQQQQQQQ");
                return false;
            }
             
            return true;
        }
         
         
        //定义一个中间人对象与调用本地服务不一样,直接继承Stub类就可以了。
        private class MyBinder extends Stub
        {
     
            @Override
            public boolean callPay(String username, String password, double money)
                    throws RemoteException {
                return Pay(username, password, money);
            }
        }
    }

    第3步:  在另外一个应用里调用支付宝服务

       首先,将支付宝服务应用的aidl拷贝过来,并且包名要保持一致。

       Activity调用支付宝服务的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
public class MainActivity extends Activity { 
        //连接远程服务的连接对象   
        private MyConn conn = null;
         
        //怎么才能将其它应用的IService得到呢,使用AIDL技术。
        private IService serviceBinder = null;
         
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            //绑定服务-----------------注意这个逻辑要写在onCreate方法里,因为它需要一定的时间。
            //由于是跨应用访问,要使用隐式意图。
            Intent intent = new Intent();
            intent.setAction("com.itheima.MY_ALI_PAY");
             
            conn = new MyConn();
            bindService(intent, conn, BIND_AUTO_CREATE);
        }
         
        public void click(View v)
        {
            try {
                boolean flag = serviceBinder.callPay("root""1234"5000);    //空指针,没有连接上。。。
                if(flag)
                {
                    System.out.println("支付成功");
                }
            catch (RemoteException e) {
                e.printStackTrace();
            }  
                 
        }
         
        //定义一个类实现ServiceConnection接口
        public class MyConn implements ServiceConnection
        {
     
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                System.out.println("服务连接上了。。。。");
                serviceBinder = Stub.asInterface(service);
            }
     
            @Override
            public void onServiceDisconnected(ComponentName name) {
                System.out.println("服务连接失败。。。。");
            }
             
        }
         
        //解除绑定Service
        @Override
        protected void onDestroy() {
            unbindService(conn);
            super.onDestroy();
        }
    }

 

           

      本文转自屠夫章哥  51CTO博客,原文链接:http://blog.51cto.com/4259297/1679401,如需转载请自行联系原作者





网友评论

登录后评论
0/500
评论
技术小胖子
+ 关注