Activity工作中的方方面面

一、Activity

Activity:android四大组件之一，是与用户交互的接口。通过Activity的栈的方式来管理Activity的，不在栈的顶端，可能被系统销毁回收。比如说这个处于前台的Activity1总是在栈的顶端，如果Activity1因为异常或者内存不足原因，被销毁的时候，栈内下方Activity2将会激活。激活的Activity将会到栈顶，将顶端的Activity1顶掉。当新的Activity启动的时候，栈顶的Activity将会下沉。通过在不断更改栈顶的Activity的变化，也是在更改Activity的状态的变化。
四种形态：

Active: Activity处于栈顶可见状态可以与用户交互。
Paused: 可见但不可交互，失去焦点。只是失去交互而已，其它的状态和成员变量都是保存的。只有在内存不足的时候，它才有可能被销毁掉。正常的情况下它不会被系统回收。
Stopped： 不可见一个Activity被另外一个Activity完全覆盖，不是被透明的Activity的覆盖。在内存足够的情况下，它的状态和成员变量都是保存的，内存不足的时候，它才有可能被销毁掉
killed: 系统回收掉

二、Activity 生命周期

Android系统是通过Activity栈的形式来管理Activity。Activity的四种状态 Active Paused Stopped killed。
Activity正常的情况下：Activity 是如何管理它的创建和销毁的呢？

Activity 是如何管理它的创建和销毁的呢？
onCreate: Activity创建的时候调用的，初始化操作。
onStart: 表示Activity在启动状态了，只是出于可见状态还没有在前台显示，无法跟用户交互。
onResume： 表示Activity已经处在前台可见了。可以与用户交互 Activity is running。
onPause: 表示Activity正在停止与OnResume成对出现的。
onStop: 一般在onPause执行完之后，立即执行这个方法。不可见在后台运行。
onDestory： 表示Activity正在被销毁一般做些回收工作。

Activity异常的情况下：系统配对发生了改变和内存不足导致的！
onSaveInstanceState: 保存当前状态的信息,以便Activity恢复的时候恢复数据。
onRestoreInstanceState: Activity重新创建之后，系统回调该方法。(数据恢复) 当里面的Bundle参数不会为空，而onCreate里面的Bundle参数可能会为空。

三、Activity之间通信

1.Intent/Bundle: (Intent: 是四大组件传播信息的纽带）

//创建用于封装数据的Bundble对象
Bundle bundle = new Bundle();
bundle.putString("name", "Mjj");
bundle.putInt("age", 18);
    
Intent intent = new Intent(OneActivity.this, SecondActivity.class);        
//将Bundle对象嵌入Intent中
intent.putExtras(bundle);
startActivity(intent);

//另外一个Activity获取数据
//intent要用this的getIntent()获取
Intent intent = getIntent();
//用intent.getXXXExtra("key-name")或是intent.getXXXExtra("key-name", default-value)获取值
String name = intent.getStringExtra("key1");
int age = intent.getIntExtra("key2", 0);
Log.d("SecondActivity", name + ":" + age);

2.类静态变量：通过类的静态变量接受到静态信息

//声明为静态file
static int age = 0;

3.全局变量: 重新声明一个类，然后再这个类中去定义全局变量值

四、Activity向Fragment传递数据

1.Bundle

//Activity端
Bundle bundle = new Bundle();
bundle.putString("ntent_d", productId);
Fragment fragment = null;
fragment.setArguments(bundle);

//Fragment端
@Override
public void onStart() {
    super.onStart();
    if(isAdded()) {  //判断Fragment已经依附Activity
        productId = getArguments().getString("ntent_d");
    }
}

2. 直接在Activity中定义方法

//Activity 中定义一个方法
public String getTitles() {
    return "getTitle";
}

//Fragment通过方法获取数据
@Deprecated
public void onAttach(Activity activity) {
    super.onAttach(activity);
    titles = ((FragmentActivity2) activity).getTitles(); //通过强转成宿主activity,就可以获取到数据
}

五、Fragment将数据传递给Activity

1. 在fragment中定义一个内部回调接口
1. fragment的方法onAttach()。
1. 调用onDetach方法，这个时候要把传递进来的activity对象释放掉

/**
* Fragment 传递数据给Activity
* @author zh-sw-weiwei
*
*/
public class Fragment3 extends Fragment implements OnClickListener{
// 2.1 定义用来与外部activity交互，获取宿主activity
private FragmentListener listener;

// 1.定义了所有activity必须实现的接口方法
public interface FragmentListener {
    void process(String str);
}

// 当Fragment 被加载到activity的时候会被回调
@Override
@Deprecated
public void onAttach(Activity activity) {
    super.onAttach(activity);
    
    if(activity instanceof FragmentListener) {
        listener = (FragmentListener) activity; // 2.2获取到宿主activity并赋值
    } else {
        throw new IllegalArgumentException("activity must implements interface");
    }
}

@Override
public void onClick(View v) {
    listener.process("我是接口"); // 3.1 执行回调
}

//把传递过来的activity对象释放掉
@Override
public void onDetach() {
    super.onDetach();
    listener = null;
}
}

 //Activity里面实现该接口
public class FragmentActivity3 extends Activity implements Fragment3.FragmentListener{

@Override
public void process(String str) {
    
}

六、Activity与Service数据通信

1.绑定服务，利用ServiceConnection类

// Service 返回一个Binder 对象给Activity
@Nullable
@Override
public IBinder onBind(Intent intent) {
    return new Binder();
}

public class Binder extends android.os.Binder {
    public void setData(String data) {
        MyService2.this.data = data;
    }
}

// Activity通过继承ServiceConnection接口，在onServiceConnected方法内获取Binder对象，进而实现数据传输
public class ServiceActivity2 extends Activity implements View.OnClickListener, ServiceConnection {
private Intent intent;
public MyService2.Binder myBinder = null;//①


@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    intent = new Intent(ServiceActivity2.this, MyService1.class);

    findViewById(R.id.btyStartService).setOnClickListener(this);
    findViewById(R.id.btyStopService).setOnClickListener(this);

}

@Override
public void onClick(View v) {
    switch (v.getId()) {
        case R.id.btyStartService://启动服务
            if (myBinder != null)
                myBinder.setData("启动服务了");//③
            break;
        case R.id.btyStopService://终止服务
            stopService(intent);
            break;

    }

}

@Override
public void onServiceConnected(ComponentName name, IBinder service) {
    myBinder = (MyService2.Binder) service;//②

}

@Override
public void onServiceDisconnected(ComponentName name) {

}

2.简单通信，利用Intent进行传值

//Activity 启动Service 利用Intent进行传值
Intent intent = new Intent(ServiceActivity1.this, MyService1.class);
intent.putExtra("data", "data");
startService(intent);

//Service 在onStartCommand方法内获取值
@Override
public int onStartCommand(final Intent intent, int flags, int startId) {
    data = intent.getStringExtra("data");
    return super.onStartCommand(intent, flags, startId);
}

3.定义一个callback接口来监听服务中的进程的变化

//Service 定义回调的Callback接口，同时在Binder对象里面提供getMyService()（获取当前Service对象）给Activity。
public class MyService3 extends Service {
    private static final String TAG = "ActivityTest";
    private Callback callback;
    public String data = "服务器正在执行";

    public MyService3() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        Log.d(TAG, "服务器已绑定");
        return new Binder();
    }

    public class Binder extends android.os.Binder {
        public void setData(String data) {
            MyService3.this.data = data;
        }

        public MyService3 getMyService() {
            return MyService3.this;
        }
    }


    @Override
    public int onStartCommand(final Intent intent, int flags, int startId) {
        data = intent.getStringExtra("data");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
    }

    @Override
    public boolean onUnbind(Intent intent) {
        return super.onUnbind(intent);
    }

    public void setCallback(Callback callback) {
        this.callback = callback;
    }

    public Callback getCallback() {
        return callback;
    }

    public interface Callback {
        void onDataChange(String data);
    }
}

//在Activity 注册该接口实现数据回调，注意的是该回调接口是在子线程运行的。
//一旦绑定成功就会执行该函数
private Handler hander = new Handler(){
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
//            textView.setText(msg.getData().getString("data"));
    }
};

//一旦绑定成功就会执行该函数
@Override
public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
    myBinder = (MyService3.Binder) iBinder;
    myBinder.getMyService().setCallback(new MyService3.Callback(){
        @Override
        public void onDataChange(String data) {
            Message msg = new Message();
            Bundle b = new Bundle();
            b.putString("data",data);
            msg.setData(b);
            hander.sendMessage(msg);
        }
    });
}

七、Activity 启动模式

开发中，一般都需要多个Activity之间的跳转，我们更希望的是Activity实例是被重用的，而不是再重新去创建一个新的Activity。
android 系统默认为启动多个Activity时，系统默认会创建多个新的Activity实例,然后按照先后的顺序放到任务栈中。当我们按back键的时候，将会将任务栈顶部的Activity移除，重复下去，直到我们任务栈为空。当它为空的时候，系统会回收整个任务栈。
四种启动模式：
1.standard: 每次启动Activity，都会在任务栈中创建一个新的实例，然后将它放到任务栈顶。不用考虑这个实例是否在栈中存在。它的onCreate onStart onResume在每次启动的时候都会调用。

1 在不指定启动模式的前提下，系统默认使用该模式启动Activity
2 每次启动一个Activity都会重写创建一个新的实例
3 它的onCreate onStart onResume在每次启动的时候都会调用。

2.singleTop: 栈顶复用。如果启动的Activity已经在栈顶，就不会创建新的Activity.而是复用已经存在栈顶的那个Activity，只有在栈顶才会复用。
如果开启的Activity在栈中存在，但不在栈顶，它依然会被创建。它的onNewIntent方法会回调。singleTop和standard都是原来的栈中新建一个实例，不会去开启新的一个任务栈的。

应用场景:IM对话框新闻客户端推送。

3.singleTask: 栈内复用模式。检测栈中是否有启动的Activity.如果存在，将启动的Activity实例放到栈顶。本来上面的Activity实例，都会被销毁。同时会回调onNewIntent方法。如果栈中不存在启动的Activity，则会创建新的Activity放到栈中。

比较适合应用在主界面的架构。

1. 首先会根据taskAffinity去寻找当前是否存在一个对应名字的任务栈 taskAffinity代表任务相关性
2 如果不存在，则会创建一个新的Task
1. 如果存在，则得到该任务栈，查找该任务栈中是否存在该Activity的实例。

4.singleInstance: 在整个android系统中只有一个实例。而且该实例会独享一个任务栈。启动的这个Activity，系统为它创建一个新的任务栈，同时会将Activity放到新的任务栈中。Activity存放在单独的任务栈里面。这个任务栈只有它一个实例存在。应用场景：呼叫来电界面。

1 以SingleInstance模式启动的Activity具有全局唯一性
2 如果在启动这样的Activity时，已经存在了一个实例
3 以SingleInstance模式启动的Activity具有独占性