Como posso passar um objeto de bitmap de uma atividade para outra
-
20-09-2019 - |
Pergunta
Na minha atividade, eu crio um Bitmap
objeto e então eu preciso lançar outro Activity
, Como posso passar isso Bitmap
Objeto da subatividade (aquele que será lançado)?
Solução
Bitmap
implementos Parcelable
, então você sempre pode passar com a intenção:
Intent intent = new Intent(this, NewActivity.class);
intent.putExtra("BitmapImage", bitmap);
e recuperá -lo do outro lado:
Intent intent = getIntent();
Bitmap bitmap = (Bitmap) intent.getParcelableExtra("BitmapImage");
Outras dicas
Na verdade, passar um bitmap como um parcelável resultará em um erro de "falha do ligante Java". Tente passar o bitmap como uma matriz de bytes e construí -lo para exibição na próxima atividade.
Eu compartilhei minha solução aqui:
Como você passa imagens (bitmaps) entre atividades do Android usando pacotes?
Passar o bitmap como parciável no pacote entre a atividade não é uma boa idéia devido à limitação de tamanho de parca (1 MB). Você pode armazenar o bitmap em um arquivo no armazenamento interno e recuperar o bitmap armazenado em várias atividades. Aqui está algum código de amostra.
Para armazenar bitmap em um arquivo minha imagem Em armazenamento interno:
public String createImageFromBitmap(Bitmap bitmap) {
String fileName = "myImage";//no .png or .jpg needed
try {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, bytes);
FileOutputStream fo = openFileOutput(fileName, Context.MODE_PRIVATE);
fo.write(bytes.toByteArray());
// remember close file output
fo.close();
} catch (Exception e) {
e.printStackTrace();
fileName = null;
}
return fileName;
}
Então, na próxima atividade, você pode decodificar este arquivo myimage para um bitmap usando o seguinte código:
//here context can be anything like getActivity() for fragment, this or MainActivity.this
Bitmap bitmap = BitmapFactory.decodeStream(context.openFileInput("myImage"));
Observação Muita verificação de bitmap nula e escala está oscilitada.
Se a imagem for muito grande e você não puder salvá -la e carregá -la no armazenamento, considere apenas usar uma referência estática global ao bitmap (dentro da atividade de recepção), que será redefinida para anular no OnDestory, apenas se "isChangingConfigurações" retorna verdadeiro.
Porque a intenção tem limite de tamanho. Eu uso o objeto estático público para passar o bitmap de serviço para transmissão ....
public class ImageBox {
public static Queue<Bitmap> mQ = new LinkedBlockingQueue<Bitmap>();
}
Passe no meu serviço
private void downloadFile(final String url){
mExecutorService.submit(new Runnable() {
@Override
public void run() {
Bitmap b = BitmapFromURL.getBitmapFromURL(url);
synchronized (this){
TaskCount--;
}
Intent i = new Intent(ACTION_ON_GET_IMAGE);
ImageBox.mQ.offer(b);
sendBroadcast(i);
if(TaskCount<=0)stopSelf();
}
});
}
Meu BroadCastreceiver
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
public void onReceive(Context context, Intent intent) {
LOG.d(TAG, "BroadcastReceiver get broadcast");
String action = intent.getAction();
if (DownLoadImageService.ACTION_ON_GET_IMAGE.equals(action)) {
Bitmap b = ImageBox.mQ.poll();
if(b==null)return;
if(mListener!=null)mListener.OnGetImage(b);
}
}
};
Compressa e envie Bitmap
A resposta aceita vai travar quando o Bitmap
é muito grande. Eu acredito que é um 1 MB limite. o Bitmap
deve ser comprimido em um formato de arquivo diferente, como um Jpg representado por a ByteArray
, então pode ser passado com segurança por meio de um Intent
.
Implementação
A função está contida em um fio separado usando Coroutines Kotlin porque o Bitmap
A compressão é acorrentada após o Bitmap
é criado a partir de um URL String
. o Bitmap
a criação requer um fio separado para evitar Aplicação não respondendo (ANR) erros.
Conceitos usados
- Coroutines Kotlin notas.
- o Carregamento, conteúdo, erro (LCE) O padrão é usado abaixo. Se estiver interessado, você pode aprender mais sobre isso em esta conversa e vídeo.
- Dados ao vivo é usado para retornar os dados. Eu compilei meu favorito Dados ao vivo recurso em essas notas.
- Dentro etapa 3,
toBitmap()
é um Função de extensão de Kotlin exigindo que a biblioteca seja adicionada às dependências do aplicativo.
Código
1. Compressa Bitmap
para Jpg ByteArray
Depois de ter sido criado.
Repositório.kt
suspend fun bitmapToByteArray(url: String) = withContext(Dispatchers.IO) {
MutableLiveData<Lce<ContentResult.ContentBitmap>>().apply {
postValue(Lce.Loading())
postValue(Lce.Content(ContentResult.ContentBitmap(
ByteArrayOutputStream().apply {
try {
BitmapFactory.decodeStream(URL(url).openConnection().apply {
doInput = true
connect()
}.getInputStream())
} catch (e: IOException) {
postValue(Lce.Error(ContentResult.ContentBitmap(ByteArray(0), "bitmapToByteArray error or null - ${e.localizedMessage}")))
null
}?.compress(CompressFormat.JPEG, BITMAP_COMPRESSION_QUALITY, this)
}.toByteArray(), "")))
}
}
ViewModel.kt
//Calls bitmapToByteArray from the Repository
private fun bitmapToByteArray(url: String) = liveData {
emitSource(switchMap(repository.bitmapToByteArray(url)) { lce ->
when (lce) {
is Lce.Loading -> liveData {}
is Lce.Content -> liveData {
emit(Event(ContentResult.ContentBitmap(lce.packet.image, lce.packet.errorMessage)))
}
is Lce.Error -> liveData {
Crashlytics.log(Log.WARN, LOG_TAG,
"bitmapToByteArray error or null - ${lce.packet.errorMessage}")
}
}
})
}
2. Passe a imagem como ByteArray
via an Intent
.
Nesta amostra, passou de um Fragmento para um Serviço. É o mesmo conceito se for compartilhado entre dois Atividades.
Fragment.kt
ContextCompat.startForegroundService(
context!!,
Intent(context, AudioService::class.java).apply {
action = CONTENT_SELECTED_ACTION
putExtra(CONTENT_SELECTED_BITMAP_KEY, contentPlayer.image)
})
3. Converta ByteArray
de volta a Bitmap
.
Utils.kt
fun ByteArray.byteArrayToBitmap(context: Context) =
run {
BitmapFactory.decodeByteArray(this, BITMAP_OFFSET, size).run {
if (this != null) this
// In case the Bitmap loaded was empty or there is an error I have a default Bitmap to return.
else AppCompatResources.getDrawable(context, ic_coinverse_48dp)?.toBitmap()
}
}
Pode ser tarde, mas pode ajudar. No primeiro fragmento ou atividade, declare uma aula ... por exemplo
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
description des = new description();
if (requestCode == PICK_IMAGE_REQUEST && data != null && data.getData() != null) {
filePath = data.getData();
try {
bitmap = MediaStore.Images.Media.getBitmap(getActivity().getContentResolver(), filePath);
imageView.setImageBitmap(bitmap);
ByteArrayOutputStream stream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream);
constan.photoMap = bitmap;
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static class constan {
public static Bitmap photoMap = null;
public static String namePass = null;
}
Então, na segunda classe/fragmento, faça isso ..
Bitmap bm = postFragment.constan.photoMap;
final String itemName = postFragment.constan.namePass;
Espero que ajude.
Você pode criar uma transferência de bitmap. tente isso ....
Na primeira aula:
1) Crie:
private static Bitmap bitmap_transfer;
2) Crie getter e setter
public static Bitmap getBitmap_transfer() {
return bitmap_transfer;
}
public static void setBitmap_transfer(Bitmap bitmap_transfer_param) {
bitmap_transfer = bitmap_transfer_param;
}
3) Defina a imagem:
ImageView image = (ImageView) view.findViewById(R.id.image);
image.buildDrawingCache();
setBitmap_transfer(image.getDrawingCache());
Então, na segunda classe:
ImageView image2 = (ImageView) view.findViewById(R.id.img2);
imagem2.setImageDrawable(new BitmapDrawable(getResources(), classe1.getBitmap_transfer()));
Todas as soluções acima não funcionam para mim, enviando bitmap como parceableByteArray
Também gera erro android.os.TransactionTooLargeException: data parcel size
.
Solução
- Salvou o bitmap no armazenamento interno como:
public String saveBitmap(Bitmap bitmap) {
String fileName = "ImageName";//no .png or .jpg needed
try {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, bytes);
FileOutputStream fo = openFileOutput(fileName, Context.MODE_PRIVATE);
fo.write(bytes.toByteArray());
// remember close file output
fo.close();
} catch (Exception e) {
e.printStackTrace();
fileName = null;
}
return fileName;
}
- e envie
putExtra(String)
Como
Intent intent = new Intent(ActivitySketcher.this,ActivityEditor.class);
intent.putExtra("KEY", saveBitmap(bmp));
startActivity(intent);
- e receba em outras atividades como:
if(getIntent() != null){
try {
src = BitmapFactory.decodeStream(openFileInput("myImage"));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
No meu caso, a maneira mencionada acima não funcionou para mim. Toda vez que coloco o bitmap na intenção, a segunda atividade não começou. O mesmo aconteceu quando passei pelo bitmap como byte [].
Eu segui isso link E funcionou como um charme e muito rápido:
package your.packagename
import android.graphics.Bitmap;
public class CommonResources {
public static Bitmap photoFinishBitmap = null;
}
No meu 1º Acitiviy:
Constants.photoFinishBitmap = photoFinishBitmap;
Intent intent = new Intent(mContext, ImageViewerActivity.class);
startActivity(intent);
E aqui está o OnCreate () da minha segunda atividade:
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Bitmap photo = Constants.photoFinishBitmap;
if (photo != null) {
mViewHolder.imageViewerImage.setImageDrawable(new BitmapDrawable(getResources(), photo));
}
}