公司项目中要使用webview下载程序，所以必须用到广播接收器，配合service下载。

忘记的东西重来一遍。

后面有最经典的音乐播放器的源代码。Service  BroadCastReeiver都用到了

简单4步，动态载入广播

1.定义一个广播接收器

public class MyReceiver extends BroadcastReceiver

{

public MyReceiver()

{

Log.i(TAG,"MyReceiver");

}

//可用Intent的getAction()区分接收到的不同广播

@Override

public void onReceive(Context arg0, Intent arg1)

{

String action=intent.getAction();

//TO-DO LIST

}

}

2.发送广播，定义好action标志，用Intent发送

//实例化该BroadcastReceiver

MyReceiver mReceiver=new MyReceiver();

//设置唯一action，用Intent发送

Intent intent=new Intent();

intent.setAction(str);

sendBroadcast(intent);

3.注冊仅仅接收指定action的广播接收器

IntentFilter filter1=new IntentFilter();

filter1.addAction(str);

registerReceiver(mReceiver,filter1);

4.取消该广播接收器

unregisterReceiver(mReceiver);

1.广播的定义

广播接收程序是android四大组件之中的一个，可对client发出的广播消息作出响应的组件，消息本身是一个intent，可由多个接收程序接收

2.注冊方式

a.动态注冊。即通过程序注冊(Context.registerReceiver()),程序退出后广播即实效

b.静态注冊，即在manifest.xml中通过receiver tag注冊，可作为全局广播

注意:对于动态注冊。假设不运行Context.unregisterReceiver，也可作为全局广播。通常，在项目中，一般把注冊放在Activity.onResume方法中，把取注冊放在Activity.onPause中

3.发送广播

广播有两种接收方式

a.普通广播(Context.sendBroadcast)

全然异步的。全部的广播接收者在同一时刻以没有定义的顺序执行。

b.顺序广播(Context.sendOrderedBroadcast)

全部的广播接收者按顺序运行，当中一个运行的广播接受者能够将结果传递给下一个广播接受者，也能够退出广播以便于不将结果传递到下一个广播接受者，能够在manifest.xml中使用android:priority属性来确定广播接收者的优先级。同一优先级的接受者将以随机顺序运行

二、广播高级话题

1.安全性

a.确保Intent的Action名称是你自己应用的命名空间。否则你会在不经意间和其它应用冲突

b.当你使用 registerReceiver(BroadcastReceiver, IntentFilter)时。其它应用也可以发送相关广播到那个注冊的接收者中。这时你应  该使用相关权限来控制谁可以发送广播到那个接收者

c.能够使用android:exported="false"来防止其它应用发送广播到你公布的广播接收者中

d.当你使用sendBroadcast(Intent)时。通过一些权限控制来阻止发送广播到其它接收者中。从android4.0開始能够用Intent.setPackage

2.接收者生命周期

一个BroadcastReceiver对象的生命周期仅存在于onReceive方法中，当你的代码从该方法中返回时。系统会觉得该接收者对象不再有效

不要在onReceive方法中进行一些异步操作的处理。由于该方法结束后整个接收者的生命周期就已经结束了

不要在onReceive方法中显示一个dialog或者绑定service，对于前者。你能够使用NotificationManager。而对于后者使用Context.startService来发送一个命令到service中

3.进程生命周期

当前进程是指执行该广播接收程序的进程，它是一个前台进程，即使该广播生命周期结束后。也会继续执行，直到系统内存紧张被回收

假设当广播接收程序生命周期结束后，该进程就会变为空进程。有可能会被系统回收，你能够结合service和broadcast receiver使用，这样能够使该进程不被回收

三、demo演示样例

1.动态注冊

该程序中，当点击button时会发送一个广播，在该广播中运行在控制台打印广播參数的操作，而且每隔10秒发送一次广播，当退出程序后该广播生命周期结束。不会再在控制台打印

2.静态注冊

a.项目结构

b.MainActivity

c.TestReceiver2

d.AndroidManefist.xml

e.执行结果

点击button后回在logcat中一直打印消息，不管程序是否退出

最经典的音乐播放器的样例：源代码

1. package com.wwj.sb.service;
2. import java.util.List;
3. import android.annotation.SuppressLint;
4. import android.app.Service;
5. import android.content.BroadcastReceiver;
6. import android.content.Context;
7. import android.content.Intent;
8. import android.content.IntentFilter;
9. import android.media.MediaPlayer;
10. import android.media.MediaPlayer.OnCompletionListener;
11. import android.media.MediaPlayer.OnPreparedListener;
12. import android.os.Handler;
13. import android.os.IBinder;
14. import android.util.Log;
15. import com.wwj.sb.activity.PlayerActivity;
16. import com.wwj.sb.domain.AppConstant;
17. import com.wwj.sb.domain.Mp3Info;
18. import com.wwj.sb.utils.MediaUtil;
19. /***
20. * 2013/5/25
21. * @author wwj
22. * 音乐播放服务
23. */
24. @SuppressLint("NewApi")
25. public class PlayerService extends Service {
26. private MediaPlayer mediaPlayer; // 媒体播放器对象
27. private String path;            // 音乐文件路径
28. private int msg;
29. private boolean isPause;        // 暂停状态
30. private int current = 0;        // 记录当前正在播放的音乐
31. private List<Mp3Info> mp3Infos;   //存放Mp3Info对象的集合
32. private int status = 3;         //播放状态，默觉得顺序播放
33. private MyReceiver myReceiver;  //自己定义广播接收器
34. private int currentTime;        //当前播放进度
35. private int duration;           //播放长度
36. //服务要发送的一些Action
37. public static final String UPDATE_ACTION = "com.wwj.action.UPDATE_ACTION";  //更新动作
38. public static final String CTL_ACTION = "com.wwj.action.CTL_ACTION";        //控制动作
39. public static final String MUSIC_CURRENT = "com.wwj.action.MUSIC_CURRENT";  //当前音乐播放时间更新动作
40. public static final String MUSIC_DURATION = "com.wwj.action.MUSIC_DURATION";//新音乐长度更新动作
41. /**
42. * handler用来接收消息。来发送广播更新播放时间
43. */
44. private Handler handler = new Handler() {
45. public void handleMessage(android.os.Message msg) {
46. if (msg.what == 1) {
47. if(mediaPlayer != null) {
48. currentTime = mediaPlayer.getCurrentPosition(); // 获取当前音乐播放的位置
49. Intent intent = new Intent();
50. intent.setAction(MUSIC_CURRENT);
51. intent.putExtra("currentTime", currentTime);
52. sendBroadcast(intent); // 给PlayerActivity发送广播
53. handler.sendEmptyMessageDelayed(1, 1000);
54. }
55. }
56. };
57. };
58. @Override
59. public void onCreate() {
60. super.onCreate();
61. Log.d("service", "service created");
62. mediaPlayer = new MediaPlayer();
63. mp3Infos = MediaUtil.getMp3Infos(PlayerService.this);
64. /**
65. * 设置音乐播放完毕时的监听器
66. */
67. mediaPlayer.setOnCompletionListener(new OnCompletionListener() {
68. @Override
69. public void onCompletion(MediaPlayer mp) {
70. if (status == 1) { // 单曲循环
71. mediaPlayer.start();
72. } else if (status == 2) { // 所有循环
73. current++;
74. if(current > mp3Infos.size() - 1) {  //变为第一首的位置继续播放
75. current = 0;
76. }
77. Intent sendIntent = new Intent(UPDATE_ACTION);
78. sendIntent.putExtra("current", current);
79. // 发送广播，将被Activity组件中的BroadcastReceiver接收到
80. sendBroadcast(sendIntent);
81. path = mp3Infos.get(current).getUrl();
82. play(0);
83. } else if (status == 3) { // 顺序播放
84. current++;  //下一首位置
85. if (current <= mp3Infos.size() - 1) {
86. Intent sendIntent = new Intent(UPDATE_ACTION);
87. sendIntent.putExtra("current", current);
88. // 发送广播，将被Activity组件中的BroadcastReceiver接收到
89. sendBroadcast(sendIntent);
90. path = mp3Infos.get(current).getUrl();
91. play(0);
92. }else {
93. mediaPlayer.seekTo(0);
94. current = 0;
95. Intent sendIntent = new Intent(UPDATE_ACTION);
96. sendIntent.putExtra("current", current);
97. // 发送广播，将被Activity组件中的BroadcastReceiver接收到
98. sendBroadcast(sendIntent);
99. }
100. } else if(status == 4) {    //随机播放
101. current = getRandomIndex(mp3Infos.size() - 1);
102. System.out.println("currentIndex ->" + current);
103. Intent sendIntent = new Intent(UPDATE_ACTION);
104. sendIntent.putExtra("current", current);
105. // 发送广播。将被Activity组件中的BroadcastReceiver接收到
106. sendBroadcast(sendIntent);
107. path = mp3Infos.get(current).getUrl();
108. play(0);
109. }
110. }
111. });
112. myReceiver = new MyReceiver();
113. IntentFilter filter = new IntentFilter();
114. filter.addAction(PlayerActivity.CTL_ACTION);
115. registerReceiver(myReceiver, filter);
116. }
117. /**
118. * 获取随机位置
119. * @param end
120. * @return
121. */
122. protected int getRandomIndex(int end) {
123. int index = (int) (Math.random() * end);
124. return index;
125. }
126. @Override
127. public IBinder onBind(Intent arg0) {
128. return null;
129. }
130. @Override
131. public void onStart(Intent intent, int startId) {
132. path = intent.getStringExtra("url");        //歌曲路径
133. current = intent.getIntExtra("listPosition", -1);   //当前播放歌曲的在mp3Infos的位置
134. msg = intent.getIntExtra("MSG", 0);         //播放信息
135. if (msg == AppConstant.PlayerMsg.PLAY_MSG) {    //直接播放音乐
136. play(0);
137. } else if (msg == AppConstant.PlayerMsg.PAUSE_MSG) {    //暂停
138. pause();
139. } else if (msg == AppConstant.PlayerMsg.STOP_MSG) {     //停止
140. stop();
141. } else if (msg == AppConstant.PlayerMsg.CONTINUE_MSG) { //继续播放
142. resume();
143. } else if (msg == AppConstant.PlayerMsg.PRIVIOUS_MSG) { //上一首
144. previous();
145. } else if (msg == AppConstant.PlayerMsg.NEXT_MSG) {     //下一首
146. next();
147. } else if (msg == AppConstant.PlayerMsg.PROGRESS_CHANGE) {  //进度更新
148. currentTime = intent.getIntExtra("progress", -1);
149. play(currentTime);
150. } else if (msg == AppConstant.PlayerMsg.PLAYING_MSG) {
151. handler.sendEmptyMessage(1);
152. }
153. super.onStart(intent, startId);
154. }
155. /**
156. * 播放音乐
157. *
158. * @param position
159. */
160. private void play(int currentTime) {
161. try {
162. mediaPlayer.reset();// 把各项參数恢复到初始状态
163. mediaPlayer.setDataSource(path);
164. mediaPlayer.prepare(); // 进行缓冲
165. mediaPlayer.setOnPreparedListener(new PreparedListener(currentTime));// 注冊一个监听器
166. handler.sendEmptyMessage(1);
167. } catch (Exception e) {
168. e.printStackTrace();
169. }
170. }
171. /**
172. * 暂停音乐
173. */
174. private void pause() {
175. if (mediaPlayer != null && mediaPlayer.isPlaying()) {
176. mediaPlayer.pause();
177. isPause = true;
178. }
179. }
180. private void resume() {
181. if (isPause) {
182. mediaPlayer.start();
183. isPause = false;
184. }
185. }
186. /**
187. * 上一首
188. */
189. private void previous() {
190. Intent sendIntent = new Intent(UPDATE_ACTION);
191. sendIntent.putExtra("current", current);
192. // 发送广播，将被Activity组件中的BroadcastReceiver接收到
193. sendBroadcast(sendIntent);
194. play(0);
195. }
196. /**
197. * 下一首
198. */
199. private void next() {
200. Intent sendIntent = new Intent(UPDATE_ACTION);
201. sendIntent.putExtra("current", current);
202. // 发送广播。将被Activity组件中的BroadcastReceiver接收到
203. sendBroadcast(sendIntent);
204. play(0);
205. }
206. /**
207. * 停止音乐
208. */
209. private void stop() {
210. if (mediaPlayer != null) {
211. mediaPlayer.stop();
212. try {
213. mediaPlayer.prepare(); // 在调用stop后假设须要再次通过start进行播放,须要之前调用prepare函数
214. } catch (Exception e) {
215. e.printStackTrace();
216. }
217. }
218. }
219. @Override
220. public void onDestroy() {
221. if (mediaPlayer != null) {
222. mediaPlayer.stop();
223. mediaPlayer.release();
224. mediaPlayer = null;
225. }
226. }
227. /**
228. *
229. * 实现一个OnPrepareLister接口,当音乐准备好的时候開始播放
230. *
231. */
232. private final class PreparedListener implements OnPreparedListener {
233. private int currentTime;
234. public PreparedListener(int currentTime) {
235. this.currentTime = currentTime;
236. }
237. @Override
238. public void onPrepared(MediaPlayer mp) {
239. mediaPlayer.start(); // 開始播放
240. if (currentTime > 0) { // 假设音乐不是从头播放
241. mediaPlayer.seekTo(currentTime);
242. }
243. Intent intent = new Intent();
244. intent.setAction(MUSIC_DURATION);
245. duration = mediaPlayer.getDuration();
246. intent.putExtra("duration", duration);  //通过Intent来传递歌曲的总长度
247. sendBroadcast(intent);
248. }
249. }
250. public class MyReceiver extends BroadcastReceiver {
251. @Override
252. public void onReceive(Context context, Intent intent) {
253. int control = intent.getIntExtra("control", -1);
254. switch (control) {
255. case 1:
256. status = 1; // 将播放状态置为1表示：单曲循环
257. break;
258. case 2:
259. status = 2; //将播放状态置为2表示：所有循环
260. break;
261. case 3:
262. status = 3; //将播放状态置为3表示：顺序播放
263. break;
264. case 4:
265. status = 4; //将播放状态置为4表示：随机播放
266. break;
267. }
268. }
269. }
270. }