Какие знаешь ограничения Bundle?

Ограничения Bundle в Android

Bundle — это механизм для передачи данных между компонентами Android (Activity, Fragment, Service). Но у этого инструмента есть серьёзные ограничения, которые нужно знать и учитывать.

1. Ограничение размера (1 MB)

Bundle имеет максимальный размер примерно 1 MB. Это один из самых критичных лимитов.

// Проблема: попытка передать большой файл
val largeData = ByteArray(2_000_000)  // 2 MB
val bundle = Bundle().apply {
    putByteArray("data", largeData)  // TransactionTooLargeException!
}
startActivity(Intent().putExtras(bundle))

// Результат: TransactionTooLargeException
// java.lang.RuntimeException: android.os.TransactionTooLargeException

Решение: использовать более крупные данные

// Способ 1: Сохранить на диск и передать путь
val file = File(context.cacheDir, "large_data.bin")
file.writeBytes(largeData)
val bundle = Bundle().apply {
    putString("file_path", file.absolutePath)
}

// Способ 2: Использовать Singleton
object DataHolder {
    var largeData: ByteArray? = null
}
DataHolder.largeData = largeData
val bundle = Bundle()  // Ничего не передаём

// Способ 3: ViewModel (рекомендуется для Activity/Fragment)
class SharedViewModel : ViewModel() {
    val largeData = MutableLiveData<ByteArray>()
}

2. Поддержка только сериализуемых типов

Bundle может содержать только определённые типы данных:

// Поддерживаемые типы:
val bundle = Bundle().apply {
    // Примитивы
    putBoolean("bool", true)
    putInt("int", 42)
    putLong("long", 123L)
    putDouble("double", 3.14)
    putFloat("float", 2.71f)
    
    // Строки
    putString("string", "Hello")
    putStringArray("strings", arrayOf("a", "b"))
    
    // Массивы примитивов
    putIntArray("intArray", intArrayOf(1, 2, 3))
    putLongArray("longArray", longArrayOf(1L, 2L))
    
    // Сериализуемые объекты
    putSerializable("serializable", myObject)
    
    // Parcelable объекты (рекомендуется)
    putParcelable("parcelable", myParcelable)
}

// Не поддерживаемые типы:
// ❌ putObject("obj", MyClass())  // Compile error
// ❌ putList("list", myList)       // Compile error (если не Parcelable)
// ❌ putMap("map", myMap)          // Compile error (если не Parcelable)

Проблема: пользовательские классы

data class User(val name: String, val age: Int)

// ❌ Это НЕ сработает
val user = User("John", 30)
val bundle = Bundle().apply {
    putSerializable("user", user)  // ClassCastException at runtime!
}

// ✅ Правильно: реализовать Parcelable
@Parcelize
data class User(val name: String, val age: Int) : Parcelable

val bundle = Bundle().apply {
    putParcelable("user", user)  // OK
}

3. Parcelable vs Serializable

Serializable — медленный и не рекомендуется:

data class User(val name: String, val age: Int) : Serializable

val bundle = Bundle().apply {
    putSerializable("user", user)  // Работает, но медленно
}

Parcelable — быстрый (рекомендуется):

// С библиотекой @Parcelize (kotlinx.parcelize)
@Parcelize
data class User(
    val name: String,
    val age: Int,
    val tags: List<String> = emptyList()
) : Parcelable

val bundle = Bundle().apply {
    putParcelable("user", user)  // Оптимально
}

4. Null безопасность

Bundle может содержать null, но нужна осторожность:

val bundle = Bundle().apply {
    putString("nullable", null)  // Сохранит null
    putString("missing", null)    // Сохранит null
}

// При получении:
val value = bundle.getString("missing")  // null (ожидаемо)
val value2 = bundle.getString("missing", "default")  // "default" (более безопасно)

// Проблема: нет типизации
val value3 = bundle.get("something")  // Any? - неизвестный тип

Решение: расширения для типобезопасности

inline fun <reified T : Parcelable> Bundle.getParcelableCompat(key: String): T? {
    return getParcelable(key, T::class.java)
}

val user = bundle.getParcelableCompat<User>("user")  // Type-safe

5. Bundle как глобальное состояние (анти-паттерн)

Проблема: неправильное использование Bundle как state holder

// ❌ Плохо: Bundle для состояния Activity
class MyActivity : AppCompatActivity() {
    private val state = Bundle()
    
    fun updateUser(user: User) {
        state.putParcelable("user", user)  // Неправильно
    }
}

// ✅ Хорошо: ViewModel для состояния
class MyViewModel : ViewModel() {
    val userLiveData = MutableLiveData<User>()
    
    fun updateUser(user: User) {
        userLiveData.value = user
    }
}

// Bundle только для сохранения/восстановления при пересоздании
override fun onSaveInstanceState(outState: Bundle) {
    super.onSaveInstanceState(outState)
    outState.putParcelable("user", viewModel.currentUser)  // OK для кратковременного сохранения
}

6. Проблемы с многоуровневыми структурами

Bundle не может содержать вложенные List/Map напрямую:

data class Data(
    val items: List<User>
)

// ❌ Это не сработает
val data = Data(listOf(user1, user2))
val bundle = Bundle().apply {
    putSerializable("data", data)  // Может отвалиться
}

// ✅ Правильно: использовать @Parcelize
@Parcelize
data class Data(
    val items: List<User>
) : Parcelable

val bundle = Bundle().apply {
    putParcelable("data", data)  // OK
}

7. Отладочные значения в Bundle

Bundle могут быть перехвачены/мониторены (security issue):

// ❌ Не передавай чувствительные данные
val bundle = Bundle().apply {
    putString("password", "secret123")  // Видна в logcat!
    putString("api_key", "my_secret_key")
}

// В logcat:
// Bundle[{password=secret123, api_key=my_secret_key}]

// ✅ Передавай токены через более безопасные каналы
val bundle = Bundle().apply {
    putString("user_id", "12345")  // OK для публичных данных
}

8. TransactionTooLargeException при Intent

Распространённая ошибка:

// ❌ Вызывает crash
val images = (1..1000).map { getImage(it) }.toByteArray()  // ~1GB
startActivity(Intent().putExtra("images", images))
// TransactionTooLargeException

// ✅ Правильный подход
ImageCache.store(images)  // Сохранить локально
startActivity(Intent().putExtra("cache_key", "my_cache"))

Чек-лист лучших практик

• Используй @Parcelize для custom классов — быстрее Serializable
• Проверяй размер данных — не более 1 MB в Bundle
• Используй ViewModel для состояния — Bundle только для сохранения/восстановления
• Не передавай List<Custom> в Bundle — оборачивай в @Parcelize класс
• Не передавай чувствительные данные через Bundle — они видны в logcat
• Обрабатывай null безопасно — используй дефолтные значения
• Для больших данных используй файловую систему или БД — не Bundle
• Альтернатива Bundle: SafeArgs (Navigation Component) — типобезопасна и удобна

Bundle — это удобный инструмент для небольших данных, но важно знать его ограничения и правильно его использовать.