Android通信机制总结

Android通信机制总结
第一种：使用handler来进行通信 handler 大家可以把它想象成主线程(UI线程)的一个子线程，它可以给主线程(UI线程)发送数据从而更新主线程(UI线程)的UI与逻辑，handler 是一个子线程所以它的耗时操作不会阻塞主线程，大家都知道在android的开发中如果代码中某个地方阻塞主线程超过5秒的话系统会提示ANR (系统提示强制关闭)所以在耗时操作上我们可以考虑开启一个子线程避免ANR。 handler会向主线程发送消息会以队列的形式排列着配合等待主线程更新UI 逻辑等等。
[java] view plain copy print ?
1. public class HandlerActivity extends Activity implements Runnable{
3. /**更新时间**/
4. public final static int UPDATE_TIME =0;
5. /**更新时间成功**/
6. public final static int UPDATE_COMPLETED =1;
8. /**记录显示时间超过10秒结束线程**/
9. private int mShowNumber = 0;
11. /**开始计时按钮**/
12. private Button mButton = null;
14. /**计时显示内容**/
15. private TextView mTextView = null;
17. /**线程**/
18. private Thread mThread = null;
20. /**线程关闭的标志**/
21. private boolean mRunning = false;
23. Handler handler = new Handler() {
24. @Override
25. public void handleMessage(Message msg) {
27. Bundle bundle= msg.getData();
28. //通过key的名称拿到它的值
29. String number = bundle.getString("number");
30. //msg.what为handler接收到的消息编号
31. switch(msg.what) {
32. case UPDATE_TIME:
33. mTextView.setText("正在更新时间" + number);
34. break;
35. case UPDATE_COMPLETED:
36. mTextView.setText("更新完毕");
37. break;
38. }
39. super.handleMessage(msg);
40. }
41. };
43. @Override
44. protected void onCreate(Bundle savedInstanceState) {
45. setContentView(R.layout.handler);
47. /**拿到button 与 TextView 对象**/
48. mButton = (Button)findViewById(R.id.button0);
49. mTextView = (TextView)findViewById(R.id.textView0);
50. mThread = new Thread(this);
52. mButton.setOnClickListener(new OnClickListener() {
53. @Override
54. public void onClick(View arg0) {
55. /**点击按钮后开始线程开始计时**/
56. mRunning = true;
57. mThread.start();
58. }
59. });
61. mTextView.setText("点击按钮开始更新时间");
62. super.onCreate(savedInstanceState);
63. }
65. public void ShowDialog(String string) {
66. AlertDialog.Builder builder = new AlertDialog.Builder(
67. HandlerActivity.this);
68. builder.setIcon(R.drawable.icon);
69. builder.setTitle(string);
70. builder.setPositiveButton("确定", new DialogInterface.OnClickListener() {
71. public void onClick(DialogInterface dialog, int whichButton) {
72. finish();
73. }
74. });
75. builder.show();
76. }
80. @Override
81. public void run() {
83. while (mRunning) {
84. try {
85. mShowNumber++;
86. /** 把须要的数据放入bandle中 **/
87. Bundle bandle = new Bundle();
88. bandle.putString("number", String.valueOf(mShowNumber));
90. /** 设置这条信息的编号为更新时间 **/
91. /** 将bandle写入message中 **/
92. /** 最后将这个message发送出去 **/
93. /** mShowNumber小于10更新时间否则更新完毕 **/
94. Message msg = new Message();
95. if(mShowNumber <=10) {
96. msg.what = UPDATE_TIME;
97. }else {
98. mRunning = false;
99. msg.what = UPDATE_COMPLETED;
100. }
101. msg.setData(bandle);
102. handler.sendMessage(msg);
103. Thread.sleep(1000);
104. } catch (InterruptedException e) {
105. e.printStackTrace();
106. }
107. }
108. }
109. }
```
public class HandlerActivity extends Activity implements Runnable{  
  
    /**更新时间**/  
    public final static int UPDATE_TIME =0;  
    /**更新时间成功**/  
    public final static int UPDATE_COMPLETED =1;  
      
    /**记录显示时间 超过10秒结束线程**/  
    private int mShowNumber = 0;  
      
    /**开始计时按钮**/  
    private Button mButton = null;  
      
    /**计时显示内容**/  
    private TextView mTextView = null;  
     
    /**线程**/  
    private Thread mThread = null;  
     
    /**线程关闭的标志**/  
    private boolean mRunning = false;  
      
    Handler handler = new Handler() {  
    @Override  
    public void handleMessage(Message msg) {  
          
        Bundle bundle= msg.getData();  
        //通过key的名称拿到它的值  
        String  number = bundle.getString("number");  
        //msg.what为handler接收到的消息编号  
        switch(msg.what) {  
        case UPDATE_TIME:  
        mTextView.setText("正在更新时间" + number);  
        break;  
        case UPDATE_COMPLETED:  
        mTextView.setText("更新完毕");  
        break;  
        }  
        super.handleMessage(msg);  
    }  
    };  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
    setContentView(R.layout.handler);  
      
    /**拿到button 与  TextView 对象**/  
    mButton = (Button)findViewById(R.id.button0);  
    mTextView = (TextView)findViewById(R.id.textView0);  
    mThread = new Thread(this);  
      
    mButton.setOnClickListener(new OnClickListener() {  
        @Override  
        public void onClick(View arg0) {  
        /**点击按钮后开始线程开始计时**/  
        mRunning = true;  
        mThread.start();  
        }  
    });  
      
    mTextView.setText("点击按钮开始更新时间");  
    super.onCreate(savedInstanceState);  
    }  
  
    public void ShowDialog(String string) {  
    AlertDialog.Builder builder = new AlertDialog.Builder(  
        HandlerActivity.this);  
    builder.setIcon(R.drawable.icon);  
    builder.setTitle(string);  
    builder.setPositiveButton("确定", new DialogInterface.OnClickListener() {  
        public void onClick(DialogInterface dialog, int whichButton) {  
        finish();  
        }  
    });  
    builder.show();  
    }  
  
   
  
    @Override  
    public void run() {  
  
    while (mRunning) {  
        try {  
        mShowNumber++;  
        /** 把须要的数据放入bandle中 **/  
        Bundle bandle = new Bundle();  
        bandle.putString("number", String.valueOf(mShowNumber));  
  
        /** 设置这条信息的编号为更新时间 **/  
        /** 将bandle写入message中 **/  
        /** 最后将这个message发送出去 **/  
        /** mShowNumber小于10更新时间 否则更新完毕 **/  
        Message msg = new Message();  
        if(mShowNumber <=10) {  
            msg.what = UPDATE_TIME;   
        }else {  
            mRunning = false;  
            msg.what = UPDATE_COMPLETED;    
        }  
        msg.setData(bandle);  
        handler.sendMessage(msg);  
        Thread.sleep(1000);  
        } catch (InterruptedException e) {  
        e.printStackTrace();  
        }  
    }  
    }  
}  
```
2.Notifation通知栏信息 Notifation通知栏会在屏幕上方向用户提示信息但是不会打断用户正在阅读的内容，除非用户手动将 Notifation通知栏拉下。 Notifation的好处就是在于不会影响用户的操作，比如用户正在阅读非常重要的信息这时候帮他直接打开一个activity会非常不合适因为直接影响到了他当时的操作行为所以Notifation就出来了。建议大家在开发中遇到可能打断用户使用的情况下都去使用Notifation通知栏。
[java] view plain copy print ?
1. public class NotificationActivity extends Activity {
2. NotificationManager mManager = null;
3. Notification notification =null;
4. @Override
5. protected void onCreate(Bundle savedInstanceState) {
6. setContentView(R.layout.notification);
8. // 得到通知消息的管理器对象，负责管理 Notification 的发送与清除消息等
9. mManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
10. // 创建Notification对象参数分别代表通知栏中显示的图标显示的标题显示的时间
11. notification = new Notification(R.drawable.jay,
12. "Android专业开发群", System.currentTimeMillis());
14. // 设置在通知栏中点击后Notification自动消失
15. notification.flags = Notification.FLAG_AUTO_CANCEL;
17. //设置点击后转跳的新activity
18. Intent intent = new Intent(this, MyShowActivity.class);
19. intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP| Intent.FLAG_ACTIVITY_NEW_TASK);
21. //通过bundle可以带一些数据过去这里将字符串传递了过去
22. Bundle bundle = new Bundle();
23. bundle.putString("name", "从Notification转跳过来的");
24. intent.putExtras(bundle);
26. //设置通知栏中显示的内容
27. PendingIntent contentIntent = PendingIntent.getActivity(this,
28. R.string.app_name, intent, PendingIntent.FLAG_UPDATE_CURRENT);
29. notification.setLatestEventInfo(this, "Android专业开发群",
30. "QQ群号 164257885", contentIntent);
33. Button button0 = (Button)findViewById(R.id.button0);
34. button0.setOnClickListener(new OnClickListener() {
36. @Override
37. public void onClick(View arg0) {
38. //打开这个Notification通知
39. mManager.notify(0, notification);
40. }
41. });
43. Button button1 = (Button)findViewById(R.id.button1);
44. button1.setOnClickListener(new OnClickListener() {
46. @Override
47. public void onClick(View arg0) {
48. //关闭这个Notification通知
49. mManager.cancelAll();
50. }
51. });
53. super.onCreate(savedInstanceState);
54. }
56. }
```
public class NotificationActivity extends Activity {  
    NotificationManager mManager = null;  
    Notification notification =null;  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
    setContentView(R.layout.notification);  
  
    // 得到通知消息的管理器对象，负责管理 Notification 的发送与清除消息等  
    mManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);  
    // 创建Notification对象 参数分别代表 通知栏 中显示的图标 显示的标题 显示的时间  
    notification = new Notification(R.drawable.jay,  
        "Android专业开发群", System.currentTimeMillis());  
      
    // 设置在通知栏中点击后Notification自动消失  
    notification.flags = Notification.FLAG_AUTO_CANCEL;  
      
    //设置点击后转跳的新activity  
    Intent intent = new Intent(this, MyShowActivity.class);  
    intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP| Intent.FLAG_ACTIVITY_NEW_TASK);  
  
    //通过bundle可以带一些数据过去 这里将字符串传递了过去  
    Bundle bundle = new Bundle();  
    bundle.putString("name", "从Notification转跳过来的");  
    intent.putExtras(bundle);  
      
    //设置通知栏中显示的内容  
    PendingIntent contentIntent = PendingIntent.getActivity(this,  
        R.string.app_name, intent, PendingIntent.FLAG_UPDATE_CURRENT);  
    notification.setLatestEventInfo(this, "Android专业开发群",  
        "QQ群号 164257885", contentIntent);  
      
  
    Button button0 = (Button)findViewById(R.id.button0);  
    button0.setOnClickListener(new OnClickListener() {  
          
        @Override  
        public void onClick(View arg0) {  
        //打开这个Notification通知  
        mManager.notify(0, notification);  
        }  
    });  
      
    Button button1 = (Button)findViewById(R.id.button1);  
    button1.setOnClickListener(new OnClickListener() {  
          
        @Override  
        public void onClick(View arg0) {  
        //关闭这个Notification通知  
        mManager.cancelAll();  
        }  
    });  
      
    super.onCreate(savedInstanceState);  
    }  
  
}  
```
3.广播的发送与接收
Android开发中如果须要对两个完全没关系的程序之间进行通信就可以使用发送广播与接收广播的机制来实现，例如程序A发送了一个广播程序B接受到做一些事情这样就达到了相互的通讯。
[java] view plain copy print ?
1. public class BroadcastActivity extends Activity {
5. Button mButton0 = null;
6. Button mButton1 = null;
8. @Override
9. protected void onCreate(Bundle savedInstanceState) {
10. setContentView(R.layout.broadcast);
12. mButton0 = (Button)findViewById(R.id.button0);
13. mButton0.setOnClickListener(new OnClickListener() {
15. @Override
16. public void onClick(View arg0) {
17. Intent intent = new Intent(MyService.SEND_OK_MESSAGE);
18. intent.putExtra("name", "您发送了OK这条广播哦");
19. sendBroadcast(intent);
20. }
21. });
23. mButton1 = (Button)findViewById(R.id.button1);
24. mButton1.setOnClickListener(new OnClickListener() {
26. @Override
27. public void onClick(View arg0) {
28. Intent intent = new Intent(MyService.SEND_CANCLE_MESSAGE);
29. intent.putExtra("name", "您发送了Cancle这条广播哦");
30. sendBroadcast(intent);
31. }
32. });
34. //启动Service
35. Intent i = new Intent(this, MyService.class);
36. startService(i);
37. super.onCreate(savedInstanceState);
38. }
39. }
```
public class BroadcastActivity extends Activity {  
  
  
     
    Button mButton0 = null;  
    Button mButton1 = null;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
    setContentView(R.layout.broadcast);  
      
    mButton0 = (Button)findViewById(R.id.button0);  
    mButton0.setOnClickListener(new OnClickListener() {  
          
        @Override  
        public void onClick(View arg0) {  
                Intent intent = new Intent(MyService.SEND_OK_MESSAGE);  
                intent.putExtra("name", "您发送了OK这条广播哦");  
                sendBroadcast(intent);  
        }  
    });  
  
    mButton1 = (Button)findViewById(R.id.button1);  
    mButton1.setOnClickListener(new OnClickListener() {  
          
        @Override  
        public void onClick(View arg0) {  
                Intent intent = new Intent(MyService.SEND_CANCLE_MESSAGE);  
                intent.putExtra("name", "您发送了Cancle这条广播哦");  
                sendBroadcast(intent);  
        }  
    });  
      
    //启动Service   
    Intent i = new Intent(this, MyService.class);  
    startService(i);  
    super.onCreate(savedInstanceState);  
    }  
}  
```
[java] view plain copy print ?
1. 接收广播的话我们开启一个service 在service中通过BroadcastReceiver 来接收广播前提是须要接收的广播须要在onStart()中注册一下在AndroidManifest.xml中可以过滤只接收须要接收的广播、
3. view plain
4. <service android:name=".MyService">
5. <intent-filter>
6. <action android:name="cn.m15.xys.MyService"></action>
7. </intent-filter>
8. <intent-filter>
9. <action android:name="send.ok.message" />
10. <action android:name="send.cancle.message" />
11. </intent-filter>
12. </service>
15. 在onStart()中注册了程序中所需要的两个广播
17. view plain
18. public class MyService extends Service {
20. public final static String SEND_OK_MESSAGE = "send.ok.message";
21. public final static String SEND_CANCLE_MESSAGE = "send.cancle.message";
23. private BroadcastReceiver myBroadCast = new BroadcastReceiver() {
25. @Override
26. public void onReceive(Context context, Intent intent) {
27. String action = intent.getAction();
28. if (action.equals(SEND_OK_MESSAGE)) {
29. Toast.makeText(context, "接收到了一条广播为" + SEND_OK_MESSAGE, Toast.LENGTH_LONG).show();
30. }else if(action.equals(SEND_CANCLE_MESSAGE)) {
31. Toast.makeText(context, "接收到了一条广播为" + SEND_CANCLE_MESSAGE, Toast.LENGTH_LONG).show();
32. }
33. }
35. };
37. @Override
38. public void onCreate() {
39. super.onCreate();
40. }
42. @Override
43. public void onStart(Intent intent, int startId) {
44. //注册这两个广播
45. IntentFilter myFilter = new IntentFilter();
46. myFilter.addAction(SEND_OK_MESSAGE);
47. myFilter.addAction(SEND_CANCLE_MESSAGE);
48. this.registerReceiver(myBroadCast, myFilter);
49. super.onStart(intent, startId);
50. }
51. @Override
52. public IBinder onBind(Intent arg0) {
53. return null;
54. }
56. }
58. 这里注意一下 service如果没有起来我们是接收不到广播的所以一定要保证接收的时候service是开启的，上例中的service是在打开activity时开启的但是如果用户把手机关掉然后在开机，这样的话service就不是打开状态这样就非常危险了因为这时scrvice就接收不到任何消息了除非用户再次进activity 才会帮他打开scrvice 所以我们可以在用户开机后就直接将scrvice打开，具体的实现方式如下
60. 在AndroidManifest.xml中注册一个开机广播这个广播系统只会在开机发出而且只会发出一次所以我们接收这个广播就可以知道手机是否为开机状态
62. view plain
63. <receiver android:name=".MyBootReceiver" >
64. <intent-filter>
65. <action android:name="android.intent.action.BOOT_COMPLETED" />
66. </intent-filter>
67. </receiver>
69. 注意加入权限
71. view plain
72. <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
74. 在BroadcastRecevier中接收开机广播然后打开service 就可以实现开机启动service。
76. view plain
77. public class MyBootReceiver extends BroadcastReceiver {
78. /**开机广播**/
79. static final String BOOT_COMPLETED = "android.intent.action.BOOT_COMPLETED";
81. @Override
82. public void onReceive(Context context, Intent intent) {
83. /**如果为开机广播则开启service**/
84. if (intent.getAction().equals(BOOT_COMPLETED)) {
85. Intent i = new Intent(context, MyService.class);
86. context.startService(i);
87. }
89. }
90. }
```
接收广播的话 我们开启一个service 在service中通过BroadcastReceiver 来接收广播 前提是须要接收的广播须要在onStart()中注册一下 在AndroidManifest.xml中可以过滤只接收须要接收的广播、

view plain
<service android:name=".MyService">  
    <intent-filter>  
        <action android:name="cn.m15.xys.MyService"></action>  
    </intent-filter>  
    <intent-filter>  
        <action android:name="send.ok.message" />  
        <action android:name="send.cancle.message" />  
    </intent-filter>  
</service>  


在onStart()中注册了程序中所需要的两个广播

view plain
public class MyService extends Service {  
  
    public final static String SEND_OK_MESSAGE = "send.ok.message";  
    public final static String SEND_CANCLE_MESSAGE = "send.cancle.message";  
      
    private BroadcastReceiver myBroadCast = new BroadcastReceiver() {  
  
    @Override  
    public void onReceive(Context context, Intent intent) {  
        String action = intent.getAction();  
        if (action.equals(SEND_OK_MESSAGE)) {  
        Toast.makeText(context, "接收到了一条广播为" + SEND_OK_MESSAGE, Toast.LENGTH_LONG).show();  
        }else if(action.equals(SEND_CANCLE_MESSAGE)) {  
        Toast.makeText(context, "接收到了一条广播为" + SEND_CANCLE_MESSAGE, Toast.LENGTH_LONG).show();  
        }  
    }  
  
    };  
  
    @Override  
    public void onCreate() {  
    super.onCreate();  
    }  
  
    @Override  
    public void onStart(Intent intent, int startId) {  
    //注册这两个广播  
    IntentFilter myFilter = new IntentFilter();  
    myFilter.addAction(SEND_OK_MESSAGE);  
    myFilter.addAction(SEND_CANCLE_MESSAGE);  
    this.registerReceiver(myBroadCast, myFilter);  
        super.onStart(intent, startId);  
    }  
    @Override  
    public IBinder onBind(Intent arg0) {  
    return null;  
    }  
  
}  

        这里注意一下 service如果没有起来 我们是接收不到广播的 所以一定要保证接收的时候service是开启的，上例中的service是在打开activity时开启的 但是如果用户把手机关掉然后在开机 ， 这样的话service就不是打开状态 这样就非常危险了因为这时scrvice就接收不到任何消息了除非用户再次进activity 才会帮他打开scrvice 所以我们可以在用户开机后就直接将scrvice打开，具体的实现方式如下

在AndroidManifest.xml中注册一个开机广播  这个广播系统只会在开机发出而且只会发出一次 所以我们接收这个广播就可以知道手机是否为开机状态

view plain
<receiver android:name=".MyBootReceiver" >  
      <intent-filter>  
         <action android:name="android.intent.action.BOOT_COMPLETED" />  
     </intent-filter>  
   </receiver>  

注意加入权限 

view plain
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />  

在BroadcastRecevier中接收开机广播  然后打开service 就可以实现开机启动service。

view plain
public class MyBootReceiver extends BroadcastReceiver {  
   /**开机广播**/  
    static final String BOOT_COMPLETED = "android.intent.action.BOOT_COMPLETED";  
  
    @Override  
    public void onReceive(Context context, Intent intent) {  
    /**如果为开机广播则开启service**/  
    if (intent.getAction().equals(BOOT_COMPLETED)) {  
        Intent i = new Intent(context, MyService.class);  
        context.startService(i);  
    }  
  
    }  
}  
```
4.Activity与Activity之间的转跳 在软件应用的开发中肯定会有多个Activity 这样它们之间就会存在相互转跳的关系转跳的实现方式还是使用Intent 然后startActivity ，当然转跳的话是可以带数据过去的。比如从A跳到B 可以把A中的一些数据通过Intent传递给B 。
[java] view plain copy print ?
1. 读下面这段代码大家会发现intent与bandle 传递数值的方式基本一样为什么还要分成两个呢？确实他们两个传递的数值的方式非常类似，他们两个的区别就是Intent属于把零散的数据传递过去而bundle则是把零散的数据先放入bundle 然后在传递过去。我举一个例子比如我们现在有3个activity A.B.C 须要把A的数据穿给B然后在穿给C ，如果使用intent一个一个传递须要在A类中一个一个传递给B 然后B类中获取到所有数值然后在一个一个传递给C 这样很麻烦但是如果是bundle的话 B类中直接将bundler传递给C 不用一个一个获得具体的值然后在C类中直接取得解析数值。
3. 传递
4. view plain
5. /**Activity之间传递值**/
6. Button botton3 = (Button)findViewById(R.id.button3);
7. botton3.setOnClickListener(new OnClickListener() {
9. @Override
10. public void onClick(View arg0) {
11. Intent intent = new Intent(mContext,ShowActivity.class);
12. //使用intent.putExtra()直接传递
13. intent.putExtra("name", "雨松MOMO");
14. intent.putExtra("age", 25);
15. intent.putExtra("boy", true);
17. //把数值放进bundle 然后在把整个bundle通过intent.putExtra()传递
18. Bundle bundle = new Bundle();
19. bundle.putString("b_name", "小可爱");
20. bundle.putInt("b_age", 23);
21. bundle.putBoolean("b_boy", false);
22. //在这里把整个bundle 放进intent中
23. intent.putExtras(bundle);
24. //开启一个新的 activity 将intent传递过去
25. startActivity(intent);
26. }
27. });
29. 接收
30. view plain
31. public class ShowActivity extends Activity {
33. @Override
34. protected void onCreate(Bundle savedInstanceState) {
35. setContentView(R.layout.my);
37. Intent intent = getIntent();
39. String name = intent.getStringExtra("name");
40. //第二个参数为默认值意思就是如果在intent中拿不到的话
41. //就用默认值
42. int age = intent.getIntExtra("age", 0);
43. boolean isboy = intent.getBooleanExtra("boy", false);
44. TextView textView0 = (TextView)findViewById(R.id.text0);
46. textView0.setText("姓名 " + name + "年龄 " + age + "男孩? " + isboy);
49. Bundle bundle = intent.getExtras();
50. name = bundle.getString("b_name");
51. //第二个参数为默认值意思就是如果在bundle中拿不到的话
52. //就用默认值
53. age = bundle.getInt("b_age",0);
54. isboy = bundle.getBoolean("b_boy", false);
56. TextView textView1 = (TextView)findViewById(R.id.text1);
58. textView1.setText("姓名 " + name + "年龄 " + age + "男孩? " + isboy);
60. super.onCreate(savedInstanceState);
61. }
63. }
相关阅读:
eclipse经常卡死、反应慢、内存溢出的解决方案
 PAC4J 初探
 suse11离线安装nginx
linux修改乱码的文件名
 CentOS修改服务器系统时间
 Unable to open nested entry '********.jar' 问题解决
 openssl req(生成证书请求和自建CA)
CRT证书转JKS证书
 如何创建一个自签名的SSL证书(X509)
Redis分布式锁的深度剖析
原文地址：https://www.cnblogs.com/douzhanshen/p/4126377.html