Android常用代码片段收藏---基础篇一（Button、BootBroadcastReceiver 、thread 、Handler 、wakelock、BroadcastReceiver 等）
本文主要是自己一些常用到过代码架构，涉及Button、BootBroadcastReceiver 、thread 、Handler 、wakelock、BroadcastReceiver Activity生命周期，记录在此更加方便自己查看，里面粘贴的代码全部是自己在 Android 6.0 SDK上编译成功或者实际项目中用的，稍加修改及可以使用，也希望能够给朋友们一些帮助，借鉴了网路上一些大牛的经验，如有雷同，望见谅：
一. Button监听：
1.一个button对应一个监听
private Button botton1;
botton1= (Button)findViewById(R.id.bt1);
botton1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
Log.d("012", "bt1 is clicked\n");
}
});2.多个button对应一个监听1:（注意implements 以及 onclick在oncreate外并且被复写）
public class MainActivity extends Activity implements View.OnClickListener{
private Button botton1;
private Button botton2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
botton1= (Button)findViewById(R.id.bt1);
botton2= (Button)findViewById(R.id.bt2);
botton1.setOnClickListener((OnClickListener) this);
botton2.setOnClickListener((OnClickListener) this);
}
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
switch(v.getId()){
case R.id.bt1:
Log.d("012", "bt1 is clicked\n");
break;
case R.id.bt2:
Log.d("012", "bt2 is clicked\n");
break;
}
}3.多个button对应一个监听2：（注意mylistener 先定义后setOnClickListener）
View.OnClickListener mylistener=new View.OnClickListener() {
@Override
public void onClick(View arg0) {
// TODO Auto-generated method stub
switch(arg0.getId()){
case R.id.bt1:
Log.d("012", "bt1 is clicked\n");
break;
case R.id.bt2:
Log.d("012", "bt is clicked\n");
break;
}
}
};
Button1.setOnClickListener(mylistener);
Button2.setOnClickListener(mylistener); 4.xml中绑定监听
二. BroadcastReceiver实现开机自启动（activity 和 service）
实现原理：当Android启动时，会发出一个系统广播，内容为ACTION_BOOT_COMPLETED，它的字符串常量
表示为android.intent.action.BOOT_COMPLETED。所以，只要在BroadcastReceiver接收到该消息时，创建并启动相应的Activity和Service即可实现
1 AnroidManifest.xml 加上权限：
<uses-permission
android:name="android.permission.RECEIVE_BOOT_COMPLETED" />2.在AndroidManifest.xml application内添加
<receiver android:name=".BootBroadcastReceiver" >
<intent-filter >
<action android:name="android.intent.action.BOOT_COMPLETED" />
intent-filter>
receiver>向系统注册了一个receiver，子节点intent-filter表示接收android.intent.action.BOOT_COMPLETED消息.
3 BootBroadcastReceiver.java源码 该类派生自BroadcastReceiver，覆载方法onReceive中，检测接收到的Intent是否符合BOOT_COMPLETED，如果符合，则启动MainActivity
package com.example.IrService;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;
public class BootBroadcastReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
//启动服务
**************************************************************************
/*Intent service = new Intent(context, IRService.class);
context.startService(service);
Log.v("012", ".....BootBroadcastReceiver");*/
Log.v("012", ".....BootBroadcastReceiver");
//启动activity
************************************************************************
Intent intent1 =new Intent(context, MainActivity.class);
intent1.addFlags(intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(intent1);
}
}三. Android 线程 thread 两种实现方法
1.一种是，扩展Java.lang.Thread类
Thread类代表线程类，它的两个最主要的方法是：
Thread thread = new Thread();
thread.start();
run()——包含线程运行时所执行的代码
Start()——用于启动线程
实现Runnable接口：
Thread thread=new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
Log.d("012","Mythread");
//死循环
while (true) {
}
}
});
thread.start();另外一种thread实现方法：扩展java.lang.Thread类
myThread th1= new myThread();
th1.start();
class myThread extends Thread{
public void run() {
Log.d("012","Mythread2");
}
}- Handler 机制，它是Runnable和Activity交互的桥梁，在run方法中发送Message，在Handler里，通过不同的Message执行不同的任务。（Handler的设计实际上是为了应用程序内其他线程和主线程进行通信，因为只有主线程才能更新UI，其他线程不行）
Handler mHandler;
mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
// TODO Auto-generated method stub
super.handleMessage(msg);
switch(msg.what){
case 0:
//主线程更新UI
String data = (String)msg.obj;
Button1.setText(data);
break;
default:
break;
}
}
};
private void updateBotton() {
new Thread(new Runnable(){
@Override
public void run() {
//耗时操作，完成之后发送消息给Handler，完成UI更新；
mHandler.sendEmptyMessage(0);
//需要数据传递，用下面方法；
Message msg =new Message();
msg.obj = "数据";//可以是基本类型，可以是对象，可以是List、map等；
mHandler.sendMessage(msg);
}
}).start();
}
updateBotton可以通过Botton点击实现
Button1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
updateBotton();
Log.d("012", "bt1 is clicked\n");
}
});附：new Runnable可以这样写 implements Runnable
public class MainActivity extends Activity implements Runnable ｛
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
Thread thread=new Thread(this);
thread.start(); ｝
//Runnable实现的接口
@Override
public void run()
{
Log.e("012", "111111111");
// TODO Auto-generated method stub
Message message=new Message();
message.what=1;
mHandler.sendMessage(message);
}
｝总结：UI的更新必须在主线程中完成，所以不管上述那种方法，都是将更新UI的消息发送到了主线程消息对象，让主线程做处理
四. android WakeLock机制
首先看看官方的解释：
PowerManager:This class gives you control of the power state of the device.
PowerManager.WakeLock: lets you say that you need to have the device on.
PowerManager负责对Android设备电源相关进行管理，而系统通过各种锁对电源进行控制，WakeLock是一种锁机制，只要有人拿着这把所，系统就无法进入休眠阶段。
wakelock实例：
private void acquireWakeLock()
{
if (null == wakeLock)
{
//获取电源管理器对象
PowerManager pm = (PowerManager)this.getSystemService(Context.POWER_SERVICE);
//获取PowerManager.WakeLock对象，后面的参数|表示同时传入两个值，最
后的是调试用的Tag
wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK|
PowerManager.ON_AFTER_RELEASE, "PostLocationService");
if (null != wakeLock)
{
//点亮屏幕
wakeLock.acquire();
}
}
}
//释放设备电源锁
privatevoid releaseWakeLock()
{
if (null != wakeLock)
{
wakeLock.release();
wakeLock = null;
}
} 上面第一个方法是获取锁，第二个方法是释放锁，一旦获取锁后，及时屏幕在熄灭或锁屏长时间后，系
统后台一直可以保持获取到锁的应用程序运行。获取到PowerManager的实例pm后，再通过newWakeLock
方法获取wakelock的实例，其中第一个参数是指定要获取哪种类型的锁，不同的锁对系统CPU、屏幕和
键盘有不同的影响，第二个参数是自定义名称。
各种锁的类型对CPU 、屏幕、键盘的影响：
PARTIAL_WAKE_LOCK:保持CPU 运转，屏幕和键盘灯有可能是关闭的。
SCREEN_DIM_WAKE_LOCK：保持CPU 运转，允许保持屏幕显示但有可能是灰的，允许关闭键盘灯
SCREEN_BRIGHT_WAKE_LOCK：保持CPU 运转，允许保持屏幕高亮显示，允许关闭键盘灯
FULL_WAKE_LOCK：保持CPU运转，保持屏幕高亮显示，键盘灯也保持亮度
ACQUIRE_CAUSES_WAKEUP：强制使屏幕亮起，这种锁主要针对一些必须通知用户的操作.
ON_AFTER_RELEASE：当锁被释放时，保持屏幕亮起一段时间
最后别忘了声明权限：
<uses-permission android:name="android.permission.WAKE_LOCK"/>
<uses-permission android:name="android.permission.DEVICE_POWER"/>五.Broadcast广播
广播被分为两种不同的类型：“普通广播（Normal broadcasts）”和“有序广播（Ordered broadcasts）”。普通广播是完全异步的，可以在同一时刻（逻辑上）被所有广播接收者接收到，消息传递的效率比较高，但缺点是：接收者不能将处理结果传递给下一个接收者，并且无法终止广播Intent的传播；然而有序广播是按照接收者声明的优先级别（声明在intent-filter元素的android:priority属性中，数越大优先级别越高,取值范围:-1000到1000。也可以调用IntentFilter对象的setPriority()进行设置），被接收者依次接收广播。如：A的级别高于B,B的级别高于C,那么，广播先传给A，再传给B，最后传给C。A得到广播后，可以往广播里存入数据，当广播传给B时,B可以从广播中得到A存入的数据。
Context.sendBroadcast()
发送的是普通广播，所有订阅者都有机会获得并进行处理。
Context.sendOrderedBroadcast()
发送的是有序广播，系统会根据接收者声明的优先级别按顺序逐个执行接收者，前面的接收者有权终止广播(BroadcastReceiver.abortBroadcast())，如果广播被前面的接收者终止，后面的接收者就再也无法获取到广播。对于有序广播，前面的接收者可以将处理结果存放进广播Intent，然后传给下一个接收者。
注册BroadcastReceiver有两种方式:
一种方式是，静态的在AndroidManifest.xml中用标签生命注册，并在标签内用标签设置过滤器。
另一种方式是，动态的在代码中先定义并设置好一个 IntentFilter 对象，然后在需要注册的地方调
Context.registerReceiver()方法，如果取消时就调用 Context.unregisterReceiver()方法。如果用
动态方式注册的BroadcastReceiver的Context对象被销毁时，BroadcastReceiver也就自动取消注册了。（特别注意，有些可能需要后台监听的，如短信消息）
另外，若在使用sendBroadcast()的方法是指定了接收权限，则只有在AndroidManifest.xml中用标签声明了拥有此权限的BroascastReceiver才会有可能接收到发送来的Broadcast。同样，若在注册BroadcastReceiver时指定了可接收的Broadcast的权限，则只有在包内的AndroidManifest.xml中 用标签声明了，拥有此权限的Context对象所发送的Broadcast才能被这个 BroadcastReceiver所接收。
1.静态注册BroadcastReceiver:
静态注册比动态注册麻烦点，先新建一个类继承BroadcastReceiver，如：
myreceiver.java
package com.example.test;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.widget.Toast;
/*
* 接收静态注册广播的BroadcastReceiver，
* step1:要到AndroidManifest.xml这里注册消息
*
step2:定义消息的字符串
step3:通过Intent传递消息来驱使BroadcastReceiver触发
*/
public class myreceiver extends BroadcastReceiver{
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
Bundle bundle = intent.getExtras();
String qf1=bundle.getString("Blog");
int number=intent.getIntExtra("Name", 0);
Toast.makeText(context, "I loveyuanyuan:"+action+" wosi "+qf1+" number:"+number, Toast.LENGTH_LONG).show();
}
}然后到AndroidManifest.xml 添加receive标签
<receiver android:name="myreceiver">
<intent-filter>
<action
android:name="com.example.qf"/>
intent-filter>
receiver> 第一个name是类名,即你的继承BroadcastReceiver的类的名字，里面实现了BroadcastReceive的
onReceive()方法，来处理你接到消息的动作。
第二个name是action的名称，即你要监听的消息名字（其它消息都会被过滤不监听）。
Broadcast：
发送广播消息，把要发送的信息和用于过滤的信息(如Action、Category)装入一个Intent对象，然后通过调用 Context.sendBroadcast()、sendOrderBroadcast()或sendStickyBroadcast()方法，把 Intent对象以广播方式发送出去。
例如：
////设置Action
intent = new Intent("com.example.qf");
////携带数据
intent.putExtra("Name", 12345);
intent.putExtra("Blog", "http://blog.csdn.net/qf0727");
////发送广播
sendBroadcast(intent);// 传递过去2.动态注册BroadcastReceiver:
package com.example.test;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends Activity {
TextView tv;
Button btn;
Intent intent;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
tv = (TextView) findViewById(R.id.tv1);
btn = (Button) findViewById(R.id.btn1);
intent = new Intent("com.qf");
// sendBroadcast(intent);// 传递过去
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
Log.d("012", "bt1 is clicked\n");
sendBroadcast(intent);
}
});
}
// 动态注册不需要一个类继承BroadcastReceiver这个类了，直接new一个对象即可
private BroadcastReceiver mReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent)
{
String action = intent.getAction();
// 判断是否接到广播
if ("com.qf".equals(action)) // 系统广播可以这么写：if
(intent.ACTION_BATTERY_CHANGED.equals(action))
{
// 处理内容
Log.d("012", "receiver MyBroadcast");
} else if (action.equals("qf.com")) {
Log.v("012", "receiver Action2");
}
}
};
@Override
protected void onStart() {
Log.i("012", "onStart called!");
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction("com.qf"); // 为BroadcastReceiver指定action，即要监听的消息名字。
registerReceiver(mReceiver, intentFilter); // 注册监听
super.onStart();
}
@Override
protected void onStop() {
Log.i("012", "onStop called!");
unregisterReceiver(mReceiver); // 取消监听
super.onStop();
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
}
六. Activity的生命周期
/**Activity1的代码*/
public class Activity1 extends Activity {
private static final String TAG = "Activity1";
@Override
public void onCreate(Bundle savedInstanceState) {
Log.i(TAG, "Activity1 onCreate called!");
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
@Override
protected void onStart() {
Log.i(TAG, "Activity1 onStart called!");
super.onStart();
}
@Override
protected void onRestart() {
Log.i(TAG, "Activity1 onRestart called!");
super.onRestart();
}
@Override
protected void onResume() {
Log.i(TAG, "Activity1 onResume called!");
super.onResume();
}
@Override
protected void onPause() {
Log.i(TAG, "Activity1 onPause called!");
super.onPause();
}
@Override
protected void onStop() {
Log.i(TAG, "Activity1 onStop called!");
super.onStop();
}
@Override
protected void onDestroy() {
Log.i(TAG, "Activity1 onDestroy called!");
super.onDestroy();
}
/**当点击屏幕时，进入Activity2*/
@Override
public boolean onTouchEvent(MotionEvent event) {
Intent intent = new Intent(this, Activity2.class);
startActivity(intent);
return super.onTouchEvent(event);
}
} ========================================================================