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

依然飯特稀西發表於2020-10-26
API

背景

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

  1. 呼叫startActivityForResult方法啟動
 startActivityForResult(intent,1)
  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返回的資料。

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

相關文章