/*
|
* Copyright (c) 2010-2019 Belledonne Communications SARL.
|
*
|
* This file is part of linphone-android
|
* (see https://www.linphone.org).
|
*
|
* This program is free software: you can redistribute it and/or modify
|
* it under the terms of the GNU General Public License as published by
|
* the Free Software Foundation, either version 3 of the License, or
|
* (at your option) any later version.
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*
|
* You should have received a copy of the GNU General Public License
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
*/
|
package org.linphone.chat;
|
|
import static android.content.Context.INPUT_METHOD_SERVICE;
|
|
import android.Manifest;
|
import android.app.Activity;
|
import android.app.Dialog;
|
import android.app.Fragment;
|
import android.content.ClipData;
|
import android.content.ClipboardManager;
|
import android.content.Context;
|
import android.content.Intent;
|
import android.graphics.Rect;
|
import android.net.Uri;
|
import android.os.Bundle;
|
import android.os.Parcelable;
|
import android.provider.MediaStore;
|
import android.text.Editable;
|
import android.text.TextWatcher;
|
import android.view.ContextMenu;
|
import android.view.LayoutInflater;
|
import android.view.MenuInflater;
|
import android.view.MenuItem;
|
import android.view.View;
|
import android.view.ViewGroup;
|
import android.view.ViewTreeObserver;
|
import android.view.WindowManager;
|
import android.view.inputmethod.InputMethodManager;
|
import android.widget.Button;
|
import android.widget.CheckBox;
|
import android.widget.ImageView;
|
import android.widget.LinearLayout;
|
import android.widget.TextView;
|
import androidx.appcompat.view.menu.MenuBuilder;
|
import androidx.appcompat.view.menu.MenuPopupHelper;
|
import androidx.core.view.inputmethod.InputConnectionCompat;
|
import androidx.core.view.inputmethod.InputContentInfoCompat;
|
import androidx.recyclerview.widget.LinearLayoutManager;
|
import androidx.recyclerview.widget.RecyclerView;
|
import com.bumptech.glide.Glide;
|
import java.io.File;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.List;
|
import org.linphone.LinphoneContext;
|
import org.linphone.LinphoneManager;
|
import org.linphone.R;
|
import org.linphone.activities.MainActivity;
|
import org.linphone.contacts.ContactAddress;
|
import org.linphone.contacts.ContactsManager;
|
import org.linphone.contacts.ContactsUpdatedListener;
|
import org.linphone.contacts.LinphoneContact;
|
import org.linphone.core.Address;
|
import org.linphone.core.Call;
|
import org.linphone.core.ChatMessage;
|
import org.linphone.core.ChatRoom;
|
import org.linphone.core.ChatRoomCapabilities;
|
import org.linphone.core.ChatRoomListener;
|
import org.linphone.core.ChatRoomSecurityLevel;
|
import org.linphone.core.Content;
|
import org.linphone.core.Core;
|
import org.linphone.core.CoreListenerStub;
|
import org.linphone.core.EventLog;
|
import org.linphone.core.Factory;
|
import org.linphone.core.Participant;
|
import org.linphone.core.ParticipantDevice;
|
import org.linphone.core.ParticipantImdnState;
|
import org.linphone.core.Reason;
|
import org.linphone.core.tools.Log;
|
import org.linphone.settings.LinphonePreferences;
|
import org.linphone.utils.FileUtils;
|
import org.linphone.utils.LinphoneUtils;
|
import org.linphone.utils.SelectableHelper;
|
import org.linphone.views.RichEditText;
|
|
public class ChatMessagesFragment extends Fragment
|
implements ChatRoomListener,
|
ContactsUpdatedListener,
|
ChatMessageViewHolderClickListener,
|
SelectableHelper.DeleteListener,
|
RichEditText.RichInputListener {
|
private static final int ADD_PHOTO = 1337;
|
private static final int MESSAGES_PER_PAGE = 20;
|
private static final String INPUT_CONTENT_INFO_KEY = "COMMIT_CONTENT_INPUT_CONTENT_INFO";
|
private static final String COMMIT_CONTENT_FLAGS_KEY = "COMMIT_CONTENT_FLAGS";
|
|
private ImageView mCallButton;
|
private ImageView mBackToCallButton;
|
private ImageView mPopupMenu;
|
private ImageView mAttachImageButton, mSendMessageButton, mSendEphemeralIcon;
|
private TextView mRoomLabel, mParticipantsLabel, mSipUriLabel, mRemoteComposing;
|
private RichEditText mMessageTextToSend;
|
private LayoutInflater mInflater;
|
private RecyclerView mChatEventsList;
|
private LinearLayout mFilesUploadLayout;
|
private SelectableHelper mSelectionHelper;
|
private Context mContext;
|
private ViewTreeObserver.OnGlobalLayoutListener mKeyboardListener;
|
private Uri mImageToUploadUri;
|
private String mRemoteSipUri;
|
private Address mLocalSipAddress, mRemoteSipAddress, mRemoteParticipantAddress;
|
private ChatRoom mChatRoom;
|
private ArrayList<LinphoneContact> mParticipants;
|
private int mContextMenuMessagePosition;
|
private LinearLayout mTopBar;
|
private ImageView mChatRoomSecurityLevel;
|
private CoreListenerStub mCoreListener;
|
|
private InputContentInfoCompat mCurrentInputContentInfo;
|
|
@Override
|
public View onCreateView(
|
LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
|
super.onCreate(savedInstanceState);
|
// Retain the fragment across configuration changes
|
setRetainInstance(true);
|
|
if (getArguments() != null) {
|
if (getArguments().getString("LocalSipUri") != null) {
|
String mLocalSipUri = getArguments().getString("LocalSipUri");
|
mLocalSipAddress = Factory.instance().createAddress(mLocalSipUri);
|
}
|
if (getArguments().getString("RemoteSipUri") != null) {
|
mRemoteSipUri = getArguments().getString("RemoteSipUri");
|
mRemoteSipAddress = Factory.instance().createAddress(mRemoteSipUri);
|
}
|
}
|
|
mContext = getActivity().getApplicationContext();
|
mInflater = inflater;
|
View view = inflater.inflate(R.layout.chat, container, false);
|
|
mTopBar = view.findViewById(R.id.top_bar);
|
|
mChatRoomSecurityLevel = view.findViewById(R.id.room_security_level);
|
mChatRoomSecurityLevel.setOnClickListener(
|
new View.OnClickListener() {
|
@Override
|
public void onClick(View view) {
|
goToDevices();
|
}
|
});
|
|
ImageView backButton = view.findViewById(R.id.back);
|
backButton.setOnClickListener(
|
new View.OnClickListener() {
|
@Override
|
public void onClick(View view) {
|
((ChatActivity) getActivity()).goBack();
|
}
|
});
|
backButton.setVisibility(
|
getResources().getBoolean(R.bool.isTablet) ? View.INVISIBLE : View.VISIBLE);
|
|
mCallButton = view.findViewById(R.id.start_call);
|
mCallButton.setOnClickListener(
|
new View.OnClickListener() {
|
@Override
|
public void onClick(View view) {
|
LinphoneManager.getCallManager()
|
.newOutgoingCall(mRemoteParticipantAddress.asString(), null);
|
}
|
});
|
|
mBackToCallButton = view.findViewById(R.id.back_to_call);
|
mBackToCallButton.setOnClickListener(
|
new View.OnClickListener() {
|
@Override
|
public void onClick(View view) {
|
((MainActivity) getActivity()).goBackToCall();
|
}
|
});
|
|
mPopupMenu = view.findViewById(R.id.menu);
|
mPopupMenu.setOnClickListener(
|
new View.OnClickListener() {
|
@Override
|
public void onClick(View view) {
|
showPopupMenu();
|
}
|
});
|
|
mRoomLabel = view.findViewById(R.id.subject);
|
mParticipantsLabel = view.findViewById(R.id.participants);
|
mSipUriLabel = view.findViewById(R.id.sipUri);
|
|
mFilesUploadLayout = view.findViewById(R.id.file_upload_layout);
|
|
mAttachImageButton = view.findViewById(R.id.send_picture);
|
mAttachImageButton.setOnClickListener(
|
new View.OnClickListener() {
|
@Override
|
public void onClick(View view) {
|
String[] permissions = {
|
Manifest.permission.CAMERA, Manifest.permission.READ_EXTERNAL_STORAGE
|
};
|
((ChatActivity) getActivity()).requestPermissionsIfNotGranted(permissions);
|
pickFile();
|
}
|
});
|
if (getResources().getBoolean(R.bool.disable_chat_send_file)) {
|
mAttachImageButton.setEnabled(false);
|
mAttachImageButton.setVisibility(View.GONE);
|
}
|
|
mSendEphemeralIcon = view.findViewById(R.id.send_ephemeral_message);
|
mSendMessageButton = view.findViewById(R.id.send_message);
|
mSendMessageButton.setEnabled(false);
|
mSendEphemeralIcon.setEnabled(mSendMessageButton.isEnabled());
|
mSendMessageButton.setOnClickListener(
|
new View.OnClickListener() {
|
@Override
|
public void onClick(View view) {
|
sendMessage();
|
}
|
});
|
|
mMessageTextToSend = view.findViewById(R.id.message);
|
mMessageTextToSend.addTextChangedListener(
|
new TextWatcher() {
|
@Override
|
public void beforeTextChanged(
|
CharSequence charSequence, int i, int i1, int i2) {}
|
|
@Override
|
public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
|
mSendMessageButton.setEnabled(
|
mMessageTextToSend.getText().length() > 0
|
|| mFilesUploadLayout.getChildCount() > 0);
|
mSendEphemeralIcon.setEnabled(mSendMessageButton.isEnabled());
|
if (mChatRoom != null && mMessageTextToSend.getText().length() > 0) {
|
if (!getResources().getBoolean(R.bool.allow_multiple_images_and_text)) {
|
mAttachImageButton.setEnabled(false);
|
}
|
mChatRoom.compose();
|
} else {
|
mAttachImageButton.setEnabled(true);
|
}
|
}
|
|
@Override
|
public void afterTextChanged(Editable editable) {}
|
});
|
mMessageTextToSend.clearFocus();
|
mMessageTextToSend.setListener(this);
|
|
mRemoteComposing = view.findViewById(R.id.remote_composing);
|
|
mChatEventsList = view.findViewById(R.id.chat_message_list);
|
mSelectionHelper = new SelectableHelper(view, this);
|
LinearLayoutManager layoutManager =
|
new LinphoneLinearLayoutManager(mContext, LinearLayoutManager.VERTICAL, true);
|
mChatEventsList.setLayoutManager(layoutManager);
|
|
ChatScrollListener chatScrollListener =
|
new ChatScrollListener(layoutManager) {
|
@Override
|
public void onLoadMore(int totalItemsCount) {
|
loadMoreData(totalItemsCount);
|
}
|
};
|
mChatEventsList.addOnScrollListener(chatScrollListener);
|
|
if (getArguments() != null) {
|
String fileSharedUri = getArguments().getString("SharedFiles");
|
if (fileSharedUri != null) {
|
Log.i("[Chat Messages Fragment] Found shared file(s): " + fileSharedUri);
|
if (fileSharedUri.contains(":")) {
|
String[] files = fileSharedUri.split(":");
|
for (String file : files) {
|
addFileIntoSharingArea(file);
|
}
|
} else {
|
addFileIntoSharingArea(fileSharedUri);
|
}
|
}
|
|
if (getArguments().containsKey("SharedText")) {
|
String sharedText = getArguments().getString("SharedText");
|
mMessageTextToSend.setText(sharedText);
|
Log.i("[Chat Messages Fragment] Found shared text: " + sharedText);
|
}
|
}
|
|
if (savedInstanceState != null) {
|
onRestoreInstanceState(savedInstanceState);
|
}
|
|
mCoreListener =
|
new CoreListenerStub() {
|
@Override
|
public void onCallStateChanged(
|
Core core, Call call, Call.State state, String message) {
|
displayChatRoomHeader();
|
}
|
};
|
|
return view;
|
}
|
|
@Override
|
public void onResume() {
|
super.onResume();
|
|
Core core = LinphoneManager.getCore();
|
if (core != null) {
|
core.addListener(mCoreListener);
|
}
|
|
ContactsManager.getInstance().addContactsListener(this);
|
|
addVirtualKeyboardVisiblityListener();
|
// Force hide keyboard
|
getActivity()
|
.getWindow()
|
.setSoftInputMode(
|
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN
|
| WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
|
InputMethodManager inputMethodManager =
|
(InputMethodManager) getActivity().getSystemService(INPUT_METHOD_SERVICE);
|
if (getActivity().getCurrentFocus() != null) {
|
inputMethodManager.hideSoftInputFromWindow(
|
getActivity().getCurrentFocus().getWindowToken(), 0);
|
}
|
|
initChatRoom();
|
displayChatRoomHeader();
|
displayChatRoomHistory();
|
|
LinphoneContext.instance()
|
.getNotificationManager()
|
.setCurrentlyDisplayedChatRoom(
|
mRemoteSipAddress != null ? mRemoteSipAddress.asStringUriOnly() : null);
|
}
|
|
@Override
|
public void onPause() {
|
Core core = LinphoneManager.getCore();
|
if (core != null) {
|
core.removeListener(mCoreListener);
|
}
|
|
ContactsManager.getInstance().removeContactsListener(this);
|
removeVirtualKeyboardVisiblityListener();
|
LinphoneContext.instance().getNotificationManager().setCurrentlyDisplayedChatRoom(null);
|
if (mChatRoom != null) mChatRoom.removeListener(this);
|
if (mChatEventsList.getAdapter() != null)
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter()).clear();
|
|
super.onPause();
|
}
|
|
@Override
|
public void onSaveInstanceState(Bundle outState) {
|
super.onSaveInstanceState(outState);
|
|
ArrayList<String> files = new ArrayList<>();
|
for (int i = 0; i < mFilesUploadLayout.getChildCount(); i++) {
|
View child = mFilesUploadLayout.getChildAt(i);
|
String filePath = (String) child.getTag();
|
files.add(filePath);
|
}
|
outState.putStringArrayList("Files", files);
|
}
|
|
@Override
|
public void onActivityResult(int requestCode, int resultCode, Intent data) {
|
if (data != null) {
|
if (requestCode == ADD_PHOTO && resultCode == Activity.RESULT_OK) {
|
String fileToUploadPath = null;
|
if (data.getData() != null) {
|
Log.i(
|
"[Chat Messages Fragment] Intent data after picking file is "
|
+ data.getData().toString());
|
if (data.getData().toString().contains("com.android.contacts/contacts/")) {
|
Uri cvsPath = FileUtils.getCVSPathFromLookupUri(data.getData().toString());
|
if (cvsPath != null) {
|
fileToUploadPath = cvsPath.toString();
|
Log.i("[Chat Messages Fragment] Found CVS path: " + fileToUploadPath);
|
} else {
|
// TODO Error
|
return;
|
}
|
} else {
|
fileToUploadPath =
|
FileUtils.getRealPathFromURI(getActivity(), data.getData());
|
Log.i(
|
"[Chat Messages Fragment] Resolved path for data is: "
|
+ fileToUploadPath);
|
}
|
if (fileToUploadPath == null) {
|
fileToUploadPath = data.getData().toString();
|
Log.i(
|
"[Chat Messages Fragment] Couldn't resolve path, using as-is: "
|
+ fileToUploadPath);
|
}
|
} else if (mImageToUploadUri != null) {
|
fileToUploadPath = mImageToUploadUri.getPath();
|
Log.i(
|
"[Chat Messages Fragment] Using pre-created path for dynamic capture "
|
+ fileToUploadPath);
|
}
|
|
if (fileToUploadPath.startsWith("content://")
|
|| fileToUploadPath.startsWith("file://")) {
|
Uri uriToParse = Uri.parse(fileToUploadPath);
|
fileToUploadPath =
|
FileUtils.getFilePath(
|
getActivity().getApplicationContext(), uriToParse);
|
Log.i(
|
"[Chat Messages Fragment] Path was using a content or file scheme, real path is: "
|
+ fileToUploadPath);
|
if (fileToUploadPath == null) {
|
Log.e(
|
"[Chat Messages Fragment] Failed to get access to file "
|
+ uriToParse.toString());
|
}
|
} else if (fileToUploadPath.contains("com.android.contacts/contacts/")) {
|
fileToUploadPath =
|
FileUtils.getCVSPathFromLookupUri(fileToUploadPath).toString();
|
Log.i(
|
"[Chat Messages Fragment] Path was using a contact scheme, real path is: "
|
+ fileToUploadPath);
|
}
|
|
if (fileToUploadPath != null) {
|
if (FileUtils.isExtensionImage(fileToUploadPath)) {
|
addImageToPendingList(fileToUploadPath);
|
} else {
|
addFileToPendingList(fileToUploadPath);
|
}
|
} else {
|
Log.e(
|
"[Chat Messages Fragment] Failed to get a path that we could use, aborting attachment");
|
}
|
} else {
|
super.onActivityResult(requestCode, resultCode, data);
|
}
|
} else {
|
if (FileUtils.isExtensionImage(mImageToUploadUri.getPath())) {
|
File file = new File(mImageToUploadUri.getPath());
|
if (file.exists()) {
|
addImageToPendingList(mImageToUploadUri.getPath());
|
}
|
}
|
}
|
}
|
|
@Override
|
public void onDeleteSelection(Object[] objectsToDelete) {
|
for (Object obj : objectsToDelete) {
|
EventLog eventLog = (EventLog) obj;
|
LinphoneUtils.deleteFileContentIfExists(eventLog);
|
eventLog.deleteFromDatabase();
|
}
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter())
|
.refresh(mChatRoom.getHistoryEvents(MESSAGES_PER_PAGE));
|
}
|
|
@Override
|
public void onCreateContextMenu(
|
ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
|
super.onCreateContextMenu(menu, v, menuInfo);
|
|
ChatMessageViewHolder holder = (ChatMessageViewHolder) v.getTag();
|
mContextMenuMessagePosition = holder.getAdapterPosition();
|
|
EventLog event =
|
(EventLog)
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter())
|
.getItem(mContextMenuMessagePosition);
|
if (event.getType() != EventLog.Type.ConferenceChatMessage) {
|
return;
|
}
|
|
MenuInflater inflater = getActivity().getMenuInflater();
|
ChatMessage message = event.getChatMessage();
|
if (message.getState() == ChatMessage.State.NotDelivered) {
|
inflater.inflate(R.menu.chat_bubble_menu_with_resend, menu);
|
} else {
|
inflater.inflate(R.menu.chat_bubble_menu, menu);
|
}
|
|
if (!message.isOutgoing()
|
|| mChatRoom.hasCapability(ChatRoomCapabilities.OneToOne.toInt())) {
|
// Do not show incoming messages IDMN state in 1 to 1 chat room as we don't receive IMDN
|
// for them
|
menu.removeItem(R.id.imdn_infos);
|
}
|
if (!message.hasTextContent()) {
|
// Do not show copy text option if message doesn't have any text
|
menu.removeItem(R.id.copy_text);
|
}
|
|
if (!message.isOutgoing()) {
|
Address address = message.getFromAddress();
|
LinphoneContact contact = ContactsManager.getInstance().findContactFromAddress(address);
|
if (contact != null) {
|
menu.removeItem(R.id.add_to_contacts);
|
}
|
} else {
|
menu.removeItem(R.id.add_to_contacts);
|
}
|
}
|
|
@Override
|
public boolean onContextItemSelected(MenuItem item) {
|
EventLog event =
|
(EventLog)
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter())
|
.getItem(mContextMenuMessagePosition);
|
|
if (event.getType() != EventLog.Type.ConferenceChatMessage) {
|
return super.onContextItemSelected(item);
|
}
|
|
ChatMessage message = event.getChatMessage();
|
String messageId = message.getMessageId();
|
|
if (item.getItemId() == R.id.resend) {
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter())
|
.removeItem(mContextMenuMessagePosition);
|
message.send();
|
return true;
|
}
|
if (item.getItemId() == R.id.imdn_infos) {
|
((ChatActivity) getActivity()).showImdn(mLocalSipAddress, mRemoteSipAddress, messageId);
|
return true;
|
}
|
if (item.getItemId() == R.id.forward) {
|
((ChatActivity) getActivity()).forwardMessage(message);
|
return true;
|
}
|
if (item.getItemId() == R.id.copy_text) {
|
if (message.hasTextContent()) {
|
ClipboardManager clipboard =
|
(ClipboardManager)
|
getActivity().getSystemService(Context.CLIPBOARD_SERVICE);
|
ClipData clip = ClipData.newPlainText("Message", message.getTextContent());
|
clipboard.setPrimaryClip(clip);
|
}
|
return true;
|
}
|
if (item.getItemId() == R.id.delete_message) {
|
LinphoneUtils.deleteFileContentIfExists(event);
|
mChatRoom.deleteMessage(message);
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter())
|
.removeItem(mContextMenuMessagePosition);
|
return true;
|
}
|
if (item.getItemId() == R.id.add_to_contacts) {
|
Address address = message.getFromAddress();
|
if (address == null) return true;
|
address.clean();
|
((ChatActivity) getActivity()).showContactsListForCreationOrEdition(address);
|
return true;
|
}
|
return super.onContextItemSelected(item);
|
}
|
|
private void addFileIntoSharingArea(String fileSharedUri) {
|
if (FileUtils.isExtensionImage(fileSharedUri)) {
|
addImageToPendingList(fileSharedUri);
|
} else {
|
if (fileSharedUri.startsWith("content://") || fileSharedUri.startsWith("file://")) {
|
fileSharedUri =
|
FileUtils.getFilePath(
|
getActivity().getApplicationContext(), Uri.parse(fileSharedUri));
|
} else if (fileSharedUri.contains("com.android.contacts/contacts/")) {
|
fileSharedUri = FileUtils.getCVSPathFromLookupUri(fileSharedUri).toString();
|
}
|
addFileToPendingList(fileSharedUri);
|
}
|
}
|
|
private void loadMoreData(final int totalItemsCount) {
|
LinphoneUtils.dispatchOnUIThread(
|
new Runnable() {
|
@Override
|
public void run() {
|
int maxSize = mChatRoom.getHistoryEventsSize();
|
if (totalItemsCount < maxSize) {
|
int upperBound = totalItemsCount + MESSAGES_PER_PAGE;
|
if (upperBound > maxSize) {
|
upperBound = maxSize;
|
}
|
EventLog[] newLogs;
|
newLogs = mChatRoom.getHistoryRangeEvents(totalItemsCount, upperBound);
|
ArrayList<EventLog> logsList = new ArrayList<>(Arrays.asList(newLogs));
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter())
|
.addAllToHistory(logsList);
|
}
|
}
|
});
|
}
|
|
/** Keyboard management */
|
private void addVirtualKeyboardVisiblityListener() {
|
mKeyboardListener =
|
new ViewTreeObserver.OnGlobalLayoutListener() {
|
@Override
|
public void onGlobalLayout() {
|
Rect visibleArea = new Rect();
|
getActivity()
|
.getWindow()
|
.getDecorView()
|
.getWindowVisibleDisplayFrame(visibleArea);
|
|
int screenHeight =
|
getActivity().getWindow().getDecorView().getRootView().getHeight();
|
int heightDiff = screenHeight - (visibleArea.bottom - visibleArea.top);
|
if (heightDiff > screenHeight * 0.15) {
|
showKeyboardVisibleMode();
|
} else {
|
hideKeyboardVisibleMode();
|
}
|
}
|
};
|
getActivity()
|
.getWindow()
|
.getDecorView()
|
.getViewTreeObserver()
|
.addOnGlobalLayoutListener(mKeyboardListener);
|
}
|
|
private void removeVirtualKeyboardVisiblityListener() {
|
getActivity()
|
.getWindow()
|
.getDecorView()
|
.getViewTreeObserver()
|
.removeOnGlobalLayoutListener(mKeyboardListener);
|
hideKeyboardVisibleMode();
|
}
|
|
private void showKeyboardVisibleMode() {
|
((ChatActivity) getActivity()).hideTabBar();
|
((ChatActivity) getActivity()).hideStatusBar();
|
mTopBar.setVisibility(View.GONE);
|
}
|
|
private void hideKeyboardVisibleMode() {
|
if (!getResources().getBoolean(R.bool.hide_bottom_bar_on_second_level_views)) {
|
((ChatActivity) getActivity()).showTabBar();
|
}
|
((ChatActivity) getActivity()).showStatusBar();
|
mTopBar.setVisibility(View.VISIBLE);
|
}
|
|
/** View initialization */
|
private void setReadOnly() {
|
mMessageTextToSend.setEnabled(false);
|
mAttachImageButton.setEnabled(false);
|
mSendMessageButton.setEnabled(false);
|
mSendEphemeralIcon.setEnabled(mSendMessageButton.isEnabled());
|
}
|
|
private void getContactsForParticipants() {
|
mParticipants = new ArrayList<>();
|
if (mChatRoom.hasCapability(ChatRoomCapabilities.OneToOne.toInt())) {
|
LinphoneContact c =
|
ContactsManager.getInstance().findContactFromAddress(mRemoteParticipantAddress);
|
if (c != null) {
|
mParticipants.add(c);
|
}
|
} else {
|
int index = 0;
|
StringBuilder participantsLabel = new StringBuilder();
|
for (Participant p : mChatRoom.getParticipants()) {
|
LinphoneContact c =
|
ContactsManager.getInstance().findContactFromAddress(p.getAddress());
|
if (c != null) {
|
mParticipants.add(c);
|
participantsLabel.append(c.getFullName());
|
} else {
|
String displayName = LinphoneUtils.getAddressDisplayName(p.getAddress());
|
participantsLabel.append(displayName);
|
}
|
index++;
|
if (index != mChatRoom.getNbParticipants()) participantsLabel.append(", ");
|
}
|
mParticipantsLabel.setText(participantsLabel.toString());
|
}
|
|
if (mChatEventsList.getAdapter() != null) {
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter()).setContacts(mParticipants);
|
}
|
}
|
|
private void initChatRoom() {
|
if (mChatRoom != null) {
|
// Required on tablets
|
mChatRoom.removeListener(this);
|
}
|
|
Core core = LinphoneManager.getCore();
|
if (mRemoteSipAddress == null
|
|| mRemoteSipUri == null
|
|| mRemoteSipUri.isEmpty()
|
|| core == null) {
|
// TODO error
|
return;
|
}
|
|
if (mLocalSipAddress != null) {
|
mChatRoom = core.getChatRoom(mRemoteSipAddress, mLocalSipAddress);
|
} else {
|
mChatRoom = core.getChatRoomFromUri(mRemoteSipAddress.asStringUriOnly());
|
}
|
mChatRoom.addListener(this);
|
mChatRoom.markAsRead();
|
|
((ChatActivity) getActivity()).displayMissedChats();
|
|
mRemoteParticipantAddress = mRemoteSipAddress;
|
if (mChatRoom.hasCapability(ChatRoomCapabilities.OneToOne.toInt())
|
&& mChatRoom.getParticipants().length > 0) {
|
mRemoteParticipantAddress = mChatRoom.getParticipants()[0].getAddress();
|
}
|
|
getContactsForParticipants();
|
|
mRemoteComposing.setVisibility(View.GONE);
|
}
|
|
private void displayChatRoomHeader() {
|
Core core = LinphoneManager.getCore();
|
if (core == null || mChatRoom == null) return;
|
|
if (mChatRoom.hasCapability(ChatRoomCapabilities.OneToOne.toInt())) {
|
mCallButton.setVisibility(View.VISIBLE);
|
|
if (mChatRoom.hasCapability(ChatRoomCapabilities.Basic.toInt())) {
|
mPopupMenu.setVisibility(View.GONE);
|
mSelectionHelper.setEditButtonVisibility(true);
|
} else {
|
mPopupMenu.setVisibility(View.VISIBLE);
|
mSelectionHelper.setEditButtonVisibility(false);
|
}
|
|
mParticipantsLabel.setVisibility(View.GONE);
|
|
if (mContext.getResources().getBoolean(R.bool.show_sip_uri_in_chat)) {
|
mSipUriLabel.setVisibility(View.VISIBLE);
|
} else {
|
mSipUriLabel.setVisibility(View.GONE);
|
mRoomLabel.setOnClickListener(
|
new View.OnClickListener() {
|
@Override
|
public void onClick(View v) {
|
mSipUriLabel.setVisibility(
|
mSipUriLabel.getVisibility() == View.VISIBLE
|
? View.GONE
|
: View.VISIBLE);
|
}
|
});
|
}
|
|
if (mParticipants.isEmpty()) {
|
// Contact not found
|
String displayName = LinphoneUtils.getAddressDisplayName(mRemoteParticipantAddress);
|
mRoomLabel.setText(displayName);
|
} else {
|
mRoomLabel.setText(mParticipants.get(0).getFullName());
|
}
|
mSipUriLabel.setText(mRemoteParticipantAddress.asStringUriOnly());
|
} else {
|
mCallButton.setVisibility(View.GONE);
|
mPopupMenu.setVisibility(View.VISIBLE);
|
mSelectionHelper.setEditButtonVisibility(false);
|
mRoomLabel.setText(mChatRoom.getSubject());
|
mParticipantsLabel.setVisibility(View.VISIBLE);
|
mSipUriLabel.setVisibility(View.GONE);
|
}
|
|
mBackToCallButton.setVisibility(View.GONE);
|
if (core.getCallsNb() > 0) {
|
mBackToCallButton.setVisibility(View.VISIBLE);
|
}
|
|
mSendEphemeralIcon.setVisibility(mChatRoom.ephemeralEnabled() ? View.VISIBLE : View.GONE);
|
if (mChatRoom.hasBeenLeft()) {
|
setReadOnly();
|
}
|
|
updateSecurityLevelIcon();
|
}
|
|
private void updateSecurityLevelIcon() {
|
if (!mChatRoom.hasCapability(ChatRoomCapabilities.Encrypted.toInt())) {
|
mChatRoomSecurityLevel.setVisibility(View.GONE);
|
} else {
|
mChatRoomSecurityLevel.setVisibility(View.VISIBLE);
|
ChatRoomSecurityLevel level = mChatRoom.getSecurityLevel();
|
switch (level) {
|
case Safe:
|
mChatRoomSecurityLevel.setImageResource(R.drawable.security_2_indicator);
|
break;
|
case Encrypted:
|
mChatRoomSecurityLevel.setImageResource(R.drawable.security_1_indicator);
|
break;
|
case ClearText:
|
case Unsafe:
|
mChatRoomSecurityLevel.setImageResource(R.drawable.security_alert_indicator);
|
break;
|
}
|
}
|
}
|
|
private void displayChatRoomHistory() {
|
if (mChatRoom == null) return;
|
ChatMessagesAdapter mEventsAdapter =
|
new ChatMessagesAdapter(
|
this,
|
mSelectionHelper,
|
R.layout.chat_bubble,
|
mChatRoom.getHistoryEvents(MESSAGES_PER_PAGE),
|
mParticipants,
|
this);
|
mSelectionHelper.setAdapter(mEventsAdapter);
|
mChatEventsList.setAdapter(mEventsAdapter);
|
scrollToBottom();
|
}
|
|
private void showSecurityDialog(boolean oneParticipantOneDevice) {
|
final Dialog dialog =
|
((ChatActivity) getActivity())
|
.displayDialog(getString(R.string.lime_security_popup));
|
Button delete = dialog.findViewById(R.id.dialog_delete_button);
|
delete.setVisibility(View.GONE);
|
Button ok = dialog.findViewById(R.id.dialog_ok_button);
|
ok.setText(oneParticipantOneDevice ? getString(R.string.call) : getString(R.string.ok));
|
ok.setVisibility(View.VISIBLE);
|
Button cancel = dialog.findViewById(R.id.dialog_cancel_button);
|
cancel.setText(getString(R.string.cancel));
|
|
dialog.findViewById(R.id.dialog_do_not_ask_again_layout).setVisibility(View.VISIBLE);
|
final CheckBox doNotAskAgain = dialog.findViewById(R.id.doNotAskAgain);
|
dialog.findViewById(R.id.doNotAskAgainLabel)
|
.setOnClickListener(
|
new View.OnClickListener() {
|
@Override
|
public void onClick(View v) {
|
doNotAskAgain.setChecked(!doNotAskAgain.isChecked());
|
}
|
});
|
|
ok.setTag(oneParticipantOneDevice);
|
ok.setOnClickListener(
|
new View.OnClickListener() {
|
@Override
|
public void onClick(View view) {
|
boolean oneParticipantOneDevice = (boolean) view.getTag();
|
if (doNotAskAgain.isChecked()) {
|
LinphonePreferences.instance().enableLimeSecurityPopup(false);
|
}
|
|
if (oneParticipantOneDevice) {
|
ParticipantDevice device =
|
mChatRoom.getParticipants()[0].getDevices()[0];
|
LinphoneManager.getCallManager()
|
.inviteAddress(device.getAddress(), true);
|
} else {
|
((ChatActivity) getActivity())
|
.showDevices(mLocalSipAddress, mRemoteSipAddress);
|
}
|
|
dialog.dismiss();
|
}
|
});
|
|
cancel.setOnClickListener(
|
new View.OnClickListener() {
|
@Override
|
public void onClick(View view) {
|
if (doNotAskAgain.isChecked()) {
|
LinphonePreferences.instance().enableLimeSecurityPopup(false);
|
}
|
dialog.dismiss();
|
}
|
});
|
dialog.show();
|
}
|
|
private void scrollToBottom() {
|
mChatEventsList.getLayoutManager().scrollToPosition(0);
|
}
|
|
@Override
|
public void onItemClicked(int position) {
|
if (mSelectionHelper.getAdapter().isEditionEnabled()) {
|
mSelectionHelper.getAdapter().toggleSelection(position);
|
}
|
}
|
|
private void onRestoreInstanceState(Bundle savedInstanceState) {
|
ArrayList<String> files = savedInstanceState.getStringArrayList("Files");
|
if (files != null && !files.isEmpty()) {
|
for (String file : files) {
|
if (FileUtils.isExtensionImage(file)) {
|
addImageToPendingList(file);
|
} else {
|
addFileToPendingList(file);
|
}
|
}
|
}
|
|
final InputContentInfoCompat previousInputContentInfo =
|
InputContentInfoCompat.wrap(
|
savedInstanceState.getParcelable(INPUT_CONTENT_INFO_KEY));
|
final int previousFlags = savedInstanceState.getInt(COMMIT_CONTENT_FLAGS_KEY);
|
if (previousInputContentInfo != null) {
|
onCommitContentInternal(previousInputContentInfo, previousFlags);
|
}
|
}
|
|
private void pickFile() {
|
List<Intent> cameraIntents = new ArrayList<>();
|
|
// Handles image & video picking
|
Intent galleryIntent = new Intent(Intent.ACTION_PICK);
|
galleryIntent.setType("*/*");
|
galleryIntent.putExtra(Intent.EXTRA_MIME_TYPES, new String[] {"image/*", "video/*"});
|
|
// Allows to capture directly from the camera
|
Intent captureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
|
File file =
|
new File(
|
FileUtils.getStorageDirectory(mContext),
|
getString(R.string.temp_photo_name_with_date)
|
.replace("%s", System.currentTimeMillis() + ".jpeg"));
|
mImageToUploadUri = Uri.fromFile(file);
|
captureIntent.putExtra(MediaStore.EXTRA_OUTPUT, mImageToUploadUri);
|
cameraIntents.add(captureIntent);
|
|
// Finally allow any kind of file
|
Intent fileIntent = new Intent(Intent.ACTION_GET_CONTENT);
|
fileIntent.setType("*/*");
|
cameraIntents.add(fileIntent);
|
|
Intent chooserIntent =
|
Intent.createChooser(galleryIntent, getString(R.string.image_picker_title));
|
chooserIntent.putExtra(
|
Intent.EXTRA_INITIAL_INTENTS, cameraIntents.toArray(new Parcelable[] {}));
|
|
startActivityForResult(chooserIntent, ADD_PHOTO);
|
}
|
|
private void addFileToPendingList(String path) {
|
if (path == null) {
|
Log.e(
|
"[Chat Messages Fragment] Can't add file to pending list because it's path is null...");
|
return;
|
}
|
|
View pendingFile = mInflater.inflate(R.layout.file_upload_cell, mFilesUploadLayout, false);
|
pendingFile.setTag(path);
|
|
TextView text = pendingFile.findViewById(R.id.pendingFileForUpload);
|
String extension = path.substring(path.lastIndexOf('.'));
|
text.setText(extension);
|
|
ImageView remove = pendingFile.findViewById(R.id.remove);
|
remove.setTag(pendingFile);
|
remove.setOnClickListener(
|
new View.OnClickListener() {
|
@Override
|
public void onClick(View view) {
|
View pendingImage = (View) view.getTag();
|
mFilesUploadLayout.removeView(pendingImage);
|
mAttachImageButton.setEnabled(true);
|
mMessageTextToSend.setEnabled(true);
|
mSendMessageButton.setEnabled(
|
mMessageTextToSend.getText().length() > 0
|
|| mFilesUploadLayout.getChildCount() > 0);
|
mSendEphemeralIcon.setEnabled(mSendMessageButton.isEnabled());
|
}
|
});
|
|
mFilesUploadLayout.addView(pendingFile);
|
|
if (!getResources().getBoolean(R.bool.allow_multiple_images_and_text)) {
|
mAttachImageButton.setEnabled(false);
|
mMessageTextToSend.setEnabled(false);
|
}
|
mSendMessageButton.setEnabled(true);
|
mSendEphemeralIcon.setEnabled(mSendMessageButton.isEnabled());
|
}
|
|
private void addImageToPendingList(String path) {
|
if (path == null) {
|
Log.e(
|
"[Chat Messages Fragment] Can't add image to pending list because it's path is null...");
|
return;
|
}
|
|
View pendingImage =
|
mInflater.inflate(R.layout.image_upload_cell, mFilesUploadLayout, false);
|
pendingImage.setTag(path);
|
|
ImageView image = pendingImage.findViewById(R.id.pendingImageForUpload);
|
Glide.with(mContext).load(path).into(image);
|
|
ImageView remove = pendingImage.findViewById(R.id.remove);
|
remove.setTag(pendingImage);
|
remove.setOnClickListener(
|
new View.OnClickListener() {
|
@Override
|
public void onClick(View view) {
|
View pendingImage = (View) view.getTag();
|
mFilesUploadLayout.removeView(pendingImage);
|
mAttachImageButton.setEnabled(true);
|
mMessageTextToSend.setEnabled(true);
|
mSendMessageButton.setEnabled(
|
mMessageTextToSend.getText().length() > 0
|
|| mFilesUploadLayout.getChildCount() > 0);
|
mSendEphemeralIcon.setEnabled(mSendMessageButton.isEnabled());
|
}
|
});
|
|
mFilesUploadLayout.addView(pendingImage);
|
|
if (!getResources().getBoolean(R.bool.allow_multiple_images_and_text)) {
|
mAttachImageButton.setEnabled(false);
|
mMessageTextToSend.setEnabled(false);
|
}
|
mSendMessageButton.setEnabled(true);
|
mSendEphemeralIcon.setEnabled(mSendMessageButton.isEnabled());
|
}
|
|
/** Message sending */
|
private void sendMessage() {
|
ChatMessage msg = mChatRoom.createEmptyMessage();
|
boolean isBasicChatRoom = mChatRoom.hasCapability(ChatRoomCapabilities.Basic.toInt());
|
boolean sendMultipleImagesAsDifferentMessages =
|
getResources().getBoolean(R.bool.send_multiple_images_as_different_messages);
|
boolean sendImageAndTextAsDifferentMessages =
|
getResources().getBoolean(R.bool.send_text_and_images_as_different_messages);
|
|
String text = mMessageTextToSend.getText().toString();
|
boolean hasText = text != null && text.length() > 0;
|
|
int filesCount = mFilesUploadLayout.getChildCount();
|
for (int i = 0; i < filesCount; i++) {
|
String filePath = (String) mFilesUploadLayout.getChildAt(i).getTag();
|
String fileName = filePath.substring(filePath.lastIndexOf("/") + 1);
|
String extension = FileUtils.getExtensionFromFileName(fileName);
|
Content content = Factory.instance().createContent();
|
if (FileUtils.isExtensionImage(fileName)) {
|
content.setType("image");
|
} else {
|
content.setType("file");
|
}
|
content.setSubtype(extension);
|
content.setName(fileName);
|
content.setFilePath(filePath); // Let the file body handler take care of the upload
|
|
boolean split =
|
isBasicChatRoom; // Always split contents in basic chat rooms for compatibility
|
if (hasText && sendImageAndTextAsDifferentMessages) {
|
split = true;
|
} else if (mFilesUploadLayout.getChildCount() > 1
|
&& sendMultipleImagesAsDifferentMessages) {
|
split = true;
|
|
// Allow the last image to be sent with text if image and text at the same time OK
|
if (hasText && i == filesCount - 1) {
|
split = false;
|
}
|
}
|
|
if (split) {
|
ChatMessage fileMessage = mChatRoom.createFileTransferMessage(content);
|
fileMessage.send();
|
} else {
|
msg.addFileContent(content);
|
}
|
}
|
|
if (hasText) {
|
msg.addTextContent(text);
|
}
|
|
// Set listener not required here anymore, message will be added to messages list and
|
// adapter will set the listener
|
if (msg.getContents().length > 0) {
|
msg.send();
|
}
|
|
mFilesUploadLayout.removeAllViews();
|
mAttachImageButton.setEnabled(true);
|
mMessageTextToSend.setEnabled(true);
|
mMessageTextToSend.setText("");
|
}
|
|
private void showPopupMenu() {
|
MenuBuilder builder = new MenuBuilder(getActivity());
|
MenuPopupHelper popupMenu = new MenuPopupHelper(getActivity(), builder, mPopupMenu);
|
popupMenu.setForceShowIcon(true);
|
|
new MenuInflater(getActivity()).inflate(R.menu.chat_room_menu, builder);
|
|
if (mChatRoom.hasCapability(ChatRoomCapabilities.OneToOne.toInt())) {
|
builder.removeItem(R.id.chat_room_group_info);
|
}
|
|
if (!mChatRoom.hasCapability(ChatRoomCapabilities.Encrypted.toInt())) {
|
builder.removeItem(R.id.chat_room_participants_devices);
|
builder.removeItem(R.id.chat_room_ephemeral_messages);
|
} else {
|
if (!LinphonePreferences.instance().isEphemeralMessagesEnabled()) {
|
builder.removeItem(R.id.chat_room_ephemeral_messages);
|
}
|
}
|
|
builder.setCallback(
|
new MenuBuilder.Callback() {
|
@Override
|
public boolean onMenuItemSelected(MenuBuilder menu, MenuItem item) {
|
if (item.getItemId() == R.id.chat_room_group_info) {
|
goToGroupInfo();
|
return true;
|
} else if (item.getItemId() == R.id.chat_room_participants_devices) {
|
goToDevices();
|
return true;
|
} else if (item.getItemId() == R.id.chat_room_ephemeral_messages) {
|
goToEphemeral();
|
return true;
|
} else if (item.getItemId() == R.id.chat_room_delete_messages) {
|
mSelectionHelper.enterEditionMode();
|
return true;
|
}
|
return false;
|
}
|
|
@Override
|
public void onMenuModeChange(MenuBuilder menu) {}
|
});
|
|
popupMenu.show();
|
}
|
|
private void goToDevices() {
|
boolean oneParticipantOneDevice = false;
|
if (mChatRoom.hasCapability(ChatRoomCapabilities.OneToOne.toInt())) {
|
ParticipantDevice[] devices = mChatRoom.getParticipants()[0].getDevices();
|
// Only start a call automatically if both ourselves and the remote
|
// have 1 device exactly, otherwise show devices list.
|
oneParticipantOneDevice =
|
devices.length == 1 && mChatRoom.getMe().getDevices().length == 1;
|
}
|
|
if (LinphonePreferences.instance().isLimeSecurityPopupEnabled()) {
|
showSecurityDialog(oneParticipantOneDevice);
|
} else {
|
if (oneParticipantOneDevice) {
|
ParticipantDevice device = mChatRoom.getParticipants()[0].getDevices()[0];
|
LinphoneManager.getCallManager().inviteAddress(device.getAddress(), true);
|
} else {
|
((ChatActivity) getActivity()).showDevices(mLocalSipAddress, mRemoteSipAddress);
|
}
|
}
|
}
|
|
private void goToGroupInfo() {
|
if (mChatRoom == null) return;
|
ArrayList<ContactAddress> participants = new ArrayList<>();
|
for (Participant p : mChatRoom.getParticipants()) {
|
Address a = p.getAddress();
|
LinphoneContact c = ContactsManager.getInstance().findContactFromAddress(a);
|
if (c == null) {
|
c = new LinphoneContact();
|
String displayName = LinphoneUtils.getAddressDisplayName(a);
|
c.setFullName(displayName);
|
}
|
ContactAddress ca = new ContactAddress(c, a.asString(), "", p.isAdmin());
|
participants.add(ca);
|
}
|
|
boolean encrypted = mChatRoom.hasCapability(ChatRoomCapabilities.Encrypted.toInt());
|
((ChatActivity) getActivity())
|
.showChatRoomGroupInfo(
|
mRemoteSipAddress, participants, mChatRoom.getSubject(), encrypted);
|
}
|
|
private void goToEphemeral() {
|
if (mChatRoom == null) return;
|
((ChatActivity) getActivity()).showChatRoomEphemeral(mRemoteSipAddress);
|
}
|
|
/*
|
* Chat room callbacks
|
*/
|
|
@Override
|
public void onChatMessageSent(ChatRoom cr, EventLog event) {
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter()).addToHistory(event);
|
scrollToBottom();
|
}
|
|
@Override
|
public void onConferenceAddressGeneration(ChatRoom cr) {}
|
|
@Override
|
public void onParticipantRegistrationSubscriptionRequested(
|
ChatRoom cr, Address participantAddr) {}
|
|
@Override
|
public void onParticipantRegistrationUnsubscriptionRequested(
|
ChatRoom cr, Address participantAddr) {}
|
|
@Override
|
public void onUndecryptableMessageReceived(ChatRoom cr, ChatMessage msg) {
|
final Address from = msg.getFromAddress();
|
final LinphoneContact contact = ContactsManager.getInstance().findContactFromAddress(from);
|
|
if (LinphoneManager.getCore().limeX3DhEnabled()) {
|
final Dialog dialog =
|
((ChatActivity) getActivity())
|
.displayDialog(
|
getString(R.string.message_cant_be_decrypted)
|
.replace(
|
"%s",
|
(contact != null)
|
? contact.getFullName()
|
: from.getUsername()));
|
Button delete = dialog.findViewById(R.id.dialog_delete_button);
|
delete.setText(getString(R.string.call));
|
Button cancel = dialog.findViewById(R.id.dialog_cancel_button);
|
cancel.setText(getString(R.string.ok));
|
delete.setOnClickListener(
|
new View.OnClickListener() {
|
@Override
|
public void onClick(View view) {
|
LinphoneManager.getCallManager()
|
.newOutgoingCall(
|
from.asStringUriOnly(),
|
(contact != null)
|
? contact.getFullName()
|
: from.getUsername());
|
dialog.dismiss();
|
}
|
});
|
|
cancel.setOnClickListener(
|
new View.OnClickListener() {
|
@Override
|
public void onClick(View view) {
|
dialog.dismiss();
|
}
|
});
|
dialog.show();
|
}
|
}
|
|
@Override
|
public void onChatMessageReceived(ChatRoom cr, EventLog event) {
|
cr.markAsRead();
|
((ChatActivity) getActivity()).displayMissedChats();
|
|
ChatMessage msg = event.getChatMessage();
|
if (msg.getErrorInfo() != null
|
&& msg.getErrorInfo().getReason() == Reason.UnsupportedContent) {
|
Log.w(
|
"[Chat Messages Fragment] Message received but content is unsupported, do not display it");
|
return;
|
}
|
|
if (!msg.hasTextContent() && msg.getFileTransferInformation() == null) {
|
Log.w(
|
"[Chat Messages Fragment] Message has no text or file transfer information to display, ignoring it...");
|
return;
|
}
|
|
String externalBodyUrl = msg.getExternalBodyUrl();
|
Content fileTransferContent = msg.getFileTransferInformation();
|
if (externalBodyUrl != null || fileTransferContent != null) {
|
((ChatActivity) getActivity())
|
.requestPermissionIfNotGranted(Manifest.permission.WRITE_EXTERNAL_STORAGE);
|
}
|
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter()).addToHistory(event);
|
scrollToBottom();
|
}
|
|
@Override
|
public void onIsComposingReceived(ChatRoom cr, Address remoteAddr, boolean isComposing) {
|
ArrayList<String> composing = new ArrayList<>();
|
for (Address a : cr.getComposingAddresses()) {
|
boolean found = false;
|
for (LinphoneContact c : mParticipants) {
|
if (c.hasAddress(a.asStringUriOnly())) {
|
composing.add(c.getFullName());
|
found = true;
|
break;
|
}
|
}
|
if (!found) {
|
LinphoneContact contact =
|
ContactsManager.getInstance().findContactFromAddress(remoteAddr);
|
String displayName;
|
if (contact != null) {
|
if (contact.getFullName() != null) {
|
displayName = contact.getFullName();
|
} else {
|
displayName = LinphoneUtils.getAddressDisplayName(remoteAddr);
|
}
|
} else {
|
displayName = LinphoneUtils.getAddressDisplayName(a);
|
}
|
composing.add(displayName);
|
}
|
}
|
|
mRemoteComposing.setVisibility(View.VISIBLE);
|
if (composing.isEmpty()) {
|
mRemoteComposing.setVisibility(View.GONE);
|
} else if (composing.size() == 1) {
|
mRemoteComposing.setText(
|
getString(R.string.remote_composing_single).replace("%s", composing.get(0)));
|
} else {
|
StringBuilder remotes = new StringBuilder();
|
int i = 0;
|
for (String remote : composing) {
|
remotes.append(remote);
|
i++;
|
if (i != composing.size()) {
|
remotes.append(", ");
|
}
|
}
|
mRemoteComposing.setText(
|
getString(R.string.remote_composing_multiple)
|
.replace("%s", remotes.toString()));
|
}
|
}
|
|
@Override
|
public void onMessageReceived(ChatRoom cr, ChatMessage msg) {}
|
|
@Override
|
public void onConferenceJoined(ChatRoom cr, EventLog event) {
|
// Currently flexisip doesn't send the participants list in the INVITE
|
// So we have to refresh the display when information is available
|
// In the meantime header will be chatroom-xxxxxxx
|
if (mChatRoom == null) mChatRoom = cr;
|
if (mChatRoom.hasCapability(ChatRoomCapabilities.OneToOne.toInt())
|
&& mChatRoom.getParticipants().length > 0) {
|
mRemoteParticipantAddress = mChatRoom.getParticipants()[0].getAddress();
|
}
|
getContactsForParticipants();
|
displayChatRoomHeader();
|
|
if (mChatRoom.hasCapability(ChatRoomCapabilities.OneToOne.toInt())) return;
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter()).addToHistory(event);
|
scrollToBottom();
|
}
|
|
@Override
|
public void onConferenceLeft(ChatRoom cr, EventLog event) {
|
if (mChatRoom.hasCapability(ChatRoomCapabilities.OneToOne.toInt())) return;
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter()).addToHistory(event);
|
scrollToBottom();
|
}
|
|
@Override
|
public void onEphemeralEvent(ChatRoom chatRoom, EventLog eventLog) {
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter()).addToHistory(eventLog);
|
scrollToBottom();
|
}
|
|
@Override
|
public void onEphemeralMessageTimerStarted(ChatRoom chatRoom, EventLog eventLog) {}
|
|
@Override
|
public void onEphemeralMessageDeleted(ChatRoom chatRoom, EventLog eventLog) {
|
Log.i("[Chat Room] Ephemeral message expired");
|
LinphoneUtils.deleteFileContentIfExists(eventLog);
|
|
if (!((ChatMessagesGenericAdapter) mChatEventsList.getAdapter())
|
.removeFromHistory(eventLog)) {
|
Log.w("[Chat Room] Ephemeral message not found, refresh list");
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter())
|
.refresh(mChatRoom.getHistoryEvents(MESSAGES_PER_PAGE));
|
}
|
}
|
|
@Override
|
public void onParticipantAdminStatusChanged(ChatRoom cr, EventLog event) {
|
if (mChatRoom.hasCapability(ChatRoomCapabilities.OneToOne.toInt())) return;
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter()).addToHistory(event);
|
scrollToBottom();
|
}
|
|
@Override
|
public void onParticipantDeviceRemoved(ChatRoom cr, EventLog event) {}
|
|
@Override
|
public void onParticipantRemoved(ChatRoom cr, EventLog event) {
|
if (mChatRoom.hasCapability(ChatRoomCapabilities.OneToOne.toInt())) return;
|
getContactsForParticipants();
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter()).addToHistory(event);
|
scrollToBottom();
|
}
|
|
@Override
|
public void onChatMessageShouldBeStored(ChatRoom cr, ChatMessage msg) {}
|
|
@Override
|
public void onParticipantDeviceAdded(ChatRoom cr, EventLog event) {}
|
|
@Override
|
public void onSecurityEvent(ChatRoom cr, EventLog eventLog) {
|
updateSecurityLevelIcon();
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter()).addToHistory(eventLog);
|
scrollToBottom();
|
}
|
|
@Override
|
public void onStateChanged(ChatRoom cr, ChatRoom.State newState) {
|
if (mChatRoom.hasBeenLeft()) {
|
setReadOnly();
|
}
|
}
|
|
@Override
|
public void onParticipantAdded(ChatRoom cr, EventLog event) {
|
if (mChatRoom.hasCapability(ChatRoomCapabilities.OneToOne.toInt())) return;
|
getContactsForParticipants();
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter()).addToHistory(event);
|
scrollToBottom();
|
}
|
|
@Override
|
public void onChatMessageParticipantImdnStateChanged(
|
ChatRoom cr, ChatMessage msg, ParticipantImdnState state) {}
|
|
@Override
|
public void onSubjectChanged(ChatRoom cr, EventLog event) {
|
if (mChatRoom.hasCapability(ChatRoomCapabilities.OneToOne.toInt())) return;
|
mRoomLabel.setText(event.getSubject());
|
((ChatMessagesGenericAdapter) mChatEventsList.getAdapter()).addToHistory(event);
|
scrollToBottom();
|
}
|
|
@Override
|
public void onContactsUpdated() {
|
getContactsForParticipants();
|
displayChatRoomHeader();
|
mChatEventsList.getAdapter().notifyDataSetChanged();
|
}
|
|
@Override
|
public boolean onCommitContent(
|
InputContentInfoCompat inputContentInfo,
|
int flags,
|
Bundle opts,
|
String[] contentMimeTypes) {
|
try {
|
if (mCurrentInputContentInfo != null) {
|
mCurrentInputContentInfo.releasePermission();
|
}
|
} catch (Exception e) {
|
Log.e("[Chat Messages Fragment] releasePermission failed : ", e);
|
} finally {
|
mCurrentInputContentInfo = null;
|
}
|
|
boolean supported = false;
|
for (final String mimeType : contentMimeTypes) {
|
if (inputContentInfo.getDescription().hasMimeType(mimeType)) {
|
supported = true;
|
break;
|
}
|
}
|
if (!supported) {
|
return false;
|
}
|
|
return onCommitContentInternal(inputContentInfo, flags);
|
}
|
|
private boolean onCommitContentInternal(InputContentInfoCompat inputContentInfo, int flags) {
|
if ((flags & InputConnectionCompat.INPUT_CONTENT_GRANT_READ_URI_PERMISSION) != 0) {
|
try {
|
inputContentInfo.requestPermission();
|
} catch (Exception e) {
|
Log.e("[Chat Messages Fragment] requestPermission failed : ", e);
|
return false;
|
}
|
}
|
|
if (inputContentInfo.getContentUri() != null) {
|
String contentUri = FileUtils.getFilePath(mContext, inputContentInfo.getContentUri());
|
addImageToPendingList(contentUri);
|
}
|
|
mCurrentInputContentInfo = inputContentInfo;
|
|
return true;
|
}
|
|
// This is a workaround to prevent a crash from happening while rotating the device
|
private class LinphoneLinearLayoutManager extends LinearLayoutManager {
|
LinphoneLinearLayoutManager(Context context, int orientation, boolean reverseLayout) {
|
super(context, orientation, reverseLayout);
|
}
|
|
@Override
|
public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
|
try {
|
super.onLayoutChildren(recycler, state);
|
} catch (IndexOutOfBoundsException e) {
|
Log.e(
|
"[Chat Messages Fragment] InvalidIndexOutOfBound Exception, probably while rotating the device");
|
}
|
}
|
}
|
}
|
