因为项目中突然需要用到两个activity之间进行数据交互，脑子里第一想法就是用EventBus来实现，但是需求仅仅只有2个activity之间进行交互（神奇的需求？），所以考虑几百年前用过的startActivityForResult来实现，但撸代码的时候发现，它过时了！！！

 如果你将项目中的appcompat库升级到1.3.0或更高的版本,startActivityForResult()方法就已经显示被废弃了，因为项目中引入的就是1.3.0的

所以才发现过时的，如果版本低了，我还蒙在鼓里。

     废弃了，自然有替代品。新欢胜旧爱，官网建议用Activity Result API来取代startActivityForResult了。

   OK，先回顾下startActivityForResult的用法，它主要作用就是用于两个activity之间传递数据，例如：

  1. class MainActivity : AppCompatActivity() {
  2.     override fun onCreate(savedInstanceState: Bundle?) {
  3.         super.onCreate(savedInstanceState)
  4.         setContentView(R.layout.activity_main)
  5.         findViewById<Button>(R.id.btn1).setOnClickListener {
  6.             val intent = Intent(this, SecondActivity::class.java)
  7.             val  bundle=Bundle()
  8.             bundle.putString("key","from MainActivity data")
  9.             intent.putExtras(bundle)
  10.             startActivityForResult(intent, 1)
  11.         }
  12.  
  13.     }
  14.  
  15.     override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
  16.         super.onActivityResult(requestCode, resultCode, data)
  17.         when (requestCode) {
  18.             1 ->
  19.                 if (resultCode == RESULT_OK) {
  20.                     val stringExtra = data?.getStringExtra("data")
  21.                     Log.e("TAG", "onActivityResult: $stringExtra")
  22.                 }
  23.         }
  24.     }
  25. }

在MainActivity里通过点击一个按钮，往Bundle里添加数据，然后放到intent里，通过startActivityForResult向SecondActivity传递数据，并且重写了onActivityResult（）方法去解析SecondActivity返回来的数据。

SecondActivity就稍微简单点了，先获取到MainActivity传递过来的数据，然后再点击一个按钮，发送新的数据返回给MainActivity。

  1. class SecondActivity : AppCompatActivity() {
  2.     override fun onCreate(savedInstanceState: Bundle?) {
  3.         super.onCreate(savedInstanceState)
  4.         setContentView(R.layout.activity_second)
  5.         val extras = intent.extras
  6.         val data = extras?.getString("key")
  7.         Log.e("SecondActivity", "onCreate: $data" )
  8.         findViewById<Button>(R.id.btn).setOnClickListener {
  9.             val intent = Intent()
  10.             intent.putExtra("data", "data from SecondActivity")
  11.             setResult(RESULT_OK, intent)
  12.             finish()
  13.         }
  14.     }
  15. }

以上代码应该没毛病，早几年每个项目百分百会用到的.

结果显而易见，从MainActivity点击按钮跳转到SecondActivity界面会打印 

SecondActivity: onCreate: from MainActivity data

然后在SecondActivity点击按钮回到MainActivity打印

TAG: onActivityResult: data from SecondActivity

接着我们学习一下如何使用Activity Result API来实现同样的功能。

  1. import androidx.activity.result.contract.ActivityResultContracts
  2.  
  3. class MainActivity : AppCompatActivity() {
  4.  
  5.     private val requestDataLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
  6.         if (result.resultCode == RESULT_OK) {
  7.             val data = result.data?.getStringExtra("data")
  8.             Log.e("TAG", "registerForActivityResult: $data")
  9.         }
  10.     }
  11.  
  12.     override fun onCreate(savedInstanceState: Bundle?) {
  13.         super.onCreate(savedInstanceState)
  14.         setContentView(R.layout.activity_main)
  15.         findViewById<Button>(R.id.btn1).setOnClickListener {
  16.             val intent = Intent(this, SecondActivity::class.java)
  17.             val bundle = Bundle()
  18.             bundle.putString("key", "from MainActivity data")
  19.             intent.putExtras(bundle)
  20.             requestDataLauncher.launch(intent)
  21.            // startActivityForResult(intent, 1)
  22.         }
  23.  
  24.     }
  25. }

SecondActivity完全不用动，代码不用变。主要看下MainActivity的代码改动，移除了对onActivityResult()方法的重写，而是调用registerForActivityResult()方法来注册一个对Activity结果的监听。registerForActivityResult()方法接收两个参数，第一个参数是一种Contract类型，由于我们是希望从另外一个Activity中请求数据，因此这里使用了StartActivityForResult这种Contract。第二个参数是一个Lambda表达式，当有结果返回时则会回调到这里，然后我们在这里获取并处理数据即可。

  1.   @NonNull
  2.     @Override
  3.     public final <I, O> ActivityResultLauncher<I> registerForActivityResult(
  4.             @NonNull ActivityResultContract<I, O> contract,
  5.             @NonNull ActivityResultCallback<O> callback) {
  6.         return registerForActivityResult(contract, mActivityResultRegistry, callback);
  7.     }

从源码可以看到registerForActivityResult返回的是ActivityResultLauncher对象，

 可以看到该对象当中有launch()方法可以用于去启用Intent。所以我们的代码中就能使用

 requestDataLauncher.launch(intent)去进行调整，从而代替startActivityForResult()方法。

以上代码运行效果和startActivityForResult()的完全一致。如果说单纯从数据跳转传递来讲，这也差不多呀。没啥优势的。

再来个例子，多任务之间进行区分。

  1. class MainActivity : AppCompatActivity() {
  2.  
  3.     override fun onCreate(savedInstanceState: Bundle?) {
  4.         super.onCreate(savedInstanceState)
  5.         setContentView(R.layout.activity_main)
  6.         findViewById<Button>(R.id.btn1).setOnClickListener {
  7.             val intent = Intent(this, SecondActivity::class.java)
  8.             val bundle = Bundle()
  9.             bundle.putString("key", "from MainActivity data1")
  10.             intent.putExtras(bundle)
  11.             startActivityForResult(intent, 1)
  12.         }
  13.         findViewById<Button>(R.id.btn2).setOnClickListener {
  14.             val intent = Intent(this, ThreeActivity::class.java)
  15.             val bundle = Bundle()
  16.             bundle.putString("key", "from MainActivity data2")
  17.             intent.putExtras(bundle)
  18.             startActivityForResult(intent, 2)
  19.         }
  20.     }
  21.  
  22.     override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
  23.         super.onActivityResult(requestCode, resultCode, data)
  24.         when (requestCode) {
  25.             1 -> {
  26.                 if (resultCode == RESULT_OK) {
  27.                     val stringExtra = data?.getStringExtra("data")
  28.                     Log.e("TAG", "onActivityResult: 1$stringExtra")
  29.                 }
  30.             }
  31.             2 ->
  32.                 if (resultCode == RESULT_OK) {
  33.                     val stringExtra = data?.getStringExtra("data")
  34.                     Log.e("TAG", "onActivityResult: 2 $stringExtra")
  35.                 }
  36.         }
  37.     }
  38. }

通过设置不同的requestCode值来区分传递不同界面的数据。因此获取返回的数据时也要在onActivityResult()方法当中，再对requestCode进行判断。这种传统的写法，大家应该都很熟悉，也见得多了，那么看下Activity Result API是怎么实现这种多任务的数据传递接收的

  1. class MainActivity : AppCompatActivity() {
  2.  
  3.     private val requestDataOneLauncher =
  4.         registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
  5.             if (result.resultCode == RESULT_OK) {
  6.                 val data = result.data?.getStringExtra("data")
  7.                 Log.e("TAG", "registerForActivityResult:one  $data")
  8.             }
  9.         }
  10.     private val requestDataTwoLauncher =
  11.         registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
  12.             if (result.resultCode == RESULT_OK) {
  13.                 val data = result.data?.getStringExtra("data")
  14.                 Log.e("TAG", "registerForActivityResult:two  $data")
  15.             }
  16.         }
  17.     override fun onCreate(savedInstanceState: Bundle?) {
  18.         super.onCreate(savedInstanceState)
  19.         setContentView(R.layout.activity_main)
  20.         findViewById<Button>(R.id.btn1).setOnClickListener {
  21.             val intent = Intent(this, SecondActivity::class.java)
  22.             val bundle = Bundle()
  23.             bundle.putString("key", "from MainActivity data1")
  24.             intent.putExtras(bundle)
  25.             requestDataOneLauncher.launch(intent)
  26.           
  27.         }
  28.         findViewById<Button>(R.id.btn2).setOnClickListener {
  29.             val intent = Intent(this, SecondActivity::class.java)
  30.             val bundle = Bundle()
  31.             bundle.putString("key", "from MainActivity data2")
  32.             intent.putExtras(bundle)
  33.             requestDataTwoLauncher.launch(intent)
  34.  
  35.         }
  36.     }
  37. }

通过ActivityResultLauncher不同对象处理不同的任务数据，无需借助requestCode数字来判断，万一数字多了不对，还容易出错。所以Activity Result API存在是有一定的合理性的。