再見！onActivityResult！你好，Activity Results API！-有解無憂

背景

在Android應用程式開發中，啟動一個Activity不一定是單項操作，從啟動的Activity獲取資料是常見的場景，最傳統的方式是通過Intent攜帶資料，然后使用startActivityForResult方法來啟動下一個Activity，然后通過onActivityResult來接識訓傳的資料，代碼如下：

呼叫startActivityForResult方法啟動

 startActivityForResult(intent,1)

實作onActivityResult方法

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if(requestCode == 1 && resultCode == Activity.RESULT_OK){
            // 處理第二個頁面帶回的資料
        }
}

以上方式，onActivityResult就能獲取從上一個界面回傳的資料，這種方式非常有用，不僅能同一個應用中，也可以從其他應用中獲取資料，比如我們常見的，呼叫系統相機、相冊獲取照片，獲取系統通訊錄等，

但也有一些問題…

隨著應用的擴展，onActivityResult回呼方法各種嵌套、耦合嚴重、難以維護， 最常見的場景就是呼叫系統相機相冊獲取照片了，代碼可能像是如下這樣：

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        if (resultCode == Activity.RESULT_OK) {
            when (requestCode) {
                REQUEST_PERMISSION -> {
                    // 處理權限
                }
                REQUEST_CAMERA -> {
                    // 相機獲取圖片結果
                }
                REQUEST_ALBUM -> {
                    // 相冊獲取圖片結果
                }
                REQUEST_CROP -> {
                    // 系統裁剪
                }
            }
        }

        super.onActivityResult(requestCode, resultCode, data)
    }

    companion object {
        const val REQUEST_PERMISSION = 1001
        const val REQUEST_CAMERA = 1002
        const val REQUEST_ALBUM = 1003
        const val REQUEST_CROP = 1004
    }
}

各種處理結果都耦合在onActivityResult回呼里，并且還得定義一堆額外的常量REQUEST_CODE,用與判斷是哪個請求的回呼結果，

onActivityResult 現狀？

Google 可能也意識到onActivityResult的這些問題，在androidx.activity:activity:1.2.0-alpha02
和androidx.fragment:fragment:1.3.0-alpha02 中，已經廢棄了startActivityForResult和onActivityResult方法，

 /**
    * {@inheritDoc}
    *
    * @deprecated use
    * {@link #registerForActivityResult(ActivityResultContract, ActivityResultCallback)}
    * passing in a {@link StartActivityForResult} object for the {@link ActivityResultContract}.
    */
   @Override
   @Deprecated
   public void startActivityForResult(@SuppressLint("UnknownNullness") Intent intent,
           int requestCode) {
       super.startActivityForResult(intent, requestCode);
   }

 /**
    * {@inheritDoc}
    *
    * @deprecated use
    * {@link #registerForActivityResult(ActivityResultContract, ActivityResultCallback)}
    * with the appropriate {@link ActivityResultContract} and handling the result in the
    * {@link ActivityResultCallback#onActivityResult(Object) callback}.
    */
   @CallSuper
   @Override
   @Deprecated
   protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
       if (!mActivityResultRegistry.dispatchResult(requestCode, resultCode, data)) {
           super.onActivityResult(requestCode, resultCode, data);
       }
   }

可以看到，這兩個方法都被標記為了Deprecated，那這兩個方法不推薦使用了，Google推薦使用什么方式從Activity中更好的獲取資料呢？答案就是 Activity Results API

Activity Results API

Activity Results API 是 Google官方推薦的Activity、Fragment獲取資料的方式，

Activity Results API 到底怎么用？相比onActivityResult有哪些優勢？接下來，將一一為你解答，

在介紹如何使用之前，先為大家介紹Activity Results API 中兩個重要的組件：ActivityResultContract和ActivityResultLauncher，

ActivityResultContract: 協議，它定義了如何傳遞資料和如何處理回傳的資料，ActivityResultContract是一個抽象類，你需要繼承它來創建自己的協議，每個 ActivityResultContract 都需要定義輸入和輸出類，如果您不需要任何輸入，可使用 Void（在 Kotlin 中，使用 Void? 或 Unit）作為輸入型別，
ActivityResultLauncher: 啟動器，呼叫ActivityResultLauncher的launch方法來啟動頁面跳轉，作用相當于原來的startActivity()

使用 Activity Results API 在Activity之間傳遞資料

`1.` 首先，在app下的`build.gradle`中加入依賴:

implementation 'androidx.activity:activity:1.2.0-beta01'
implementation 'androidx.fragment:fragment:1.3.0-beta01'

`2.` 定義協議

新建一個Contract類，繼承自ActivityResultContract<I,O>，其中，I是輸入的型別，O是輸出的型別，需要實作2個方法，createIntent和parseResult,輸入型別I作為createIntent的引數，輸出型別O作為parseResult方法的回傳值，在下面的例子中，輸入輸出型別都是String:

 class MyActivityResultContract: ActivityResultContract<String,String>(){
        override fun createIntent(context: Context, input: String?): Intent {
            return Intent(context,SecondActivity::class.java).apply {
                putExtra("name",input)
            }
        }

        override fun parseResult(resultCode: Int, intent: Intent?): String? {
            val data = intent?.getStringExtra("result")
            return if (resultCode == Activity.RESULT_OK && data != null) data
            else null
        }

    }

如上代碼，我們在createIntent方法中創建了Intent，并且攜帶了引數name,在parseResult方法中，獲取了回傳的資料result，

`3.` 注冊協議，獲取啟動器-ActivityResultLauncher

注冊協議，使用registerForActivityResult方法，該方法由ComponentActivity或者Fragment提供,接受2個引數，第一個引數就是我們定義的Contract協議，第二個引數是一個回呼ActivityResultCallback<O>,其中O就是前面Contract的輸出型別，代碼如下：

private val myActivityLauncher = registerForActivityResult(MyActivityResultContract()){result ->
   Toast.makeText(applicationContext,result,Toast.LENGTH_SHORT).show()
   textView.text = "回傳資料：$result"
}

如上代碼，注冊了MyActivityResultContract,registerForActivityResult方法的回傳值是ActivityResultLauncher, 因此我們定義了一個myActivityLauncher,回呼方法中，result就是從上一個界面傳回的值，這里我們簡單的用Toast顯示，

`4.` 最后，呼叫啟動器的launch方法開啟界面跳轉

MainActivity中添加一個Button,點擊Button時，呼叫launch方法跳轉：

 button.setOnClickListener {
      // 開啟頁面跳轉
      myActivityLauncher.launch("Hello,技術最TOP")
 }

SecondActivity的代碼很簡單：

class SecondActivity : AppCompatActivity(){

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.second_layout)

        val name = intent.getStringExtra("name")
        textView3.text = "接收到的資料為：$name"

        button2.setOnClickListener {
            val intent = Intent().apply {
                putExtra("result","Hello，依然范特西稀，我是回傳的資料！")
            }
            setResult(Activity.RESULT_OK,intent)
            finish()
        }
    }
}

以上3步，就實作了使用新的Activity Results API 來完成Activity之間的資料傳遞，并獲取Activity回傳的資料

看一下效果:

這就完了嗎？

你可能會有疑問，雖然確實減少了代碼耦合，但是使用并不簡單啊，

確實，但這并沒有完！！！

預定義的Contract

大伙都看出來，新的Activity Results API使用起來好像有點麻煩，每次都得定義Contract，Google肯定考慮到了這個問題的，于是，Google 預定義了很多Contract,把你們能想到的使用場景基本上都想到了，它們都定義在類ActivityResultContracts中,有以下這些Contract:

StartActivityForResult() 
RequestMultiplePermissions()
RequestPermission()
TakePicturePreview()
TakePicture()
TakeVideo()
PickContact()
CreateDocument()
OpenDocumentTree()
OpenMultipleDocuments()
OpenDocument()
GetMultipleContents()
GetContent()

下面分別介紹一下這些Contract:

StartActivityForResult: 通用的Contract,不做任何轉換，Intent作為輸入，ActivityResult作為輸出，這也是最常用的一個協定，
RequestMultiplePermissions：用于請求一組權限
RequestPermission: 用于請求單個權限
TakePicturePreview: 呼叫MediaStore.ACTION_IMAGE_CAPTURE拍照，回傳值為Bitmap圖片
TakePicture: 呼叫MediaStore.ACTION_IMAGE_CAPTURE拍照，并將圖片保存到給定的Uri地址，回傳true表示保存成功，
TakeVideo: 呼叫MediaStore.ACTION_VIDEO_CAPTURE 拍攝視頻，保存到給定的Uri地址，回傳一張縮略圖，
PickContact: 從通訊錄APP獲取聯系人
GetContent: 提示用選擇一條內容，回傳一個通過ContentResolver#openInputStream(Uri)訪問原生資料的Uri地址（content://形式），默認情況下，它增加了Intent#CATEGORY_OPENABLE, 回傳可以表示流的內容，
CreateDocument: 提示用戶選擇一個檔案，回傳一個(file:/http:/content:)開頭的Uri，
OpenMultipleDocuments: 提示用戶選擇檔案（可以選擇多個），分別回傳它們的Uri，以List的形式，
OpenDocumentTree: 提示用戶選擇一個目錄，并回傳用戶選擇的作為一個Uri回傳，應用程式可以完全管理回傳目錄中的檔案，

上面這些預定義的Contract中，除了StartActivityForResult和RequestMultiplePermissions之外，基本都是處理的與其他APP互動，回傳資料的場景，比如，拍照，選擇圖片，選擇聯系人，打開檔案等等，使用最多的就是StartActivityForResult和RequestMultiplePermissions了，

有了這些預定義的Contract, Activity之間傳遞資料就簡單多了，比如，前面的例子，可以簡化成這樣：

1. 注冊協議，獲取ActivityResultLauncher:

 private val myActivityLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()){ activityResult ->  
        if(activityResult.resultCode == Activity.RESULT_OK){
            val result = activityResult.data?.getStringExtra("result")
            Toast.makeText(applicationContext,result,Toast.LENGTH_SHORT).show()
            textView.text = "回傳資料：$result"
        }
    }

2. 構造需要傳遞的資料，啟動頁面跳轉

 button.setOnClickListener {
        val  intent = Intent(this,SecondActivity::class.java).apply {
             putExtra("name","Hello,技術最TOP")
        }
        myActivityLauncher.launch(intent)
}

OK，就是這么簡單！！！

在比如，我們的權限，申請，請看代碼：

request_permission.setOnClickListener {
    requestPermission.launch(permission.BLUETOOTH)
}

request_multiple_permission.setOnClickListener {
    requestMultiplePermissions.launch(
        arrayOf(
            permission.BLUETOOTH,
            permission.NFC,
            permission.ACCESS_FINE_LOCATION
        )
    )
}

// 請求單個權限
private val requestPermission =
    registerForActivityResult(ActivityResultContracts.RequestPermission()) { isGranted ->
        // Do something if permission granted
        if (isGranted) toast("Permission is granted")
        else toast("Permission is denied")
    }

// 請求一組權限
private val requestMultiplePermissions =
    registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { permissions : Map<String, Boolean> ->
        // Do something if some permissions granted or denied
        permissions.entries.forEach {
            // Do checking here
        }                                                                             
}

有了這個，我們就可以拋棄所有的第三方權限請求框架，只需要將這兩個Contract放到BaseActivity中，或者抽取到一個單獨的類中，就能隨時隨地申請權限，是不是很方便！！！

在非Activity/Fragment的類中接收Activity的結果

在Activity和Fragment中，我們能直接使用registerForActivityResultAPI ，那是因為ConponentActivity和Fragment基類實作了ActivityResultCaller 介面,在非Activity/Fragment中，如果我們想要接收Activity回傳的資料，可以直接使用 ActivityResultRegistry 來實作，

比如，用一個單獨的類來實作協議的注冊和啟動器的啟動：

    class MyLifecycleObserver(private val registry : ActivityResultRegistry)
            : DefaultLifecycleObserver {
        lateinit var getContent : ActivityResultLauncher<String>

        fun onCreate(owner: LifecycleOwner) {
            getContent = registry.register("key", owner, GetContent()) { uri ->
                // Handle the returned Uri
            }
        }

        fun selectImage() {
            getContent("image/*")
        }
    }

    class MyFragment : Fragment() {
        lateinit var observer : MyLifecycleObserver

        override fun onCreate(savedInstanceState: Bundle?) {
            // ...

            observer = MyLifecycleObserver(requireActivity().activityResultRegistry)
            lifecycle.addObserver(observer)
        }

        override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
            val selectButton = view.findViewById<Button>(R.id.select_button)

            selectButton.setOnClickListener {
                // Open the activity to select an image
                observer.selectImage()
            }
        }
    }

示例中，我們在MyLifecycleObserver中實作協議注冊和啟動器啟動，為什么要實作LifecycleObserver 呢？因為，使用生命周期組件，LifecycleOwner 會在 Lifecycle 被銷毀時自動移除已注冊的啟動器，不過，如果 LifecycleOwner 不存在，則每個 ActivityResultLauncher 類都允許您手動呼叫 unregister() 作為替代，但在使用ActivityResultRegistry時，Google官方強烈建議我們使用可接受LifecycleOwner 作為引數的 API，

Activity和Fragment中為什么不需要手動呼叫unregister()呢？,因為ComponentActivity和Fragment已經實作了LifecycleObserver，

ComponentActivity原始碼在這里：

Fragment中原始碼在這里：

總結

新的Activity Result API提供了一種執行許多常見任務的簡便方法，比如我們呼叫第三方APP 獲取資料，請求權限、拍照、選圖片、獲取聯系人等等，除此之外，降低了代碼的耦合，減少了樣板代碼（比如，定義requestCode常量），另外，startActivityForResult和onActivityResult已經被廢棄，官方也是強烈建議使用這種方式來進行資料傳遞并獲取Activity回傳的資料，

還沒用起來的，趕快使用起來，賊香！！！祝大家編碼愉快！！！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/195191.html

標籤：java

上一篇：Android學習筆記（五）——EditView

下一篇：LruCache 的使用及原始碼決議

再見！onActivityResult！你好，Activity Results API！

背景

onActivityResult 現狀？

Activity Results API

使用 Activity Results API 在Activity之間傳遞資料

1. 首先，在app下的build.gradle中加入依賴:

2. 定義協議

3. 注冊協議，獲取啟動器-ActivityResultLauncher