拓展：
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.进程
-
-
Foreground process 前台进程 相当于Activity执行了onResume方法 用户正在操作页面 前台进程的优先级最高
-
Visible process 可视进程 相当于Activity执行了onPasue方法 用户依然能看的见屏幕
-
Service process 服务进程 相当于通过startservice方式开启了一个服务 在当前进程里面运行
-
Background process 后台进程 相当于Activity执行了onStop方法 用户看不见页面 但是注意Activity没有执行ondestroy方法
-
Empty process 空进程 后台没有任何组件运行 这个时候属于空进程
-
3.服务的创建和开启
■服务的创建：
定义一个类继承Service，在清单文件里注册这个类，<service>标签。
■服务的开启：
服务的开启属于Context里的方法，所以继承了Context的类Activity、Service或者是拥有Context对象的类
都可以开启一个服务（如广播接收者的onReceive方法里有Context对象，所以广播接收者也可以开启一个服务）
开启服务的方式有2种：startService和bindService。
不同的方式开启的服务，作用不同，服务的生命周期不同，服务需要复写的方法也不同，掌握
这两种开启服务的方式区别十分地重要。（********重点*********）
如果想要服务长期运行，就用startService方法；如果想调用服务里的方法，就用bindService
方法来开启服务。
不同方式开启服务的生命周期图：
1）startService方式开启服务
当用户第一次调用start-service方法 服务会执行onCreate、onStartCommand、onStart方法
当用户第二次调用start-service方法 服务只会走onStartCommand、onStart方法
服务一旦通过start-service方法开启后 服务就会在后台长期运行 直到用户手工停止或调用
stopService方法停止，或者服务调用自身的stopSelf()方法。如下图，手动关闭service:
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个功能按钮,效果如下图所示：
实现思路:一般音乐播放软件,在界面销毁之后,音乐还能继续在长期运行播放，所以音乐播放的逻辑应该写在服
务里，用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步: 建立两个应用
第2步: 模拟支付宝服务（实际上支付宝是很复杂的）
先定义AIDL（相当于接口）
定义AIDL之后，程序会自动在gen目录下生成相同包名相同文件名的java文件，可以看到Java
文件中有一抽象类Stub，既继承了Binder类又实现了IService接口。这就是为什么下面服
务“中间人”是直接继承Stub的原因。
定义支付宝服务
注意要为服务配一个过滤器，指定一个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，如需转载请自行联系原作者
