Bundle之用法

---

前言

解释下安卓常用的Bundle

一、Bundle是什么？

在 Android 中，Bundle 是一种非常常用的数据结构，用于在不同组件（例如 Activity、Service、BroadcastReceiver 等）之间传递数据。Bundle 可以存储一组键值对，其中键是字符串类型，值可以是基本数据类型、String 类型、Parcelable 对象或 Serializable 对象等。Bundle 通常用于在应用程序组件之间传递数据，例如在启动一个 Activity 时传递数据。

二、Bundle示例

以下是一个使用 Bundle 的示例，将一些数据存储在 Bundle 中，并将其传递给一个新的 Activity：

val bundle = Bundle()
bundle.putString("name", "John")
bundle.putInt("age", 25)
bundle.putBoolean("isStudent", true)

val intent = Intent(this, SecondActivity::class.java)
intent.putExtras(bundle)
startActivity(intent)

在第二个 Activity 中获取 Bundle 数据的代码如下：

val extras = intent.extras
if (extras != null) {
    val name = extras.getString("name")
    val age = extras.getInt("age")
    val isStudent = extras.getBoolean("isStudent")
    // Do something with the data
}

Bundle 在内部实现中使用了 HashMap 来存储键值对。它是一个轻量级的数据结构，可以快速地存储和检索数据，适用于传递小量的数据。

三：Bundle还有以下用法：

除了上面提到的存储数据和传递数据的用法，Bundle还有以下用法：

1. 保存Activity的状态

在Activity被销毁并重新创建时，可以通过onSaveInstanceState()方法将数据保存在Bundle中，然后在onCreate()或onRestoreInstanceState()中恢复数据。

当Activity被系统销毁重建时，它的状态将丢失。为了保存和恢复这些状态，我们可以使用onSaveInstanceState()和onRestoreInstanceState()方法，这些方法允许我们在Activity重建时保存和恢复Bundle对象中的数据。

以下是一个示例Activity，在其中我们保存和恢复一个计数器的值：

class MainActivity : AppCompatActivity() {
    private var counter = 0

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

        if (savedInstanceState != null) {
            counter = savedInstanceState.getInt("counter", 0)
            textView.text = "Counter: $counter"
        }

        button.setOnClickListener {
            counter++
            textView.text = "Counter: $counter"
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putInt("counter", counter)
    }
}

在onCreate()方法中，我们检查savedInstanceState参数是否为空。如果不为空，我们从Bundle中恢复计数器的值并将其显示在屏幕上。如果为空，则我们将计数器的值设置为0。

我们还在onSaveInstanceState()方法中将计数器的值存储在Bundle中，以便在Activity重建时恢复它。

当Activity重新创建时，系统会调用onRestoreInstanceState()方法，并将保存的Bundle对象作为参数传递给它。如果我们需要从Bundle中恢复其他数据，我们可以在这个方法中执行相应的操作。

2. 向Fragment传递数据

当向Fragment传递数据时，可以将数据封装在Bundle中，然后通过setArguments()方法传递给Fragment，Fragment在onCreate()中可以通过getArguments()方法获取数据。
这是在Android中向Fragment传递数据的常见方式，具体步骤如下：
1.创建一个Bundle对象，并使用put方法将数据存储在Bundle中，例如：

val bundle = Bundle()
bundle.putString("key", "value")

2.创建Fragment实例，并调用setArguments()方法将Bundle对象传递给Fragment，例如：

val fragment = MyFragment()
fragment.arguments = bundle

3.在Fragment的onCreate()方法中获取Bundle对象，并从中获取数据，例如：

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    val bundle = arguments
    val value = bundle?.getString("key")
}

注意事项：
1.需要在调用Fragment的任何其他方法之前调用setArguments()方法。 2.在Fragment中获取Bundle时，需要检查是否为null，因为在没有参数传递给Fragment的情况下，getArguments()方法将返回null。 3.数据类型不限于字符串，可以使用put方法存储任何支持的数据类型。

当使用Bundle传递数据给Fragment时，可以使用putXXX()方法存储各种类型的数据，例如：

val bundle = Bundle()
bundle.putInt("int_key", 123)
bundle.putString("string_key", "Hello, World!")
bundle.putBoolean("boolean_key", true)
bundle.putSerializable("serializable_key", MySerializableObject())
bundle.putParcelable("parcelable_key", MyParcelableObject())

这里的putXXX()方法支持的数据类型包括：int、float、double、long、boolean、String、Serializable、Parcelable 等。需要注意的是，对于自定义的对象，需要实现 Serializable 或 Parcelable 接口才能使用putSerializable()或putParcelable()方法进行存储。
对于自定义的对象，需要实现 Serializable 或 Parcelable 接口才能使用putSerializable()或putParcelable()方法进行存储。 举个例子
假设有一个自定义的数据类Person，包含两个属性name和age，需要实现Parcelable接口以在Bundle中存储：

class Person(val name: String, val age: Int) : Parcelable {

    constructor(parcel: Parcel) : this(
        parcel.readString()!!,
        parcel.readInt()
    )

    override fun writeToParcel(parcel: Parcel, flags: Int) {
        parcel.writeString(name)
        parcel.writeInt(age)
    }

    override fun describeContents(): Int {
        return 0
    }

    companion object CREATOR : Parcelable.Creator<Person> {
        override fun createFromParcel(parcel: Parcel): Person {
            return Person(parcel)
        }

        override fun newArray(size: Int): Array<Person?> {
            return arrayOfNulls(size)
        }
    }
}

然后可以通过putParcelable()方法将Person对象存储到Bundle中：

val person = Person("Sjx", 25)
val bundle = Bundle()
bundle.putParcelable("person_key", person)

然后在Fragment中可以通过getParcelable()方法获取Person对象：

val person = arguments?.getParcelable<Person>("person_key")

3. Intent传递数据

在Activity之间传递数据时，可以通过Intent的putExtras()方法将数据封装在Bundle中，然后通过Intent传递给另一个Activity，另一个Activity在onCreate()中可以通过getIntent().getExtras()方法获取数据。
在 Android 中，使用 Intent 可以启动一个新的 Activity，同时也可以在 Activity 之间传递数据。putExtras()方法可以将数据封装在 Bundle 中，Bundle 是一种键值对集合，可以存储各种类型的数据。
当启动一个新的 Activity 时，可以将 Bundle 对象放入 Intent 中传递给新的 Activity，这个 Bundle 对象包含了需要传递的数据。在新的 Activity 中，可以通过 getIntent().getExtras() 方法获取到传递过来的 Bundle 对象，然后从 Bundle 中获取相应的数据。
在 Activity 之间传递数据时，建议使用 putExtra() 和 getExtra() 系列方法。这些方法会根据数据类型自动选择适当的 put 和 get 方法，简化了数据传递的代码。同时，也可以使用 putExtras() 和 getExtras() 方法，它们是 putExtra() 和 getExtra() 方法的基础。
举个栗子：
假设有两个Activity：Activity A和Activity B，现在需要在Activity A中传递一个字符串数据到Activity B中。代码实现如下：

在Activity A中：

val intent = Intent(this, ActivityB::class.java)
val bundle = Bundle()
bundle.putString("key", "hello world")
intent.putExtras(bundle)
startActivity(intent)

在Activity B中：

val bundle = intent.extras
if (bundle != null) {
    val message = bundle.getString("key")
    Log.d("MainActivity", message)
}

这里使用Bundle将数据封装并通过Intent传递给Activity B，Activity B在onCreate()方法中获取传递过来的Bundle并获取数据。

4. 多进程通信

在多进程通信中，可以使用Bundle来传递数据，例如在使用AIDL进行进程间通信时，可以将数据封装在Bundle中，然后通过AIDL接口将Bundle传递给另一个进程。
关于aidl的通信例子我在以前一篇文章中写过：
安卓AIDL的使用
上面文章里传递数据是使用intent，其实bundle也可以。
这里举个Bundle来aidl中传递数据的例子：
是的，Bundle也可以在多进程通信中使用，特别是在使用AIDL（Android Interface Definition Language）时。AIDL是一种基于接口定义的IPC（Inter-Process Communication，进程间通信）机制，它允许不同进程之间的应用程序进行通信和交互。

在AIDL中，我们可以定义接口和方法，然后通过这些方法实现进程间通信。当我们需要在不同进程之间传递数据时，可以将数据封装在Bundle中，然后通过AIDL接口将Bundle传递给另一个进程。这样可以保证数据的安全性和完整性。

下面是一个简单的例子，展示了如何在AIDL中使用Bundle进行数据传递：

// AIDL接口定义
interface IMyAidlInterface {
    fun sendData(data: Bundle): Boolean
}

// 客户端代码
val myService = Intent().setComponent(ComponentName("com.sjx.myapp", "com.sjx.myapp.MyService"))
bindService(myService, object : ServiceConnection {
    override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
        val myAidlInterface = IMyAidlInterface.Stub.asInterface(service)
        val data = Bundle()
        data.putString("key", "value")
        myAidlInterface.sendData(data)
    }
    override fun onServiceDisconnected(name: ComponentName?) {}
}, Context.BIND_AUTO_CREATE)

// 服务端代码
class MyService : Service() {
    override fun onBind(intent: Intent?): IBinder? {
        return object : IMyAidlInterface.Stub() {
            override fun sendData(data: Bundle?): Boolean {
                // 处理数据
                return true
            }
        }
    }
}

在上面的代码中，客户端通过调用AIDL接口的sendData()方法，将数据封装在Bundle中，并传递给服务端。服务端通过AIDL接口接收到Bundle，然后进行数据处理。
除了 AIDL（Android Interface Definition Language）外，还有一些其他的进程间通信（IPC）机制，例如使用 Messenger、ContentProvider、BroadcastReceiver、Socket 等。这些机制也可以使用 Bundle 来传递数据。例如，使用 Messenger 进行 IPC 时，可以将消息封装在 Bundle 中，然后通过 Messenger 将 Bundle 传递给另一个进程。

总结

总之，Bundle可以用于在不同组件或线程之间传递数据，具有很广泛的应用场景。