数据、消息的传递

一、Activity之间
A、使用public static Handler，这样其他class可以轻松得到彼此之间的Handler，从而进行信息的传递。
B、后来在网上查到了两个Activity进行handler传递的方法，即利用Application，参考http://blog.csdn.net/jason0539/article/details/18055259 （转）：

public class MyAPP extends Application {  
// 共享变量  
private MyHandler handler = null;  

// set方法  
public void setHandler(MyHandler handler) {  
this.handler = handler;  
}  

// get方法  
public MyHandler getHandler() {  
return handler;  
}  

}

在一个Activity里这样设置：

public void onCreate(Bundle savedInstanceState) {  

super.onCreate(savedInstanceState);  
setContentView(R.layout.main);  


mAPP = (MyAPP) getApplication();  
handler = new MyHandler();  
tv = (TextView) findViewById(R.id.tv);  
btn_to = (Button) findViewById(R.id.btn_to);  

// 设置监听器  
btn_to.setOnClickListener(new OnClickListener() {  
@Override  
public void onClick(View v) {  
// 设置共享变量  
mAPP.setHandler(handler);  
// 启动另一个Activity  
Intent intent = new Intent(MasterActivity.this,  
ToChangeViewActivity.class);  
startActivity(intent);  
}  
});  

}  

在另一个activity这样：

    protected void onCreate(Bundle savedInstanceState) {  
    super.onCreate(savedInstanceState);  
    setContentView(R.layout.show);  

    mAPP = (MyAPP) getApplication();  
    // 获得该共享变量实例  
    mHandler = mAPP.getHandler();  
    findViewById(R.id.btn_chang).setOnClickListener(new OnClickListener() {  

    @Override  
    public void onClick(View v) {  
    // 发送消息  
    mHandler.sendEmptyMessage(CHANGED);  
    ToChangeViewActivity.this.finish();  
    }  
    });  

    }  

C、另外可以使用Messenger来实现，如：
Activity1

package com.example.almoliu.handlerbetweenacti;

import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.Messenger;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {

    Button next_btn;

    public  static final int FLAG = 1001;
    private Messenger messenger1;
    private Handler UiHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case FLAG:
                    Toast.makeText(MainActivity.this,"feafesaf",Toast.LENGTH_LONG).show();
                    break;
                default:
                    super.handleMessage(msg);
                    break;
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        messenger1 = new Messenger(UiHandler);
        next_btn = (Button)findViewById(R.id.next_btn);
        next_btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent i = new Intent(MainActivity.this,Main2Activity.class);
                Bundle bundle = new Bundle();
                bundle.putBinder("IBinder",messenger1.getBinder());
                i.putExtras(bundle);
                startActivity(i);
            }
        });
    }

}

Activity2

public class Main2Activity extends AppCompatActivity {

    MyHandler mHandler1 = null;

    Button send_btn;
    private Messenger messenger2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);
        Intent  i = getIntent();
        Bundle bundle = i.getExtras();
        messenger2 = new Messenger(bundle.getBinder("IBinder"));


        send_btn = (Button)findViewById(R.id.button);
        send_btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Message msg = Message.obtain(null,MainActivity.FLAG);
                try {
                    messenger2.send(msg);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        })；
    }
}

D、利用公共类：
该方法还适合于Activity与Service进行信息的交换，详细请见Activity如何与Service进行信息交换。
E、利用Broadcast Receiver，该方法亦可使用于Activity与静态注册的Broadcast Receiver进行信息的传递，详细请参考 此处。

二、Activity与Broadcast Receiver
Broadcast Receiver：注册方式有两种，一种是静态的，一种是动态的。
对于动态的，在哪个Activity注册，就要在这个Activity取消注册，并且对于 其Context尽量不要使用getApplicationContext（）方法，尽量使用注册该Broadcast Receiver的Context。这样，该Broadcast Receiver很容易和该Activity进行信息的传递，进而和其他Activity进行信息传递。比较简单，且易操作。
但是对于静态的，我理解为全局的Broadcast Recevier，首先要在AndroidManifest里进行注册，而对于和Activity进行信息传递则显得比较难办。
使用Handler比较容易解决，但是怎么在Boradcast Receiver中获得Activity的Handler？使用static handler 可以实现，但是带了了其他问题，不推荐。
刚开始我犯了一个低级错误，在这里也记一下吧：首先我注册了一个静态的Broadcast Receiver：

public class Receiver extends BroadcastReceiver {
    private static final String TAG = "Receiver";

    public static final String MY_ACTION = "com.example.almoliu.bplayer.action";

    private Handler uiHandler = null;
    public Receiver() {

    }

    @Override
    public void onReceive(Context context, Intent intent) {
        // TODO: This method is called when the BroadcastReceiver is receiving
        // an Intent broadcast.
        String action = intent.getAction();
        if(BluetoothAdapter.ACTION_STATE_CHANGED.equals(action)) {
            int extrasState = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, -1);
            if(extrasState==BluetoothAdapter.STATE_OFF) {
                Log.d(TAG, "the bluetooth has been turned off...");
                Intent i = new Intent(MY_ACTION);
                context.sendBroadcast(i);
            }
        }
    }
}

在一个Activity中：

 IntentFilter i = new IntentFilter(Receiver.MY_ACTION);
        registerReceiver(mBroadcastReceiver,i);

三、 Activity与Service
A、该种方法也适用于activity之间的通信：
在activity
TaskService.start(uiHandler, this);
在该service内或者其他Activity中：
public static void start(Handler handler,Context context) {
uiHandler = handler;
mContext = context;
Intent startIntent = new Intent(context,TaskService.class);
context.startService(startIntent);
}

public static void stop(Context context) {
    Intent stopIntent = new Intent(context,TaskService.class);
    context.stopService(stopIntent);
}
@Override
public void onCreate() {
    super.onCreate();
    mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
    if((mBluetoothAdapter==null)||(!mBluetoothAdapter.isEnabled())) {
        stopSelf();
        return;
    }
}

B、公共类方法：
public class Task {

private Handler mHandler;
private Context mContext;
private int mTaskId;

public static final int TASK_ACCEPT_ON = 0;
public static final int TASK_CONNECT_ON = 1;
public static final int TASK_CHAT_ON =2;
public static final int TASK_REC_MESSAGE = 3;
public static final int TASK_SEND_MESSAGE = 4;

private Object[] parameter;

public Task(Handler handler,Context context,int taskId,Object[] parameter) {
    this.mContext = context;
    this.mHandler = handler;
    mTaskId = taskId;
    this.parameter = parameter;
}
public Handler getHandler() {
    return mHandler;
}
public int getTaskId() {
    return  mTaskId;
}

public Object getObject(int pos) {
    if(pos<=parameter.length-1)
        return parameter[pos];
    else
        return null;
}

}
只需要在activity或者service里创建一个方法
public static void newTask(Task task) {
synchronized (tasksList) {
tasksList.add(task);
}
}
C、使用Broadcast Receiver，方法同Activity与静态注册的Broadcast Receiver类似。