diff options
Diffstat (limited to 'src/main/java/de/pixart/messenger/ui/ConversationLegacyActivity.java')
| -rw-r--r-- | src/main/java/de/pixart/messenger/ui/ConversationLegacyActivity.java | 1028 |
1 files changed, 1028 insertions, 0 deletions
diff --git a/src/main/java/de/pixart/messenger/ui/ConversationLegacyActivity.java b/src/main/java/de/pixart/messenger/ui/ConversationLegacyActivity.java new file mode 100644 index 000000000..5c99ff001 --- /dev/null +++ b/src/main/java/de/pixart/messenger/ui/ConversationLegacyActivity.java @@ -0,0 +1,1028 @@ +/* + * Copyright (c) 2018, Daniel Gultsch All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation and/or + * other materials provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package de.pixart.messenger.ui; + +import android.annotation.SuppressLint; +import android.app.FragmentTransaction; +import android.content.ActivityNotFoundException; +import android.content.Context; +import android.content.Intent; +import android.content.SharedPreferences; +import android.content.pm.ApplicationInfo; +import android.content.pm.PackageManager; +import android.graphics.Typeface; +import android.net.Uri; +import android.os.Build; +import android.os.Bundle; +import android.preference.PreferenceManager; +import android.provider.Settings; +import android.support.v4.widget.SlidingPaneLayout; +import android.support.v4.widget.SlidingPaneLayout.PanelSlideListener; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AlertDialog; +import android.util.Log; +import android.util.Pair; +import android.view.KeyEvent; +import android.view.Menu; +import android.view.MenuItem; +import android.view.Surface; +import android.view.View; +import android.widget.AdapterView; +import android.widget.AdapterView.OnItemClickListener; +import android.widget.ArrayAdapter; +import android.widget.ListView; +import android.widget.TextView; +import android.widget.Toast; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.atomic.AtomicBoolean; + +import de.pixart.messenger.Config; +import de.pixart.messenger.R; +import de.pixart.messenger.entities.Account; +import de.pixart.messenger.entities.Conversation; +import de.pixart.messenger.entities.Message; +import de.pixart.messenger.entities.MucOptions; +import de.pixart.messenger.entities.Presence; +import de.pixart.messenger.services.EmojiService; +import de.pixart.messenger.services.UpdateService; +import de.pixart.messenger.services.XmppConnectionService; +import de.pixart.messenger.services.XmppConnectionService.OnAccountUpdate; +import de.pixart.messenger.services.XmppConnectionService.OnConversationUpdate; +import de.pixart.messenger.services.XmppConnectionService.OnRosterUpdate; +import de.pixart.messenger.ui.adapter.ConversationAdapter; +import de.pixart.messenger.utils.UIHelper; +import de.pixart.messenger.xmpp.OnUpdateBlocklist; +import de.pixart.messenger.xmpp.chatstate.ChatState; +import de.pixart.messenger.xmpp.jid.InvalidJidException; +import de.pixart.messenger.xmpp.jid.Jid; + +import static de.pixart.messenger.ui.SettingsActivity.USE_BUNDLED_EMOJIS; + +public class ConversationLegacyActivity extends XmppActivity + implements OnAccountUpdate, OnConversationUpdate, OnRosterUpdate, OnUpdateBlocklist, XmppConnectionService.OnShowErrorToast, View.OnClickListener { + + public static final String ACTION_VIEW_CONVERSATION = "de.pixart.messenger.VIEW"; + public static final String ACTION_DESTROY_MUC = "de.pixart.messenger.DESTROY_MUC"; + public static final String CONVERSATION = "conversationUuid"; + public static final String EXTRA_DOWNLOAD_UUID = "de.pixart.messenger.download_uuid"; + public static final String TEXT = "text"; + public static final String NICK = "nick"; + public static final String PRIVATE_MESSAGE = "pm"; + + private static final String STATE_OPEN_CONVERSATION = "state_open_conversation"; + private static final String STATE_PANEL_OPEN = "state_panel_open"; + private static final String STATE_PENDING_IMAGE_URI = "state_pending_image_uri"; + private static final String STATE_PENDING_PHOTO_URI = "state_pending_photo_uri"; + private static final String STATE_FIRST_VISIBLE = "first_visible"; + private static final String STATE_OFFSET_FROM_TOP = "offset_from_top"; + + private String mOpenConversation = null; + private boolean mPanelOpen = true; + private AtomicBoolean mShouldPanelBeOpen = new AtomicBoolean(false); + private Pair<Integer, Integer> mScrollPosition = null; + private boolean forbidProcessingPendings = false; + + private boolean conversationWasSelectedByKeyboard = false; + + private View mContentView; + + private List<Conversation> conversationList = new ArrayList<>(); + private Conversation swipedConversation = null; + private Conversation mSelectedConversation = null; + private ListView listView; + public ConversationFragment mConversationFragment; + + private ArrayAdapter<Conversation> listAdapter; + + private boolean mActivityPaused = false; + private AtomicBoolean mRedirected = new AtomicBoolean(false); + private boolean mUnprocessedNewIntent = false; + private boolean showLastSeen = false; + + long FirstStartTime = -1; + + String PREF_FIRST_START = "FirstStart"; + + public Conversation getSelectedConversation() { + return this.mSelectedConversation; + } + + public void setSelectedConversation(Conversation conversation) { + this.mSelectedConversation = conversation; + } + + public void showConversationsOverview() { + if (mConversationFragment != null) { + mConversationFragment.stopScrolling(); + mConversationFragment.hideSearchField(); + } + if (mContentView instanceof SlidingPaneLayout) { + SlidingPaneLayout mSlidingPaneLayout = (SlidingPaneLayout) mContentView; + mShouldPanelBeOpen.set(true); + mSlidingPaneLayout.openPane(); + } + } + + @Override + protected String getShareableUri() { + Conversation conversation = getSelectedConversation(); + if (conversation != null) { + return conversation.getAccount().getShareableUri(); + } else { + return ""; + } + } + + public void hideConversationsOverview() { + if (mContentView instanceof SlidingPaneLayout) { + SlidingPaneLayout mSlidingPaneLayout = (SlidingPaneLayout) mContentView; + mShouldPanelBeOpen.set(false); + mSlidingPaneLayout.closePane(); + } + } + + public boolean isConversationsOverviewHideable() { + if (mContentView instanceof SlidingPaneLayout) { + return true; + } else { + return false; + } + } + + public boolean isConversationsOverviewVisable() { + if (mContentView instanceof SlidingPaneLayout) { + return mShouldPanelBeOpen.get(); + } else { + return true; + } + } + + @SuppressLint("ClickableViewAccessibility") + @Override + protected void onCreate(final Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + new EmojiService(this).init(useBundledEmoji()); + if (savedInstanceState != null) { + mOpenConversation = savedInstanceState.getString(STATE_OPEN_CONVERSATION, null); + mPanelOpen = savedInstanceState.getBoolean(STATE_PANEL_OPEN, true); + int pos = savedInstanceState.getInt(STATE_FIRST_VISIBLE, -1); + int offset = savedInstanceState.getInt(STATE_OFFSET_FROM_TOP, 1); + if (pos >= 0 && offset <= 0) { + Log.d(Config.LOGTAG, "retrieved scroll position from instanceState " + pos + ":" + offset); + mScrollPosition = new Pair<>(pos, offset); + } else { + mScrollPosition = null; + } + } + + setContentView(R.layout.fragment_conversations_overview); + + this.mConversationFragment = new ConversationFragment(); + FragmentTransaction transaction = getFragmentManager().beginTransaction(); + //transaction.replace(R.id.selected_conversation, this.mConversationFragment, "conversation"); + transaction.commit(); + + listView = findViewById(R.id.list); + this.listAdapter = new ConversationAdapter(this, conversationList); + listView.setAdapter(this.listAdapter); + + final ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayOptions(ActionBar.DISPLAY_SHOW_TITLE); + } + + listView.setOnItemClickListener(new OnItemClickListener() { + + @Override + public void onItemClick(AdapterView<?> arg0, View clickedView, + int position, long arg3) { + if (getSelectedConversation() != conversationList.get(position)) { + ConversationLegacyActivity.this.mConversationFragment.stopScrolling(); + setSelectedConversation(conversationList.get(position)); + ConversationLegacyActivity.this.mConversationFragment.reInit(getSelectedConversation()); + conversationWasSelectedByKeyboard = false; + } + hideConversationsOverview(); + openConversation(); + } + }); + + //mContentView = findViewById(R.id.content_view_spl); + if (mContentView == null) { + //mContentView = findViewById(R.id.content_view_ll); + } + if (mContentView instanceof SlidingPaneLayout) { + SlidingPaneLayout mSlidingPaneLayout = (SlidingPaneLayout) mContentView; + mSlidingPaneLayout.setShadowResourceLeft(R.drawable.es_slidingpane_shadow); + mSlidingPaneLayout.setSliderFadeColor(0); + mSlidingPaneLayout.setPanelSlideListener(new PanelSlideListener() { + + @Override + public void onPanelOpened(View arg0) { + mShouldPanelBeOpen.set(true); + updateActionBarTitle(); + invalidateOptionsMenu(); + hideKeyboard(); + if (xmppConnectionServiceBound) { + xmppConnectionService.getNotificationService().setOpenConversation(null); + } + closeContextMenu(); + mConversationFragment.hideSearchField(); + } + + @Override + public void onPanelClosed(View arg0) { + mShouldPanelBeOpen.set(false); + openConversation(); + } + + @Override + public void onPanelSlide(View arg0, float arg1) { + // TODO Auto-generated method stub + + } + }); + } + } + + public boolean useBundledEmoji() { + return getPreferences().getBoolean(USE_BUNDLED_EMOJIS, getResources().getBoolean(R.bool.use_bundled_emoji)); + } + + private boolean isPackageInstalled(String targetPackage) { + List<ApplicationInfo> packages; + PackageManager pm; + pm = getPackageManager(); + packages = pm.getInstalledApplications(0); + for (ApplicationInfo packageInfo : packages) { + if (packageInfo.packageName.equals(targetPackage)) return true; + } + return false; + } + + protected void AppUpdate(boolean PlayStore) { + if (PlayStore) { + return; + } + String PREFS_NAME = "UpdateTimeStamp"; + SharedPreferences UpdateTimeStamp = getApplicationContext().getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + long lastUpdateTime = UpdateTimeStamp.getLong("lastUpdateTime", 0); + Log.d(Config.LOGTAG, "AppUpdater: LastUpdateTime: " + lastUpdateTime); + if ((lastUpdateTime + (Config.UPDATE_CHECK_TIMER * 1000)) < System.currentTimeMillis()) { + lastUpdateTime = System.currentTimeMillis(); + SharedPreferences.Editor editor = UpdateTimeStamp.edit(); + editor.putLong("lastUpdateTime", lastUpdateTime); + editor.apply(); + Log.d(Config.LOGTAG, "AppUpdater: CurrentTime: " + lastUpdateTime); + if (!installFromUnknownSourceAllowed() && !PlayStore) { + openInstallFromUnknownSourcesDialogIfNeeded(); + } else { + UpdateService task = new UpdateService(this, PlayStore); + task.executeOnExecutor(UpdateService.THREAD_POOL_EXECUTOR, "false"); + Log.d(Config.LOGTAG, "AppUpdater started"); + } + } else { + Log.d(Config.LOGTAG, "AppUpdater stopped"); + return; + } + } + + @Override + public void switchToConversation(Conversation conversation) { + setSelectedConversation(conversation); + runOnUiThread(() -> { + ConversationLegacyActivity.this.mConversationFragment.reInit(getSelectedConversation()); + openConversation(); + }); + } + + private void updateActionBarTitle() { + updateActionBarTitle(isConversationsOverviewHideable() && !isConversationsOverviewVisable()); + } + + private void updateActionBarTitle(boolean titleShouldBeName) { + final ActionBar ab = getSupportActionBar(); + final Conversation conversation = getSelectedConversation(); + if (ab != null) { + if (titleShouldBeName && conversation != null) { + if ((ab.getDisplayOptions() & ActionBar.DISPLAY_HOME_AS_UP) != ActionBar.DISPLAY_HOME_AS_UP) { + ab.setDisplayOptions(ActionBar.DISPLAY_HOME_AS_UP | ActionBar.DISPLAY_SHOW_TITLE); + } + ab.setDisplayShowTitleEnabled(false); + ab.setDisplayShowCustomEnabled(true); + ab.setCustomView(R.layout.ab_title); + TextView abtitle = findViewById(android.R.id.text1); + TextView absubtitle = findViewById(android.R.id.text2); + abtitle.setText(conversation.getName()); + abtitle.setOnClickListener(this); + abtitle.setSelected(true); + if (conversation.getMode() == Conversation.MODE_SINGLE && !this.getSelectedConversation().withSelf()) { + ChatState state = conversation.getIncomingChatState(); + if (conversation.getContact().getShownStatus() == Presence.Status.OFFLINE) { + absubtitle.setText(getString(R.string.account_status_offline)); + absubtitle.setSelected(true); + absubtitle.setOnClickListener(this); + } else { + if (state == ChatState.COMPOSING) { + absubtitle.setText(getString(R.string.is_typing)); + absubtitle.setTypeface(null, Typeface.BOLD_ITALIC); + absubtitle.setSelected(true); + absubtitle.setOnClickListener(this); + } else { + if (showLastSeen && conversation.getContact().getLastseen() > 0) { + absubtitle.setText(UIHelper.lastseen(getApplicationContext(), conversation.getContact().isActive(), conversation.getContact().getLastseen())); + } else { + absubtitle.setText(getString(R.string.account_status_online)); + } + absubtitle.setSelected(true); + absubtitle.setOnClickListener(this); + } + } + } else { + if (conversation.getParticipants() != null) { + ChatState state = ChatState.COMPOSING; + List<MucOptions.User> userWithChatStates = conversation.getMucOptions().getUsersWithChatState(state, 5); + if (userWithChatStates.size() == 0) { + state = ChatState.PAUSED; + userWithChatStates = conversation.getMucOptions().getUsersWithChatState(state, 5); + } + List<MucOptions.User> users = conversation.getMucOptions().getUsers(true); + if (state == ChatState.COMPOSING) { + if (userWithChatStates.size() > 0) { + if (userWithChatStates.size() == 1) { + MucOptions.User user = userWithChatStates.get(0); + absubtitle.setText(getString(R.string.contact_is_typing, UIHelper.getDisplayName(user))); + } else { + StringBuilder builder = new StringBuilder(); + for (MucOptions.User user : userWithChatStates) { + if (builder.length() != 0) { + builder.append(", "); + } + builder.append(UIHelper.getDisplayName(user)); + } + absubtitle.setText(getString(R.string.contacts_are_typing, builder.toString())); + } + } + } else { + if (users.size() == 1) { + absubtitle.setText(getString(R.string.one_participant)); + } else { + absubtitle.setText(getString(R.string.more_participants, users.size())); + } + } + absubtitle.setSelected(true); + absubtitle.setOnClickListener(this); + } else { + absubtitle.setText(R.string.no_participants); + abtitle.setSelected(true); + absubtitle.setOnClickListener(this); + } + } + + } else { + if ((ab.getDisplayOptions() & ActionBar.DISPLAY_HOME_AS_UP) == ActionBar.DISPLAY_HOME_AS_UP) { + ab.setDisplayOptions(ActionBar.DISPLAY_SHOW_TITLE); + } + ab.setDisplayShowTitleEnabled(true); + ab.setDisplayShowCustomEnabled(false); + ab.setTitle(R.string.app_name); + ab.setSubtitle(null); + } + } + } + + private void openConversation() { + this.updateActionBarTitle(); + this.invalidateOptionsMenu(); + if (xmppConnectionServiceBound) { + final Conversation conversation = getSelectedConversation(); + xmppConnectionService.getNotificationService().setOpenConversation(conversation); + sendReadMarkerIfNecessary(conversation); + } + listAdapter.notifyDataSetChanged(); + } + + public void sendReadMarkerIfNecessary(final Conversation conversation) { + if (!mActivityPaused && !mUnprocessedNewIntent && conversation != null) { + xmppConnectionService.sendReadMarker(conversation); + } + } + + @Override + public boolean onCreateOptionsMenu(Menu menu) { + return super.onCreateOptionsMenu(menu); + } + + @Override + public boolean onOptionsItemSelected(final MenuItem item) { + if (item.getItemId() == android.R.id.home) { + showConversationsOverview(); + return true; + } else if (item.getItemId() == R.id.action_add) { + startActivity(new Intent(this, StartConversationActivity.class)); + return true; + } else { + return super.onOptionsItemSelected(item); + } + } + + public void endConversation(Conversation conversation) { + endConversation(conversation, true, true); + } + + public void endConversation(Conversation conversation, boolean showOverview, boolean reinit) { + if (showOverview) { + showConversationsOverview(); + } + xmppConnectionService.archiveConversation(conversation); + if (reinit) { + if (conversationList.size() > 0) { + setSelectedConversation(conversationList.get(0)); + this.mConversationFragment.reInit(getSelectedConversation()); + } else { + setSelectedConversation(null); + if (mRedirected.compareAndSet(false, true)) { + Intent intent = new Intent(this, StartConversationActivity.class); + intent.putExtra("init", true); + startActivity(intent); + finish(); + } + } + } + } + + @Override + public void onBackPressed() { + if (!isConversationsOverviewVisable() && mConversationFragment.isSearchFieldVisible()) { + mConversationFragment.hideSearchField(); + } else if (!isConversationsOverviewVisable()) { + showConversationsOverview(); + } else { + super.onBackPressed(); + } + } + + @Override + public boolean onKeyUp(int key, KeyEvent event) { + int rotation = getWindowManager().getDefaultDisplay().getRotation(); + final int upKey; + final int downKey; + switch (rotation) { + case Surface.ROTATION_90: + upKey = KeyEvent.KEYCODE_DPAD_LEFT; + downKey = KeyEvent.KEYCODE_DPAD_RIGHT; + break; + case Surface.ROTATION_180: + upKey = KeyEvent.KEYCODE_DPAD_DOWN; + downKey = KeyEvent.KEYCODE_DPAD_UP; + break; + case Surface.ROTATION_270: + upKey = KeyEvent.KEYCODE_DPAD_RIGHT; + downKey = KeyEvent.KEYCODE_DPAD_LEFT; + break; + case Surface.ROTATION_0: + default: + upKey = KeyEvent.KEYCODE_DPAD_UP; + downKey = KeyEvent.KEYCODE_DPAD_DOWN; + } + final boolean modifier = event.isCtrlPressed() || (event.getMetaState() & KeyEvent.META_ALT_LEFT_ON) != 0; + if (modifier && key == KeyEvent.KEYCODE_TAB && isConversationsOverviewHideable()) { + toggleConversationsOverview(); + return true; + } else if (modifier && key == KeyEvent.KEYCODE_SPACE) { + startActivity(new Intent(this, StartConversationActivity.class)); + return true; + } else if (modifier && key == downKey) { + if (isConversationsOverviewHideable() && !isConversationsOverviewVisable()) { + showConversationsOverview(); + } + return selectDownConversation(); + } else if (modifier && key == upKey) { + if (isConversationsOverviewHideable() && !isConversationsOverviewVisable()) { + showConversationsOverview(); + } + return selectUpConversation(); + } else if (modifier && key == KeyEvent.KEYCODE_1) { + return openConversationByIndex(0); + } else if (modifier && key == KeyEvent.KEYCODE_2) { + return openConversationByIndex(1); + } else if (modifier && key == KeyEvent.KEYCODE_3) { + return openConversationByIndex(2); + } else if (modifier && key == KeyEvent.KEYCODE_4) { + return openConversationByIndex(3); + } else if (modifier && key == KeyEvent.KEYCODE_5) { + return openConversationByIndex(4); + } else if (modifier && key == KeyEvent.KEYCODE_6) { + return openConversationByIndex(5); + } else if (modifier && key == KeyEvent.KEYCODE_7) { + return openConversationByIndex(6); + } else if (modifier && key == KeyEvent.KEYCODE_8) { + return openConversationByIndex(7); + } else if (modifier && key == KeyEvent.KEYCODE_9) { + return openConversationByIndex(8); + } else if (modifier && key == KeyEvent.KEYCODE_0) { + return openConversationByIndex(9); + } else { + return super.onKeyUp(key, event); + } + } + + private void toggleConversationsOverview() { + if (isConversationsOverviewVisable()) { + hideConversationsOverview(); + if (mConversationFragment != null) { + mConversationFragment.setFocusOnInputField(); + } + } else { + showConversationsOverview(); + } + } + + private boolean selectUpConversation() { + if (this.mSelectedConversation != null) { + int index = this.conversationList.indexOf(this.mSelectedConversation); + if (index > 0) { + return openConversationByIndex(index - 1); + } + } + return false; + } + + private boolean selectDownConversation() { + if (this.mSelectedConversation != null) { + int index = this.conversationList.indexOf(this.mSelectedConversation); + if (index != -1 && index < this.conversationList.size() - 1) { + return openConversationByIndex(index + 1); + } + } + return false; + } + + private boolean openConversationByIndex(int index) { + try { + this.conversationWasSelectedByKeyboard = true; + this.mConversationFragment.stopScrolling(); + setSelectedConversation(this.conversationList.get(index)); + this.mConversationFragment.reInit(getSelectedConversation()); + if (index > listView.getLastVisiblePosition() - 1 || index < listView.getFirstVisiblePosition() + 1) { + this.listView.setSelection(index); + } + openConversation(); + return true; + } catch (IndexOutOfBoundsException e) { + return false; + } + } + + @Override + protected void onNewIntent(final Intent intent) { + if (intent != null && ACTION_VIEW_CONVERSATION.equals(intent.getAction())) { + mOpenConversation = null; + mUnprocessedNewIntent = true; + if (xmppConnectionServiceBound) { + handleViewConversationIntent(intent); + intent.setAction(Intent.ACTION_MAIN); + } else { + setIntent(intent); + } + } else if (intent != null && ACTION_DESTROY_MUC.equals(intent.getAction())) { + final Bundle extras = intent.getExtras(); + if (extras != null && extras.containsKey("MUC_UUID")) { + Log.d(Config.LOGTAG, "Get " + intent.getAction() + " intent for " + extras.getString("MUC_UUID")); + Conversation conversation = xmppConnectionService.findConversationByUuid(extras.getString("MUC_UUID")); + ConversationLegacyActivity.this.xmppConnectionService.clearConversationHistory(conversation); + xmppConnectionService.destroyMuc(conversation); + endConversation(conversation); + } + } + } + + @Override + public void onStart() { + super.onStart(); + this.mRedirected.set(false); + if (this.xmppConnectionServiceBound) { + this.onBackendConnected(); + } + if (conversationList.size() >= 1) { + this.onConversationUpdate(); + } + final SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this); + this.showLastSeen = preferences.getBoolean("last_activity", false); + } + + @Override + public void onPause() { + super.onPause(); + this.mActivityPaused = true; + } + + @Override + public void onResume() { + super.onResume(); + final int theme = findTheme(); + final boolean usingEnterKey = usingEnterKey(); + if (this.mTheme != theme || usingEnterKey != mUsingEnterKey) { + recreate(); + } + this.mActivityPaused = false; + if (!isConversationsOverviewVisable() || !isConversationsOverviewHideable()) { + sendReadMarkerIfNecessary(getSelectedConversation()); + } + } + + @Override + public void onSaveInstanceState(final Bundle savedInstanceState) { + Conversation conversation = getSelectedConversation(); + if (conversation != null) { + savedInstanceState.putString(STATE_OPEN_CONVERSATION, conversation.getUuid()); + Pair<Integer, Integer> scrollPosition = mConversationFragment.getScrollPosition(); + if (scrollPosition != null) { + savedInstanceState.putInt(STATE_FIRST_VISIBLE, scrollPosition.first); + savedInstanceState.putInt(STATE_OFFSET_FROM_TOP, scrollPosition.second); + } + } else { + savedInstanceState.remove(STATE_OPEN_CONVERSATION); + } + savedInstanceState.putBoolean(STATE_PANEL_OPEN, isConversationsOverviewVisable()); + /*if (this.mPendingImageUris.size() >= 1) { + Log.d(Config.LOGTAG, "ConversationActivity.onSaveInstanceState() - saving pending image uri"); + savedInstanceState.putString(STATE_PENDING_IMAGE_URI, this.mPendingImageUris.get(0).toString()); + } else if (this.mPendingPhotoUris.size() >= 1) { + savedInstanceState.putString(STATE_PENDING_PHOTO_URI, this.mPendingPhotoUris.get(0).toString()); + } else { + savedInstanceState.remove(STATE_PENDING_IMAGE_URI); + savedInstanceState.remove(STATE_PENDING_PHOTO_URI); + }*/ + super.onSaveInstanceState(savedInstanceState); + } + + private void clearPending() { + mConversationFragment.clearPending(); + } + + private void redirectToStartConversationActivity(boolean noAnimation) { + Account pendingAccount = xmppConnectionService.getPendingAccount(); + if (pendingAccount == null) { + Intent startConversationActivity = new Intent(this, StartConversationActivity.class); + startConversationActivity.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK); + if (noAnimation) { + startConversationActivity.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION); + } + startConversationActivity.putExtra("init", true); + startActivity(startConversationActivity); + if (noAnimation) { + overridePendingTransition(0, 0); + } + } else { + switchToAccount(pendingAccount, true); + } + } + + @Override + void onBackendConnected() { + this.xmppConnectionService.getNotificationService().setIsInForeground(true); + updateConversationList(); + final Intent intent = getIntent(); + final Bundle extras = intent.getExtras(); + + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { + if (extras != null && extras.containsKey(PREF_FIRST_START)) { + FirstStartTime = extras.getLong(PREF_FIRST_START); + Log.d(Config.LOGTAG, "Get first start time from StartUI: " + FirstStartTime); + } + } else { + FirstStartTime = System.currentTimeMillis(); + Log.d(Config.LOGTAG, "Device is running Android < SDK 23, no restart required: " + FirstStartTime); + } + + if (mPendingConferenceInvite != null) { + if (mPendingConferenceInvite.execute(this)) { + mToast = Toast.makeText(this, R.string.creating_conference, Toast.LENGTH_LONG); + mToast.show(); + } + mPendingConferenceInvite = null; + } + + if (FirstStartTime == 0) { + Log.d(Config.LOGTAG, "First start time: " + FirstStartTime + ", restarting App"); + //write first start timestamp to file + FirstStartTime = System.currentTimeMillis(); + SharedPreferences FirstStart = getApplicationContext().getSharedPreferences(PREF_FIRST_START, Context.MODE_PRIVATE); + SharedPreferences.Editor editor = FirstStart.edit(); + editor.putLong(PREF_FIRST_START, FirstStartTime); + editor.commit(); + // restart + Intent restartintent = getBaseContext().getPackageManager().getLaunchIntentForPackage(getBaseContext().getPackageName()); + restartintent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); + restartintent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + startActivity(restartintent); + System.exit(0); + } + + if (xmppConnectionService.getAccounts().size() == 0) { + if (mRedirected.compareAndSet(false, true)) { + if (Config.X509_VERIFICATION) { + Intent redirectionIntent = new Intent(this, ManageAccountActivity.class); + redirectionIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NO_ANIMATION); + startActivity(redirectionIntent); + overridePendingTransition(0, 0); + } else if (Config.MAGIC_CREATE_DOMAIN != null) { + WelcomeActivity.launch(this); + } else { + Intent editAccount = new Intent(this, EditAccountActivity.class); + editAccount.putExtra("init", true); + editAccount.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NO_ANIMATION); + startActivity(editAccount); + overridePendingTransition(0, 0); + } + } + } else if (conversationList.size() <= 0) { + if (mRedirected.compareAndSet(false, true)) { + redirectToStartConversationActivity(true); + } + } else if (selectConversationByUuid(mOpenConversation)) { + if (mPanelOpen) { + showConversationsOverview(); + } else { + if (isConversationsOverviewHideable()) { + openConversation(); + updateActionBarTitle(true); + } + } + if (this.mConversationFragment.reInit(getSelectedConversation())) { + Log.d(Config.LOGTAG, "setting scroll position on fragment"); + this.mConversationFragment.setScrollPosition(mScrollPosition); + } + mOpenConversation = null; + } else if (intent != null && ACTION_VIEW_CONVERSATION.equals(intent.getAction())) { + clearPending(); + handleViewConversationIntent(intent); + intent.setAction(Intent.ACTION_MAIN); + } else if (getSelectedConversation() == null) { + reInitLatestConversation(); + } else { + this.mConversationFragment.messageListAdapter.updatePreferences(); + //this.mConversationFragment.messagesView.invalidateViews(); + this.mConversationFragment.setupIme(); + } + + if (xmppConnectionService.getAccounts().size() != 0) { + if (xmppConnectionService.hasInternetConnection()) { + if (xmppConnectionService.isWIFI() || (xmppConnectionService.isMobile() && !xmppConnectionService.isMobileRoaming())) { + if (!xmppConnectionService.installedFromFDroid()) { + AppUpdate(xmppConnectionService.installedFromPlayStore()); + } + } + } + } + + mConversationFragment.onBackendConnected(); + + /*if (!ExceptionHelper.checkForCrash(this, this.xmppConnectionService) && !mRedirected.get()) { + openBatteryOptimizationDialogIfNeeded(); + }*/ + + if (isConversationsOverviewVisable() && isConversationsOverviewHideable()) { + xmppConnectionService.getNotificationService().setOpenConversation(null); + } else { + xmppConnectionService.getNotificationService().setOpenConversation(getSelectedConversation()); + } + } + + private boolean isStopping() { + if (Build.VERSION.SDK_INT >= 17) { + return isFinishing() || isDestroyed(); + } else { + return isFinishing(); + } + } + + private void reInitLatestConversation() { + showConversationsOverview(); + clearPending(); + setSelectedConversation(conversationList.get(0)); + this.mConversationFragment.reInit(getSelectedConversation()); + } + + private void handleViewConversationIntent(final Intent intent) { + final String uuid = intent.getStringExtra(CONVERSATION); + final String downloadUuid = intent.getStringExtra(EXTRA_DOWNLOAD_UUID); + final String text = intent.getStringExtra(TEXT); + final String nick = intent.getStringExtra(NICK); + final boolean pm = intent.getBooleanExtra(PRIVATE_MESSAGE, false); + this.mConversationFragment.stopScrolling(); + if (selectConversationByUuid(uuid)) { + this.mConversationFragment.reInit(getSelectedConversation()); + if (nick != null) { + if (pm) { + Jid jid = getSelectedConversation().getJid(); + try { + Jid next = Jid.fromParts(jid.getLocalpart(), jid.getDomainpart(), nick); + this.mConversationFragment.privateMessageWith(next); + } catch (final InvalidJidException ignored) { + //do nothing + } + } else { + this.mConversationFragment.highlightInConference(nick); + } + } else { + this.mConversationFragment.appendText(text); + } + hideConversationsOverview(); + mUnprocessedNewIntent = false; + openConversation(); + if (mContentView instanceof SlidingPaneLayout) { + updateActionBarTitle(true); //fixes bug where slp isn't properly closed yet + } + if (downloadUuid != null) { + final Message message = mSelectedConversation.findMessageWithFileAndUuid(downloadUuid); + if (message != null) { + //startDownloadable(message); + } + } + } else { + mUnprocessedNewIntent = false; + + } + } + + private boolean selectConversationByUuid(String uuid) { + if (uuid == null) { + return false; + } + for (Conversation aConversationList : conversationList) { + if (aConversationList.getUuid().equals(uuid)) { + setSelectedConversation(aConversationList); + return true; + } + } + return false; + } + + @Override + protected void unregisterListeners() { + super.unregisterListeners(); + xmppConnectionService.getNotificationService().setOpenConversation(null); + } + + @Override + protected void onActivityResult(final int requestCode, int resultCode, final Intent data) { + super.onActivityResult(requestCode, resultCode, data); + if (resultCode != RESULT_OK) { + if (requestCode == REQUEST_BATTERY_OP) { + setNeverAskForBatteryOptimizationsAgain(); + } + } + } + + private String getBatteryOptimizationPreferenceKey() { + @SuppressLint("HardwareIds") String device = Settings.Secure.getString(getContentResolver(), Settings.Secure.ANDROID_ID); + return "show_battery_optimization" + (device == null ? "" : device); + } + + private void setNeverAskForBatteryOptimizationsAgain() { + getPreferences().edit().putBoolean(getBatteryOptimizationPreferenceKey(), false).apply(); + } + + private void openBatteryOptimizationDialogIfNeeded() { + if (hasAccountWithoutPush() + && isOptimizingBattery() + && getPreferences().getBoolean(getBatteryOptimizationPreferenceKey(), true)) { + AlertDialog.Builder builder = new AlertDialog.Builder(this); + builder.setTitle(R.string.battery_optimizations_enabled); + builder.setMessage(R.string.battery_optimizations_enabled_dialog); + builder.setPositiveButton(R.string.next, (dialog, which) -> { + Intent intent = new Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS); + Uri uri = Uri.parse("package:" + getPackageName()); + intent.setData(uri); + try { + startActivityForResult(intent, REQUEST_BATTERY_OP); + } catch (ActivityNotFoundException e) { + Toast.makeText(this, R.string.device_does_not_support_battery_op, Toast.LENGTH_SHORT).show(); + } + }); + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) { + builder.setOnDismissListener(dialog -> setNeverAskForBatteryOptimizationsAgain()); + } + builder.create().show(); + } + } + + private boolean hasAccountWithoutPush() { + for (Account account : xmppConnectionService.getAccounts()) { + if (account.getStatus() == Account.State.ONLINE && !xmppConnectionService.getPushManagementService().available(account)) { + return true; + } + } + return false; + } + + public void updateConversationList() { + xmppConnectionService.populateWithOrderedConversations(conversationList); + if (!conversationList.contains(mSelectedConversation)) { + mSelectedConversation = null; + } + if (swipedConversation != null) { + if (swipedConversation.isRead()) { + conversationList.remove(swipedConversation); + } + } + listAdapter.notifyDataSetChanged(); + } + + @Override + protected void refreshUiReal() { + updateConversationList(); + if (conversationList.size() > 0) { + if (!this.mConversationFragment.isAdded()) { + Log.d(Config.LOGTAG, "fragment NOT added to activity. detached=" + Boolean.toString(mConversationFragment.isDetached())); + } + if (getSelectedConversation() == null) { + reInitLatestConversation(); + } else { + ConversationLegacyActivity.this.mConversationFragment.refresh(); + updateActionBarTitle(); + invalidateOptionsMenu(); + } + } else { + if (!isStopping() && mRedirected.compareAndSet(false, true)) { + redirectToStartConversationActivity(false); + } + Log.d(Config.LOGTAG, "not updating conversations fragment because conversations list size was 0"); + } + } + + @Override + public void onAccountUpdate() { + this.refreshUi(); + } + + @Override + public void onConversationUpdate() { + this.refreshUi(); + } + + @Override + public void onRosterUpdate() { + this.refreshUi(); + } + + @Override + public void OnUpdateBlocklist(Status status) { + this.refreshUi(); + } + + @Override + public void onShowErrorToast(final int resId) { + runOnUiThread(() -> Toast.makeText(ConversationLegacyActivity.this, resId, Toast.LENGTH_SHORT).show()); + } + + public boolean highlightSelectedConversations() { + return !isConversationsOverviewHideable() || this.conversationWasSelectedByKeyboard; + } + + @Override + public void onClick(View view) { + final Conversation conversation = getSelectedConversation(); + if (conversation.getMode() == Conversation.MODE_SINGLE) { + switchToContactDetails(getSelectedConversation().getContact()); + } else if (conversation.getMode() == Conversation.MODE_MULTI) { + Intent intent = new Intent(this, + ConferenceDetailsActivity.class); + intent.setAction(ConferenceDetailsActivity.ACTION_VIEW_MUC); + intent.putExtra("uuid", getSelectedConversation().getUuid()); + startActivity(intent); + } + } + + +} |