新版本Android ViewModel和获取Activity返回结果的方法

1 新版本Android ViewModel构造

1.1 ViewModel继承自androidx.lifecycle.ViewModel

1.1.1 ViewModel中的数据在重建Activity时无需存储

ViewModel的子类构造方法无参数

public class MyViewModel extends ViewModel {  
  public MyViewModel(){    
  }
}
//构造ViewModel,每次获取创建ViewModel的时候都会创建一个新的。
ViewModel viewModel = new ViewModelProvider(this).get(MyViewModel.class);

1.1.1 ViewModel中的数据在重建Activity时需存储

ViewModel的子类构造方法带一个SavedStateHandle类型参数,用于存储重建Activity时所需的数据

public class MyViewModel extends ViewModel {  
  public MyViewModel(SavedStateHandle savedStateHandle){    
  }
}
//构造ViewModel
ViewModel viewModel = new ViewModelProvider(new SavedStateViewModelFactory(getApplication(), this)).get(MyViewModel.class);

1.2 ViewModel继承自androidx.lifecycle.AndroidViewModel

ViewModel的子类构造方法带一个Application类型参数,同时子类自带getApplication()函数

public class MyViewModel extends androidx.lifecycle.AndroidViewModel {  
  public MyViewModel(Application application){    
  }
}

//构造ViewModel,全局单例只有一个,如果owner相同，则Activity和Fragment会共享这个viewModel
this.viewModel = new ViewModelProvider(this,new ViewModelProvider.AndroidViewModelFactory(this.getApplication()) ).get(MainViewModel.class);

2 新版本获取Activity返回结果

基本概念:

• Intent:用于应用间的交互与通讯.
  
• Bundle:用于交互时存取数据.
  

总结:Intent旨在交互与通讯,Bundle旨在存取数据.

• 虽然Intent可以直接存取数据,但是它内部也是通过Bundle来存取数据,因此不建议直接使用Intent存取数据.
• 既然使用Bundle,要传递复杂的对象时对象必须支持序列化.

假设有两个Activity,它们分别用A和B表示.

2.1 老版本

从A打开B,然后在A中调用startActivityForResult打开B并获取返回结果.

startActivityForResult已经标注为已过时(Deprecated),开发不应该再使用startActivityForResult函数.

2.2 新版本

从A打开B,B传递给A一个对象,用对象的目的是演示返回一个复杂的数据类型.实际上这个对象仅有一个int参数,简化时可以直接使用Bundle的getInt函数.

2.3.1 创建一个可序列化的对象,用于在Activity之间传递.

import android.os.Parcel;
import android.os.Parcelable;

import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.NotNull;

public class IntParameter implements Parcelable {
    private int value;

    public ThreadIntParameter(int value) {
        this.value = value;
    }

    public void setValue(int val) {
        this.value = val;
    }

    public int getValue() {
        return value;
    }

    public ThreadIntParameter(@NotNull Parcel in) {
        value = in.readInt();
    }

    @Override
    public void writeToParcel(@NotNull Parcel dest, int flags) {
        dest.writeInt(value);
    }

    @Override
    public int describeContents() {
        return 0;
    }

    public static final Creator<ThreadIntParameter> CREATOR = new Creator<ThreadIntParameter>() {
        @NotNull
        @Contract("_ -> new")
        @Override
        public ThreadIntParameter createFromParcel(Parcel in) {
            return new ThreadIntParameter(in);
        }

        @NotNull
        @Contract(value = "_ -> new", pure = true)
        @Override
        public ThreadIntParameter[] newArray(int size) {
            return new ThreadIntParameter[size];
        }
    };
}

2.3.2 回调类型.

继承自androidx.activity.result.contract.ActivityResultContract.

注意ActivityResultContract是一个抽象模板类,原型如下:

public abstract class ActivityResultContract<I, O>

I:表示输入的参数类型.也就是传递给B的类型,一般为Intent或Void(V大写).Void时要注意调用launch(null)时将参数设置为null,否则填写对应的类型;

O:表示输出的参数类型.也就是B操作完成后回调时给A的数据类型.

/**
 * Activity返回结果回调类型
 * 其中IntParameter为自己定义的类型
 */
public class ActivityResultContractT extends ActivityResultContract<Intent, IntParameter> {

  /**
     * 说明怎样启动Activity和设置传递的参数
     * @param context   Activity A
     * @param input    要传递给Activity B的参数.也就是launch的参数;
     * @return
     */
    @NonNull
    @Override
    public Intent createIntent(@NonNull Context context, Intent input) {
        if (null == input) { //如果launch(null)时,需要重新创建input
            input = new Intent(context, ActivityB.class);
            Bundle bundle = new Bundle();
            bundle.putParcelable("int_parameter", new IntParameter(100));
            input.putExtra("bundle", bundle);
        }
        return input;
    }

    /**
     * Activity B已经处理完成,通过调用setResult函数返回结果给 Activity A
     * 在Activity B中setResult(Activity.RESULT_OK, intent)返回结果
     * @param resultCode   setResult函数中的第一个参数
     * @param intent   setResult函数中的第二个参数
     * @return第
     *
     */
    @Override
    public IntParameter parseResult(int resultCode, @Nullable Intent intent) {
        if(resultCode != Activity.RESULT_OK)
            return null;
        Bundle bundle = intent.getBundleExtra("bundle");
        if( null == bundle)
            return null;
        return bundle.getParcelable("int_parameter");
    }
}

2.3.3 使用方法

Activity A

Intent intent = new Intent(this, ActivityB.class);
Bundle bundle = new Bundle();
bundle.putParcelable("int_parameter", new IntParameter(100));
input.putExtra("bundle", bundle);
ActivityResultLauncher<Intent> launcher = registerForActivityResult(new ActivityResultContractT(), new ActivityResultCallback<IntParameter>() {
   @Override
   public void onActivityResult(IntParameter result) {
      if( null != result )
        int x = result.getValue(); //x=1024
   }
});
launcher.launch(intent);

Activity B

//将传递过来的参数修改为1024后返回
Intent in = getIntent();
Bundle bundle = in.getBundleExtra("bundle");
IntParameter param;
if (null == bundle) {
  param = new IntParameter(0);
} else {
   param = bundle.getParcelable("int_parameter");
   param = (null == param ? new IntParameter(0) : param);
}
param.setValue(1024);
//返回数据给Activity A
Intent out = new Intent();
Bundle bundle = new Bundle();
bundle.putParcelable("int_parameter", param);
out.putExtra("bundle", bundle);
setResult(Activity.RESULT_OK, out);
finish();