Os objetos Parcelable e Bundle destinam-se ao uso em
limites de processo, como com transações IPC/Binder, entre atividades com intents e para armazenar o estado temporário durante mudanças de
configuração. Nesta página, você encontra recomendações e práticas recomendadas para usar
objetos Parcelable e Bundle.
Observação:Parcel não é um mecanismo de serialização de uso geral. Nunca armazene dados Parcel em disco nem os envie pela rede.
Como enviar dados entre atividades
Quando um app cria um objeto Intent para usar em
startActivity(android.content.Intent) ao iniciar uma nova atividade,
ele pode transmitir
parâmetros usando o método
putExtra(java.lang.String, java.lang.String).
O snippet de código a seguir mostra um exemplo de como realizar essa operação.
Kotlin
val intent = Intent(this, MyActivity::class.java).apply {
putExtra("media_id", "a1b2c3")
// ...
}
startActivity(intent)
Java
Intent intent = new Intent(this, MyActivity.class);
intent.putExtra("media_id", "a1b2c3");
// ...
startActivity(intent);
O SO organiza o Bundle subjacente do intent. Em seguida, o SO cria
a nova atividade,
separa os dados e transmite a intent para ela.
Recomendamos que você use a classe Bundle para definir primitivos conhecidos pelo SO em
objetos Intent. A classe Bundle é altamente
otimizada para o gerenciamento e o desmarshalling usando pacotes.
Em alguns casos, você pode precisar de um mecanismo para envio de objetos compostos ou complexos entre as atividades.
Nesses casos, a classe personalizada precisa implementar o Parcelable e fornecer o método
writeToParcel(android.os.Parcel, int) apropriado.
Ele também precisa fornecer um campo não nulo chamado CREATOR que
implementa a interface Parcelable.Creator, cujo método
createFromParcel()
é usado para converter o Parcel de volta para o objeto atual.
Para mais informações,
consulte a documentação de referência do objeto Parcelable.
Ao enviar dados por meio de um intent, tenha o cuidado de limitar o tamanho dos dados a alguns KB.
O envio de muitos dados pode fazer com que o sistema gere uma
exceção TransactionTooLargeException.
Como enviar dados entre processos
Enviar dados entre processos é semelhante a fazer isso entre atividades. No entanto, ao enviar
entre processos, recomendamos que você não use parcelables personalizados. Se você enviar um objeto
Parcelable personalizado de um app para outro, vai precisar ter certeza de que a
mesma versão da classe personalizada está
presente nos apps de envio e de recebimento. Normalmente, essa pode ser uma biblioteca comum
usada nos dois apps. Pode ocorrer um erro se o app tentar enviar um parcelable personalizado ao
sistema, porque ele não pode desembarcar de uma classe de que não tenha conhecimento.
Por exemplo, um app pode definir um alarme usando
a classe AlarmManager e usar um Parcelable personalizado
na intent de alarme. Quando o alarme dispara, o sistema modifica o Bundle da intent
de extras para adicionar
uma contagem de repetição. Essa modificação pode fazer com que o sistema remova o Parcelable
personalizado dos extras. Essa remoção, por sua vez, pode resultar na falha
do app quando ele receber a intent de alarme modificada, porque ele espera
receber dados extras que não estão mais presentes.
O buffer de transação de vinculação tem um tamanho fixo limitado, atualmente de 1 MB, que é compartilhado por todas as transações em andamento no processo. Como esse limite está no nível do processo, e não no nível por atividade, essas transações incluem todas as transações de binder no app, como onSaveInstanceState, startActivity e qualquer interação com o sistema. Quando o limite de tamanho é excedido, TransactionTooLargeException é gerada.
Para o caso específico de savedInstanceState, a quantidade de dados precisa ser mantida pequena, porque o processo do sistema precisa manter os dados fornecidos enquanto o usuário pode navegar de volta a essa atividade, mesmo se o processo da atividade for encerrado. Recomendamos que você mantenha o estado salvo para menos de 50 mil dados.
Observação:no Android 7.0 (nível 24 da API) e versões mais recentes, o sistema gera uma TransactionTooLargeException como uma exceção de execução. Nas versões anteriores do Android, o sistema só mostra um aviso no logcat.