Изображение не загружается после выхода из разговора ⇐ JAVA

[Anonymous]

Когда я отправляю изображение в разговоре, получатель получает URL-адрес изображения, а отправитель может его видеть, но после выхода из разговора отправитель видит только URL-адрес. Я использую Firebase в качестве базы данных с путем хранения с именем "chat_images/"
ChatActivity.java
package com.example.sparks.activities;

import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Bundle;
import android.provider.MediaStore;
import android.util.Base64;
import android.view.View;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import com.example.sparks.adapters.ChatAdapter;
import com.example.sparks.databinding.ActivityChatBinding;
import com.example.sparks.models.ChatMessage;
import com.example.sparks.models.User;
import com.example.sparks.network.ApiClient;
import com.example.sparks.network.ApiService;
import com.example.sparks.utilities.Constants;
import com.example.sparks.utilities.PreferenceManager;
import com.google.android.gms.tasks.OnCompleteListener;
import com.google.firebase.Firebase;
import com.google.firebase.firestore.DocumentChange;
import com.google.firebase.firestore.DocumentReference;
import com.google.firebase.firestore.DocumentSnapshot;
import com.google.firebase.firestore.EventListener;
import com.google.firebase.firestore.FirebaseFirestore;
import com.google.firebase.firestore.QuerySnapshot;
import com.google.firebase.storage.FirebaseStorage;
import com.google.firebase.storage.StorageReference;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import java.util.UUID;

import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;

public class ChatActivity extends BaseActivity {

private ActivityChatBinding binding;
private User receiverUser;
private List chatMessages;
private List imageMessages = new ArrayList();
private ChatAdapter chatAdapter;
private PreferenceManager preferenceManager;
private FirebaseFirestore database;
private String conversionId = null;
private Boolean isReceiverAvailable = false;
private Uri selectedImageUri; // Add this line to store the selected image URI

private static final int REQUEST_CODE_PICK_IMAGE = 1;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
binding = ActivityChatBinding.inflate(getLayoutInflater());
setContentView(binding.getRoot());
setListeners();
loadReceiverDetails();
init();
listenMessages();
}

private void init(){
preferenceManager = new PreferenceManager(getApplicationContext());
chatMessages = new ArrayList();
chatAdapter = new ChatAdapter(
chatMessages,
getBitmapFromEncodedString(receiverUser.image),
preferenceManager.getString(Constants.KEY_USER_ID),
imageMessages
);
binding.chatRecyclerView.setAdapter(chatAdapter);
database = FirebaseFirestore.getInstance();
}

private void sendMessage(String imageUrl) {
HashMap message = new HashMap();
message.put(Constants.KEY_SENDER_ID, preferenceManager.getString(Constants.KEY_USER_ID));
message.put(Constants.KEY_RECEIVER_ID, receiverUser.id);

if (imageUrl != null) {
message.put(Constants.KEY_MESSAGE, imageUrl);
imageMessages.add(imageUrl);
} else {
message.put(Constants.KEY_MESSAGE, binding.inputMessage.getText().toString());
}

message.put(Constants.KEY_TIMESTAMP, new Date());
database.collection(Constants.KEY_COLLECTION_CHAT).add(message);

if (conversionId != null) {
updateConversion(binding.inputMessage.getText().toString());
} else {
HashMap conversion = new HashMap();
conversion.put(Constants.KEY_SENDER_ID, preferenceManager.getString(Constants.KEY_USER_ID));
conversion.put(Constants.KEY_SENDER_NAME, preferenceManager.getString(Constants.KEY_NAME));
conversion.put(Constants.KEY_SENDER_IMAGE, preferenceManager.getString(Constants.KEY_IMAGE));
conversion.put(Constants.KEY_RECEIVER_ID, receiverUser.id);
conversion.put(Constants.KEY_RECEIVER_NAME, receiverUser.name);
conversion.put(Constants.KEY_RECEIVER_IMAGE, receiverUser.image);
conversion.put(Constants.KEY_LAST_MESSAGE, binding.inputMessage.getText().toString());
conversion.put(Constants.KEY_TIMESTAMP, new Date());
addConversion(conversion);
}

if (!isReceiverAvailable) {
try {
JSONArray tokens = new JSONArray();
tokens.put(receiverUser.token);

JSONObject data = new JSONObject();
data.put(Constants.KEY_USER_ID, preferenceManager.getString(Constants.KEY_USER_ID));
data.put(Constants.KEY_NAME, preferenceManager.getString(Constants.KEY_NAME));
data.put(Constants.KEY_FCM_TOKEN, preferenceManager.getString(Constants.KEY_FCM_TOKEN));
data.put(Constants.KEY_MESSAGE, binding.inputMessage.getText().toString());

JSONObject body = new JSONObject();
body.put(Constants.REMOTE_MSG_DATA, data);
body.put(Constants.REMOTE_MSG_REGISTRATION_IDS, tokens);

sendNotification(body.toString());
} catch (Exception exception) {
showToast(exception.getMessage());
}
}
binding.inputMessage.setText(null);
selectedImageUri = null;
}

private void uploadImageAndSendMessage(Uri imageUri) {
// Generate a unique filename for the image using UUID
String imageFileName = UUID.randomUUID().toString();

// Get a reference to the Firebase Storage location with the unique filename
StorageReference storageReference = FirebaseStorage.getInstance().getReference()
.child("chat_images/" + imageFileName);

// Upload the image to Firebase Storage with the unique filename
storageReference.putFile(imageUri)
.addOnSuccessListener(taskSnapshot -> {
// Once the upload is successful, get the download URL
storageReference.getDownloadUrl().addOnSuccessListener(uri -> {
// Send message with the download URL of the image
sendMessage(uri.toString());
});
})
.addOnFailureListener(e -> showToast(e.getMessage()));
}

private void showToast(String message){
Toast.makeText(getApplicationContext(), message, Toast.LENGTH_SHORT).show();
}

private void sendNotification(String messageBody){
ApiClient.getClient().create(ApiService.class).sendMessage(
Constants.getRemoteMsgHeaders(),
messageBody
).enqueue(new Callback() {
@Override
public void onResponse(@NonNull Call call, @NonNull Response response) {
if (response.isSuccessful()){
try {
if (response.body() != null){
JSONObject responseJson = new JSONObject(response.body());
JSONArray results = responseJson.getJSONArray("resuults");
if (responseJson.getInt("failure") == 1){
JSONObject error = (JSONObject) results.get(0);
showToast(error.getString("error"));
return;
}
}
}catch (JSONException e){
e.printStackTrace();
}
showToast("Notification sent successfully");
}else {
showToast("Error: " + response.code());
}
}

@Override
public void onFailure(@NonNull Call call, @NonNull Throwable t) {
showToast(t.getMessage());
}
});
}

private void listenAvailabilityOfReceiver(){
database.collection(Constants.KEY_COLLECTION_USERS).document(
receiverUser.id
).addSnapshotListener(ChatActivity.this, (value, error) -> {
if (error != null){
return;
}
if (value != null){
if (value.getLong(Constants.KEY_AVAILABILITY) != null) {
int availability = Objects.requireNonNull(
value.getLong(Constants.KEY_AVAILABILITY)
).intValue();
isReceiverAvailable = availability == 1;
}
receiverUser.token = value.getString(Constants.KEY_FCM_TOKEN);
if (receiverUser.image == null){
receiverUser.image = value.getString(Constants.KEY_IMAGE);
chatAdapter.setReceiverProfileImage(getBitmapFromEncodedString(receiverUser.image));
chatAdapter.notifyItemRangeChanged(0, chatMessages.size());
}
}
if (isReceiverAvailable){
binding.textAvailability.setVisibility(View.VISIBLE);
}else {
binding.textAvailability.setVisibility(View.GONE);
}
});
}

private void listenMessages(){
database.collection(Constants.KEY_COLLECTION_CHAT)
.whereEqualTo(Constants.KEY_SENDER_ID, preferenceManager.getString(Constants.KEY_USER_ID))
.whereEqualTo(Constants.KEY_RECEIVER_ID, receiverUser.id)
.addSnapshotListener(eventListener);
database.collection(Constants.KEY_COLLECTION_CHAT)
.whereEqualTo(Constants.KEY_SENDER_ID, receiverUser.id)
.whereEqualTo(Constants.KEY_RECEIVER_ID, preferenceManager.getString(Constants.KEY_USER_ID))
.addSnapshotListener(eventListener);
}

private final EventListener eventListener = (value, error) -> {
if (error != null) {
return;
}
if (value != null) {
int count = chatMessages.size();
for (DocumentChange documentChange : value.getDocumentChanges()) {
if (documentChange.getType() == DocumentChange.Type.ADDED) {
ChatMessage chatMessage = new ChatMessage();
chatMessage.senderId = documentChange.getDocument().getString(Constants.KEY_SENDER_ID);
chatMessage.receiverId = documentChange.getDocument().getString(Constants.KEY_RECEIVER_ID);
chatMessage.message = documentChange.getDocument().getString(Constants.KEY_MESSAGE);
chatMessage.dateTime = getReadableDateTime(documentChange.getDocument().getDate(Constants.KEY_TIMESTAMP));
chatMessage.dateObject = documentChange.getDocument().getDate(Constants.KEY_TIMESTAMP);
chatMessages.add(chatMessage);
}
}
Collections.sort(chatMessages, (obj1, obj2) -> obj1.dateObject.compareTo(obj2.dateObject));
if (count == 0) {
chatAdapter.notifyDataSetChanged();
} else {
chatAdapter.notifyItemRangeInserted(chatMessages.size(), chatMessages.size());
binding.chatRecyclerView.smoothScrollToPosition(chatMessages.size() - 1);
}
binding.chatRecyclerView.setVisibility(View.VISIBLE);
}
binding.progressBar.setVisibility(View.GONE);
if (conversionId == null) {
checkForConversion();
}
};

private Bitmap getBitmapFromEncodedString(String encodedImage){
if (encodedImage != null){
byte[] bytes = Base64.decode(encodedImage, Base64.DEFAULT);
return BitmapFactory.decodeByteArray(bytes, 0, bytes.length);

} else {
return null;
}
}

private void loadReceiverDetails(){
receiverUser = (User) getIntent().getSerializableExtra(Constants.KEY_USER);
binding.textName.setText(receiverUser.name);
}

private void setListeners() {
binding.imageBack.setOnClickListener(v -> onBackPressed());
binding.layoutSend.setOnClickListener(v -> {
if (selectedImageUri != null) {
uploadImageAndSendMessage(selectedImageUri);
} else {
sendMessage(null);
}
});
binding.mediaAttach.setOnClickListener(v -> {
Intent intent = new Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
startActivityForResult(intent, REQUEST_CODE_PICK_IMAGE);
});
}

@Override
protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode == REQUEST_CODE_PICK_IMAGE && resultCode == RESULT_OK && data != null) {
selectedImageUri = data.getData();
}
}

private String getReadableDateTime(Date date){
return new SimpleDateFormat("MMMM dd, yyyy - hh:mm a", Locale.getDefault()).format(date);
}

private void addConversion(HashMap conversion){
database.collection(Constants.KEY_COLLECTION_CONVERSATIONS)
.add(conversion)
.addOnSuccessListener(documentReference -> conversionId = documentReference.getId());
}

private void updateConversion(String message){
DocumentReference documentReference =
database.collection(Constants.KEY_COLLECTION_CONVERSATIONS).document(conversionId);
documentReference.update(
Constants.KEY_LAST_MESSAGE, message,
Constants.KEY_TIMESTAMP, new Date()
);
}

private void checkForConversion(){
if(!chatMessages.isEmpty()){
checkForConversionRemotely(
preferenceManager.getString(Constants.KEY_USER_ID),
receiverUser.id
);
checkForConversionRemotely(
receiverUser.id,
preferenceManager.getString(Constants.KEY_USER_ID)
);
}
}

private void checkForConversionRemotely(String senderId, String receiverid){
database.collection(Constants.KEY_COLLECTION_CONVERSATIONS)
.whereEqualTo(Constants.KEY_SENDER_ID, senderId)
.whereEqualTo(Constants.KEY_RECEIVER_ID, receiverid)
.get()
.addOnCompleteListener(conversionOnCompleteListener);
}

private final OnCompleteListener conversionOnCompleteListener = task -> {
if (task.isSuccessful() && task.getResult() != null && !task.getResult().getDocuments().isEmpty()){
DocumentSnapshot documentSnapshot = task.getResult().getDocuments().get(0);
conversionId = documentSnapshot.getId();
}
};

@Override
protected void onResume() {
super.onResume();
listenAvailabilityOfReceiver();
}
}

ChatAdapter.java
package com.example.sparks.adapters;

import android.graphics.Bitmap;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;

import com.bumptech.glide.Glide;
import com.example.sparks.databinding.ItemContainerReceivedMediaMessageBinding;
import com.example.sparks.databinding.ItemContainerReceivedMessageBinding;
import com.example.sparks.databinding.ItemContainerSentMediaMessageBinding;
import com.example.sparks.databinding.ItemContainerSentMessageBinding;
import com.example.sparks.models.ChatMessage;

import java.util.List;

public class ChatAdapter extends RecyclerView.Adapter {

private final List chatMessages;

private Bitmap receiverProfileImage;
private final String senderId;

public static final int VIEW_TYPE_SENT = 1;
public static final int VIEW_TYPE_RECEIVED = 2;

public static final int VIEW_TYPE_SENT_IMAGE = 3;
public static final int VIEW_TYPE_RECEIVED_IMAGE = 4;
private List imageMessages;

public void setReceiverProfileImage(Bitmap bitmap){
receiverProfileImage = bitmap;
}

public ChatAdapter(List chatMessages, Bitmap receiverProfileImage, String senderId, List imageMessages) {
this.chatMessages = chatMessages;
this.receiverProfileImage = receiverProfileImage;
this.senderId = senderId;
this.imageMessages = imageMessages;

}

@Override
public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
if (viewType == VIEW_TYPE_SENT) {
return new SentMessageViewHolder(
ItemContainerSentMessageBinding.inflate(
LayoutInflater.from(parent.getContext()),
parent,
false
)
);
} else if (viewType == VIEW_TYPE_RECEIVED) {
return new ReceivedMessageViewHolder(
ItemContainerReceivedMessageBinding.inflate(
LayoutInflater.from(parent.getContext()),
parent,
false
),
ItemContainerReceivedMediaMessageBinding.inflate(
LayoutInflater.from(parent.getContext()),
parent,
false
)
);
} else if (viewType == VIEW_TYPE_SENT_IMAGE) {
return new SentImageMessageViewHolder(
ItemContainerSentMediaMessageBinding.inflate(
LayoutInflater.from(parent.getContext()),
parent,
false
)
);
} else {
return new ReceivedImageMessageViewHolder(
ItemContainerReceivedMediaMessageBinding.inflate(
LayoutInflater.from(parent.getContext()),
parent,
false
)
);
}
}

@Override
public int getItemViewType(int position) {
ChatMessage message = chatMessages.get(position);
boolean isSender = message.senderId.equals(senderId);
boolean isImageMessage = imageMessages.contains(message.message);

if (isSender) {
return isImageMessage ? VIEW_TYPE_SENT_IMAGE : VIEW_TYPE_SENT;
} else {
return isImageMessage ? VIEW_TYPE_RECEIVED_IMAGE : VIEW_TYPE_RECEIVED;
}
}

@Override
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
ChatMessage message = chatMessages.get(position);

if (holder instanceof SentMessageViewHolder) {
((SentMessageViewHolder) holder).setData(message);
} else if (holder instanceof ReceivedMessageViewHolder) {
((ReceivedMessageViewHolder) holder).setData(message, receiverProfileImage);
} else if (holder instanceof SentImageMessageViewHolder) {
((SentImageMessageViewHolder) holder).setData(message);
} else if (holder instanceof ReceivedImageMessageViewHolder) {
((ReceivedImageMessageViewHolder) holder).setData(message);
}
}

@Override
public int getItemCount() {
return chatMessages.size();
}

static class SentMessageViewHolder extends RecyclerView.ViewHolder {

private final ItemContainerSentMessageBinding binding;

SentMessageViewHolder(ItemContainerSentMessageBinding itemContainerSentMessageBinding) {
super(itemContainerSentMessageBinding.getRoot());
binding = itemContainerSentMessageBinding;
}

void setData(ChatMessage chatMessage) {
binding.textMessage.setText(chatMessage.message);
binding.textDateTime.setText(chatMessage.dateTime);
}
}

static class ReceivedMessageViewHolder extends RecyclerView.ViewHolder {
private final ItemContainerReceivedMessageBinding binding;
private final ItemContainerReceivedMediaMessageBinding mediaBinding;

ReceivedMessageViewHolder(ItemContainerReceivedMessageBinding itemContainerReceivedMessageBinding, ItemContainerReceivedMediaMessageBinding itemContainerReceivedMediaMessageBinding) {
super(itemContainerReceivedMessageBinding.getRoot());
binding = itemContainerReceivedMessageBinding;
mediaBinding = itemContainerReceivedMediaMessageBinding;
}

void setData(ChatMessage chatMessage, Bitmap receiverProfileImage) {
if (isImageUrl(chatMessage.message)) {
binding.getRoot().setVisibility(View.GONE);
mediaBinding.getRoot().setVisibility(View.VISIBLE);
Glide.with(mediaBinding.getRoot().getContext())
.load(chatMessage.message)
.into(mediaBinding.imageMessage);
mediaBinding.textDateTime.setText(chatMessage.dateTime);
if (receiverProfileImage != null) {
mediaBinding.imageProfile.setImageBitmap(receiverProfileImage);
}
} else {
binding.getRoot().setVisibility(View.VISIBLE);
mediaBinding.getRoot().setVisibility(View.GONE);
binding.textMessage.setText(chatMessage.message);
binding.textDateTime.setText(chatMessage.dateTime);
if (receiverProfileImage != null) {
binding.imageProfile.setImageBitmap(receiverProfileImage);
}
}
}

private boolean isImageUrl(String url) {
return url != null && (url.endsWith(".jpg") || url.endsWith(".jpeg") || url.endsWith(".png") || url.endsWith(".gif"));
}
}

static class SentImageMessageViewHolder extends RecyclerView.ViewHolder {
private final ItemContainerSentMediaMessageBinding binding;

SentImageMessageViewHolder(ItemContainerSentMediaMessageBinding binding) {
super(binding.getRoot());
this.binding = binding;
}

void setData(ChatMessage chatMessage) {
Glide.with(binding.getRoot().getContext())
.load(chatMessage.message)
.into(binding.imageMessage);
}
}

static class ReceivedImageMessageViewHolder extends RecyclerView.ViewHolder {
private final ItemContainerReceivedMediaMessageBinding binding;

ReceivedImageMessageViewHolder(ItemContainerReceivedMediaMessageBinding binding) {
super(binding.getRoot());
this.binding = binding;
}

void setData(ChatMessage chatMessage) {
Glide.with(binding.getRoot().getContext())
.load(chatMessage.message)
.into(binding.imageMessage);
}
}
}


Подробнее здесь: https://stackoverflow.com/questions/785 ... nversation