Можно ли при открытии фрагмента засунуть в передаваемые данные 15 мегабайт?

Краткий ответ

Нет, передавать 15 МБ данных через аргументы фрагмента (Bundle) — крайне плохая практика, которая с высокой вероятностью приведет к TransactionTooLargeException.

Технические ограничения

Ограничения Bundle/Intent

Аргументы фрагмента упаковываются в Bundle, который передается через IPC (межпроцессное взаимодействие) между компонентами. Система Android накладывает жесткие ограничения:

1. Общее ограничение транзакции: ~1 МБ (точный лимит варьиется от 512 КБ до 2 МБ в зависимости от версии Android и устройства)
2. Binder буфер: данные передаются через Binder с фиксированным размером буфера (обычно 1 МБ на весь процесс)
3. Транзакции включают всю цепочку: данные проходят через ActivityManagerService, что создает дополнительную нагрузку

Что происходит при превышении лимита

// Пример кода, который вызовет проблему
val largeData = ByteArray(15 * 1024 * 1024) // 15 МБ
val fragment = MyFragment().apply {
    arguments = Bundle().apply {
        putByteArray("huge_data", largeData)
    }
}

// При попытке транзакции получим:
// android.os.TransactionTooLargeException: data parcel size 15728680 bytes

Правильные подходы для передачи больших данных

1. Использование ViewModel с SharedViewModel

Для передачи данных между фрагментами в пределах одного Activity:

class SharedViewModel : ViewModel() {
    private val _largeData = MutableLiveData<ByteArray>()
    val largeData: LiveData<ByteArray> get() = _largeData
    
    fun setLargeData(data: ByteArray) {
        _largeData.value = data
    }
}

// В первом фрагменте
viewModel.setLargeData(largeData)

// Во втором фрагменте (в том же Activity)
private val sharedViewModel: SharedViewModel by activityViewModels()
sharedViewModel.largeData.observe(viewLifecycleOwner) { data ->
    // работаем с данными
}

2. Хранение во временном хранилище

Для передачи между разными компонентами:

object TemporaryStorage {
    private val storage = mutableMapOf<String, Any>()
    
    fun put(key: String, data: Any) {
        storage[key] = data
    }
    
    fun <T> get(key: String): T? {
        return storage.remove(key) as? T
    }
}

// Передача
TemporaryStorage.put("large_data_key", largeData)

// Получение (с обязательной очисткой после использования)
val data: ByteArray? = TemporaryStorage.get("large_data_key")

3. Сохранение в файловую систему или БД

Для действительно больших данных или долговременного хранения:

// Запись во внутреннее хранилище
val file = File(context.filesDir, "temp_large_data.dat")
file.outputStream().use { stream ->
    stream.write(largeData)
}

// Передача только пути в аргументах
val fragment = MyFragment().apply {
    arguments = Bundle().apply {
        putString("data_path", file.absolutePath)
    }
}

// Чтение во фрагменте
val path = arguments?.getString("data_path")
val data = File(path).readBytes()

4. Использование ContentProvider или FileProvider

Для передачи между процессами:

// Создание временного URI через FileProvider
val file = File(context.filesDir, "temp.dat")
val uri = FileProvider.getUriForFile(
    context,
    "${context.packageName}.provider",
    file
)

// Передача URI в аргументах
arguments = Bundle().apply {
    putParcelable("data_uri", uri)
}

Рекомендации по проектированию

Когда что использовать:

• < 1 МБ: можно использовать аргументы Bundle
• 1-10 МБ: ViewModel или временное хранилище
• > 10 МБ: файловая система, БД, или пересмотр архитектуры

Лучшие практики:

1. Ленивая загрузка: загружайте данные только когда они действительно нужны
2. Потоковая обработка: обрабатывайте данные частями, не загружая все в память
3. Кэширование: используйте кэш для повторного использования данных
4. Оптимизация формата: сжимайте данные, используйте эффективные форматы (Protocol Buffers вместо JSON)

Вывод

Передача 15 МБ через аргументы фрагмента технически невозможна из-за архитектурных ограничений Android. Вместо этого следует использовать ViewModel для данных в пределах одного Activity, временное файловое хранилище для больших объемов, или пересмотреть архитектуру приложения, чтобы избежать необходимости передавать такие большие данные целиком. Правильный выбор подхода зависит от конкретного сценария использования и жизненного цикла данных.