1package eu.siacs.conversations.ui;
   2
   3import android.Manifest;
   4import android.annotation.SuppressLint;
   5import android.app.Dialog;
   6import android.app.PendingIntent;
   7import android.content.ActivityNotFoundException;
   8import android.content.Context;
   9import android.content.Intent;
  10import android.content.SharedPreferences;
  11import android.content.pm.PackageManager;
  12import android.net.Uri;
  13import android.os.Build;
  14import android.os.Bundle;
  15import android.preference.PreferenceManager;
  16import android.text.Editable;
  17import android.text.Html;
  18import android.text.TextWatcher;
  19import android.text.method.LinkMovementMethod;
  20import android.util.Log;
  21import android.util.Pair;
  22import android.view.ContextMenu;
  23import android.view.ContextMenu.ContextMenuInfo;
  24import android.view.KeyEvent;
  25import android.view.Menu;
  26import android.view.MenuItem;
  27import android.view.View;
  28import android.view.ViewGroup;
  29import android.view.inputmethod.InputMethodManager;
  30import android.widget.AdapterView;
  31import android.widget.AdapterView.AdapterContextMenuInfo;
  32import android.widget.ArrayAdapter;
  33import android.widget.AutoCompleteTextView;
  34import android.widget.CheckBox;
  35import android.widget.EditText;
  36import android.widget.ListView;
  37import android.widget.Spinner;
  38import android.widget.TextView;
  39import android.widget.Toast;
  40
  41import androidx.annotation.MenuRes;
  42import androidx.annotation.NonNull;
  43import androidx.annotation.Nullable;
  44import androidx.annotation.StringRes;
  45import androidx.appcompat.app.ActionBar;
  46import androidx.appcompat.app.AlertDialog;
  47import androidx.appcompat.widget.PopupMenu;
  48import androidx.core.content.ContextCompat;
  49import androidx.databinding.DataBindingUtil;
  50import androidx.fragment.app.Fragment;
  51import androidx.fragment.app.FragmentManager;
  52import androidx.fragment.app.FragmentTransaction;
  53import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
  54import androidx.viewpager.widget.PagerAdapter;
  55import androidx.viewpager.widget.ViewPager;
  56
  57import com.google.android.material.color.MaterialColors;
  58import com.google.android.material.dialog.MaterialAlertDialogBuilder;
  59import com.google.android.material.textfield.TextInputLayout;
  60import com.google.common.collect.Iterables;
  61import com.leinardi.android.speeddial.SpeedDialActionItem;
  62import com.leinardi.android.speeddial.SpeedDialView;
  63
  64import java.util.ArrayList;
  65import java.util.Collections;
  66import java.util.List;
  67import java.util.concurrent.atomic.AtomicBoolean;
  68
  69import eu.siacs.conversations.BuildConfig;
  70import eu.siacs.conversations.Config;
  71import eu.siacs.conversations.R;
  72import eu.siacs.conversations.databinding.ActivityStartConversationBinding;
  73import eu.siacs.conversations.entities.Account;
  74import eu.siacs.conversations.entities.Bookmark;
  75import eu.siacs.conversations.entities.Contact;
  76import eu.siacs.conversations.entities.Conversation;
  77import eu.siacs.conversations.entities.ListItem;
  78import eu.siacs.conversations.entities.MucOptions;
  79import eu.siacs.conversations.entities.Presence;
  80import eu.siacs.conversations.services.QuickConversationsService;
  81import eu.siacs.conversations.services.XmppConnectionService;
  82import eu.siacs.conversations.services.XmppConnectionService.OnRosterUpdate;
  83import eu.siacs.conversations.ui.adapter.ListItemAdapter;
  84import eu.siacs.conversations.ui.interfaces.OnBackendConnected;
  85import eu.siacs.conversations.ui.util.JidDialog;
  86import eu.siacs.conversations.ui.util.MenuDoubleTabUtil;
  87import eu.siacs.conversations.ui.util.PendingItem;
  88import eu.siacs.conversations.ui.util.SoftKeyboardUtils;
  89import eu.siacs.conversations.ui.widget.SwipeRefreshListFragment;
  90import eu.siacs.conversations.utils.AccountUtils;
  91import eu.siacs.conversations.utils.XmppUri;
  92import eu.siacs.conversations.xmpp.Jid;
  93import eu.siacs.conversations.xmpp.OnUpdateBlocklist;
  94import eu.siacs.conversations.xmpp.XmppConnection;
  95
  96public class StartConversationActivity extends XmppActivity implements XmppConnectionService.OnConversationUpdate, OnRosterUpdate, OnUpdateBlocklist, CreatePrivateGroupChatDialog.CreateConferenceDialogListener, JoinConferenceDialog.JoinConferenceDialogListener, SwipeRefreshLayout.OnRefreshListener, CreatePublicChannelDialog.CreatePublicChannelDialogListener {
  97
  98    private static final String PREF_KEY_CONTACT_INTEGRATION_CONSENT = "contact_list_integration_consent";
  99
 100    public static final String EXTRA_INVITE_URI = "eu.siacs.conversations.invite_uri";
 101
 102    private final int REQUEST_SYNC_CONTACTS = 0x28cf;
 103    private final int REQUEST_CREATE_CONFERENCE = 0x39da;
 104    private final PendingItem<Intent> pendingViewIntent = new PendingItem<>();
 105    private final PendingItem<String> mInitialSearchValue = new PendingItem<>();
 106    private final AtomicBoolean oneShotKeyboardSuppress = new AtomicBoolean();
 107    public int conference_context_id;
 108    public int contact_context_id;
 109    private ListPagerAdapter mListPagerAdapter;
 110    private final List<ListItem> contacts = new ArrayList<>();
 111    private ListItemAdapter mContactsAdapter;
 112    private final List<ListItem> conferences = new ArrayList<>();
 113    private ListItemAdapter mConferenceAdapter;
 114    private final ArrayList<String> mActivatedAccounts = new ArrayList<>();
 115    private EditText mSearchEditText;
 116    private final AtomicBoolean mRequestedContactsPermission = new AtomicBoolean(false);
 117    private final AtomicBoolean mOpenedFab = new AtomicBoolean(false);
 118    private boolean mHideOfflineContacts = false;
 119    private boolean createdByViewIntent = false;
 120    private final MenuItem.OnActionExpandListener mOnActionExpandListener = new MenuItem.OnActionExpandListener() {
 121
 122        @Override
 123        public boolean onMenuItemActionExpand(MenuItem item) {
 124            mSearchEditText.post(() -> {
 125                updateSearchViewHint();
 126                mSearchEditText.requestFocus();
 127                if (oneShotKeyboardSuppress.compareAndSet(true, false)) {
 128                    return;
 129                }
 130                InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
 131                if (imm != null) {
 132                    imm.showSoftInput(mSearchEditText, InputMethodManager.SHOW_IMPLICIT);
 133                }
 134            });
 135            if (binding.speedDial.isOpen()) {
 136                binding.speedDial.close();
 137            }
 138            return true;
 139        }
 140
 141        @Override
 142        public boolean onMenuItemActionCollapse(MenuItem item) {
 143            SoftKeyboardUtils.hideSoftKeyboard(StartConversationActivity.this);
 144            mSearchEditText.setText("");
 145            filter(null);
 146            return true;
 147        }
 148    };
 149    private final TextWatcher mSearchTextWatcher = new TextWatcher() {
 150
 151        @Override
 152        public void afterTextChanged(Editable editable) {
 153            filter(editable.toString());
 154        }
 155
 156        @Override
 157        public void beforeTextChanged(CharSequence s, int start, int count, int after) {
 158        }
 159
 160        @Override
 161        public void onTextChanged(CharSequence s, int start, int before, int count) {
 162        }
 163    };
 164    private MenuItem mMenuSearchView;
 165    private final ListItemAdapter.OnTagClickedListener mOnTagClickedListener = new ListItemAdapter.OnTagClickedListener() {
 166        @Override
 167        public void onTagClicked(String tag) {
 168            if (mMenuSearchView != null) {
 169                mMenuSearchView.expandActionView();
 170                mSearchEditText.setText("");
 171                mSearchEditText.append(tag);
 172                filter(tag);
 173            }
 174        }
 175    };
 176    private Pair<Integer, Intent> mPostponedActivityResult;
 177    private Toast mToast;
 178    private final UiCallback<Conversation> mAdhocConferenceCallback = new UiCallback<Conversation>() {
 179        @Override
 180        public void success(final Conversation conversation) {
 181            runOnUiThread(() -> {
 182                hideToast();
 183                switchToConversation(conversation);
 184            });
 185        }
 186
 187        @Override
 188        public void error(final int errorCode, Conversation object) {
 189            runOnUiThread(() -> replaceToast(getString(errorCode)));
 190        }
 191
 192        @Override
 193        public void userInputRequired(PendingIntent pi, Conversation object) {
 194
 195        }
 196    };
 197    private ActivityStartConversationBinding binding;
 198    private final TextView.OnEditorActionListener mSearchDone = new TextView.OnEditorActionListener() {
 199        @Override
 200        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
 201            int pos = binding.startConversationViewPager.getCurrentItem();
 202            if (pos == 0) {
 203                if (contacts.size() == 1) {
 204                    openConversationForContact((Contact) contacts.get(0));
 205                    return true;
 206                } else if (contacts.size() == 0 && conferences.size() == 1) {
 207                    openConversationsForBookmark((Bookmark) conferences.get(0));
 208                    return true;
 209                }
 210            } else {
 211                if (conferences.size() == 1) {
 212                    openConversationsForBookmark((Bookmark) conferences.get(0));
 213                    return true;
 214                } else if (conferences.size() == 0 && contacts.size() == 1) {
 215                    openConversationForContact((Contact) contacts.get(0));
 216                    return true;
 217                }
 218            }
 219            SoftKeyboardUtils.hideSoftKeyboard(StartConversationActivity.this);
 220            mListPagerAdapter.requestFocus(pos);
 221            return true;
 222        }
 223    };
 224
 225    public static void populateAccountSpinner(final Context context, final List<String> accounts, final AutoCompleteTextView spinner) {
 226        if (accounts.isEmpty()) {
 227            ArrayAdapter<String> adapter = new ArrayAdapter<>(context,
 228                    R.layout.item_autocomplete,
 229                    Collections.singletonList(context.getString(R.string.no_accounts)));
 230            adapter.setDropDownViewResource(R.layout.item_autocomplete);
 231            spinner.setAdapter(adapter);
 232            spinner.setEnabled(false);
 233        } else {
 234            final ArrayAdapter<String> adapter = new ArrayAdapter<>(context, R.layout.item_autocomplete, accounts);
 235            adapter.setDropDownViewResource(R.layout.item_autocomplete);
 236            spinner.setAdapter(adapter);
 237            spinner.setEnabled(true);
 238            spinner.setText(Iterables.getFirst(accounts,null),false);
 239        }
 240    }
 241
 242    public static void launch(Context context) {
 243        final Intent intent = new Intent(context, StartConversationActivity.class);
 244        context.startActivity(intent);
 245    }
 246
 247    private static Intent createLauncherIntent(Context context) {
 248        final Intent intent = new Intent(context, StartConversationActivity.class);
 249        intent.setAction(Intent.ACTION_MAIN);
 250        intent.addCategory(Intent.CATEGORY_LAUNCHER);
 251        return intent;
 252    }
 253
 254    private static boolean isViewIntent(final Intent i) {
 255        return i != null && (Intent.ACTION_VIEW.equals(i.getAction()) || Intent.ACTION_SENDTO.equals(i.getAction()) || i.hasExtra(EXTRA_INVITE_URI));
 256    }
 257
 258    protected void hideToast() {
 259        if (mToast != null) {
 260            mToast.cancel();
 261        }
 262    }
 263
 264    protected void replaceToast(String msg) {
 265        hideToast();
 266        mToast = Toast.makeText(this, msg, Toast.LENGTH_LONG);
 267        mToast.show();
 268    }
 269
 270    @Override
 271    public void onRosterUpdate() {
 272        this.refreshUi();
 273    }
 274
 275    @Override
 276    public void onCreate(Bundle savedInstanceState) {
 277        super.onCreate(savedInstanceState);
 278        this.binding = DataBindingUtil.setContentView(this, R.layout.activity_start_conversation);
 279        Activities.setStatusAndNavigationBarColors(this, binding.getRoot());
 280        setSupportActionBar(binding.toolbar);
 281        configureActionBar(getSupportActionBar());
 282
 283        inflateFab(binding.speedDial, R.menu.start_conversation_fab_submenu);
 284        binding.tabLayout.setupWithViewPager(binding.startConversationViewPager);
 285        binding.startConversationViewPager.addOnPageChangeListener(new ViewPager.SimpleOnPageChangeListener() {
 286            @Override
 287            public void onPageSelected(int position) {
 288                updateSearchViewHint();
 289            }
 290        });
 291        mListPagerAdapter = new ListPagerAdapter(getSupportFragmentManager());
 292        binding.startConversationViewPager.setAdapter(mListPagerAdapter);
 293
 294        mConferenceAdapter = new ListItemAdapter(this, conferences);
 295        mContactsAdapter = new ListItemAdapter(this, contacts);
 296        mContactsAdapter.setOnTagClickedListener(this.mOnTagClickedListener);
 297
 298        final SharedPreferences preferences = getPreferences();
 299
 300        this.mHideOfflineContacts = QuickConversationsService.isConversations() && preferences.getBoolean("hide_offline", false);
 301
 302        final boolean startSearching = preferences.getBoolean("start_searching", getResources().getBoolean(R.bool.start_searching));
 303
 304        final Intent intent;
 305        if (savedInstanceState == null) {
 306            intent = getIntent();
 307        } else {
 308            createdByViewIntent = savedInstanceState.getBoolean("created_by_view_intent", false);
 309            final String search = savedInstanceState.getString("search");
 310            if (search != null) {
 311                mInitialSearchValue.push(search);
 312            }
 313            intent = savedInstanceState.getParcelable("intent");
 314        }
 315
 316        if (isViewIntent(intent)) {
 317            pendingViewIntent.push(intent);
 318            createdByViewIntent = true;
 319            setIntent(createLauncherIntent(this));
 320        } else if (startSearching && mInitialSearchValue.peek() == null) {
 321            mInitialSearchValue.push("");
 322        }
 323        mRequestedContactsPermission.set(savedInstanceState != null && savedInstanceState.getBoolean("requested_contacts_permission", false));
 324        mOpenedFab.set(savedInstanceState != null && savedInstanceState.getBoolean("opened_fab", false));
 325        binding.speedDial.setOnActionSelectedListener(actionItem -> {
 326            final String searchString = mSearchEditText != null ? mSearchEditText.getText().toString() : null;
 327            final String prefilled;
 328            if (isValidJid(searchString)) {
 329                prefilled = Jid.ofEscaped(searchString).toEscapedString();
 330            } else {
 331                prefilled = null;
 332            }
 333            switch (actionItem.getId()) {
 334                case R.id.discover_public_channels:
 335                    if (QuickConversationsService.isPlayStoreFlavor()) {
 336                        throw new IllegalStateException("Channel discovery is not available on Google Play flavor");
 337                    } else {
 338                        startActivity(new Intent(this, ChannelDiscoveryActivity.class));
 339                    }
 340                    break;
 341                case R.id.join_public_channel:
 342                    showJoinConferenceDialog(prefilled);
 343                    break;
 344                case R.id.create_private_group_chat:
 345                    showCreatePrivateGroupChatDialog();
 346                    break;
 347                case R.id.create_public_channel:
 348                    showPublicChannelDialog();
 349                    break;
 350                case R.id.create_contact:
 351                    showCreateContactDialog(prefilled, null);
 352                    break;
 353            }
 354            return false;
 355        });
 356    }
 357
 358    private void inflateFab(final SpeedDialView speedDialView, final @MenuRes int menuRes) {
 359        speedDialView.clearActionItems();
 360        final PopupMenu popupMenu = new PopupMenu(this, new View(this));
 361        popupMenu.inflate(menuRes);
 362        final Menu menu = popupMenu.getMenu();
 363        for (int i = 0; i < menu.size(); i++) {
 364            final MenuItem menuItem = menu.getItem(i);
 365            if (QuickConversationsService.isPlayStoreFlavor() && menuItem.getItemId() == R.id.discover_public_channels) {
 366                continue;
 367            }
 368            final SpeedDialActionItem actionItem = new SpeedDialActionItem.Builder(menuItem.getItemId(), menuItem.getIcon())
 369                    .setLabel(menuItem.getTitle() != null ? menuItem.getTitle().toString() : null)
 370                    .setFabImageTintColor(MaterialColors.getColor(speedDialView, com.google.android.material.R.attr.colorOnSurface))
 371                    .setFabBackgroundColor(MaterialColors.getColor(speedDialView, com.google.android.material.R.attr.colorSurfaceContainerHighest))
 372                    .create();
 373            speedDialView.addActionItem(actionItem);
 374        }
 375    }
 376
 377    public static boolean isValidJid(String input) {
 378        try {
 379            Jid jid = Jid.ofEscaped(input);
 380            return !jid.isDomainJid();
 381        } catch (IllegalArgumentException e) {
 382            return false;
 383        }
 384    }
 385
 386    @Override
 387    public void onSaveInstanceState(Bundle savedInstanceState) {
 388        Intent pendingIntent = pendingViewIntent.peek();
 389        savedInstanceState.putParcelable("intent", pendingIntent != null ? pendingIntent : getIntent());
 390        savedInstanceState.putBoolean("requested_contacts_permission", mRequestedContactsPermission.get());
 391        savedInstanceState.putBoolean("opened_fab", mOpenedFab.get());
 392        savedInstanceState.putBoolean("created_by_view_intent", createdByViewIntent);
 393        if (mMenuSearchView != null && mMenuSearchView.isActionViewExpanded()) {
 394            savedInstanceState.putString("search", mSearchEditText != null ? mSearchEditText.getText().toString() : null);
 395        }
 396        super.onSaveInstanceState(savedInstanceState);
 397    }
 398
 399    @Override
 400    public void onStart() {
 401        super.onStart();
 402        if (pendingViewIntent.peek() == null) {
 403            askForContactsPermissions();
 404        }
 405        mConferenceAdapter.refreshSettings();
 406        mContactsAdapter.refreshSettings();
 407    }
 408
 409    @Override
 410    public void onNewIntent(final Intent intent) {
 411        super.onNewIntent(intent);
 412        if (xmppConnectionServiceBound) {
 413            processViewIntent(intent);
 414        } else {
 415            pendingViewIntent.push(intent);
 416        }
 417        setIntent(createLauncherIntent(this));
 418    }
 419
 420    protected void openConversationForContact(int position) {
 421        Contact contact = (Contact) contacts.get(position);
 422        openConversationForContact(contact);
 423    }
 424
 425    protected void openConversationForContact(Contact contact) {
 426        Conversation conversation = xmppConnectionService.findOrCreateConversation(contact.getAccount(), contact.getJid(), false, true);
 427        SoftKeyboardUtils.hideSoftKeyboard(this);
 428        switchToConversation(conversation);
 429    }
 430
 431    protected void openConversationForBookmark(int position) {
 432        Bookmark bookmark = (Bookmark) conferences.get(position);
 433        openConversationsForBookmark(bookmark);
 434    }
 435
 436    protected void shareBookmarkUri() {
 437        shareBookmarkUri(conference_context_id);
 438    }
 439
 440    protected void shareBookmarkUri(int position) {
 441        Bookmark bookmark = (Bookmark) conferences.get(position);
 442        shareAsChannel(this, bookmark.getJid().asBareJid().toEscapedString());
 443    }
 444
 445    public static void shareAsChannel(final Context context, final String address) {
 446        Intent shareIntent = new Intent();
 447        shareIntent.setAction(Intent.ACTION_SEND);
 448        shareIntent.putExtra(Intent.EXTRA_TEXT, "xmpp:" + address + "?join");
 449        shareIntent.setType("text/plain");
 450        try {
 451            context.startActivity(Intent.createChooser(shareIntent, context.getText(R.string.share_uri_with)));
 452        } catch (ActivityNotFoundException e) {
 453            Toast.makeText(context, R.string.no_application_to_share_uri, Toast.LENGTH_SHORT).show();
 454        }
 455    }
 456
 457    protected void openConversationsForBookmark(Bookmark bookmark) {
 458        final Jid jid = bookmark.getFullJid();
 459        if (jid == null) {
 460            Toast.makeText(this, R.string.invalid_jid, Toast.LENGTH_SHORT).show();
 461            return;
 462        }
 463        Conversation conversation = xmppConnectionService.findOrCreateConversation(bookmark.getAccount(), jid, true, true, true);
 464        bookmark.setConversation(conversation);
 465        if (!bookmark.autojoin()) {
 466            bookmark.setAutojoin(true);
 467            xmppConnectionService.createBookmark(bookmark.getAccount(), bookmark);
 468        }
 469        SoftKeyboardUtils.hideSoftKeyboard(this);
 470        switchToConversation(conversation);
 471    }
 472
 473    protected void openDetailsForContact() {
 474        int position = contact_context_id;
 475        Contact contact = (Contact) contacts.get(position);
 476        switchToContactDetails(contact);
 477    }
 478
 479    protected void showQrForContact() {
 480        int position = contact_context_id;
 481        Contact contact = (Contact) contacts.get(position);
 482        showQrCode("xmpp:" + contact.getJid().asBareJid().toEscapedString());
 483    }
 484
 485    protected void toggleContactBlock() {
 486        final int position = contact_context_id;
 487        BlockContactDialog.show(this, (Contact) contacts.get(position));
 488    }
 489
 490    protected void deleteContact() {
 491        final int position = contact_context_id;
 492        final Contact contact = (Contact) contacts.get(position);
 493        final MaterialAlertDialogBuilder builder = new MaterialAlertDialogBuilder(this);
 494        builder.setNegativeButton(R.string.cancel, null);
 495        builder.setTitle(R.string.action_delete_contact);
 496        builder.setMessage(JidDialog.style(this, R.string.remove_contact_text, contact.getJid().toEscapedString()));
 497        builder.setPositiveButton(R.string.delete, (dialog, which) -> {
 498            xmppConnectionService.deleteContactOnServer(contact);
 499            filter(mSearchEditText.getText().toString());
 500        });
 501        builder.create().show();
 502    }
 503
 504    protected void deleteConference() {
 505        final int position = conference_context_id;
 506        final Bookmark bookmark = (Bookmark) conferences.get(position);
 507        final var conversation = bookmark.getConversation();
 508        final boolean hasConversation = conversation != null;
 509        final MaterialAlertDialogBuilder builder = new MaterialAlertDialogBuilder(this);
 510        builder.setNegativeButton(R.string.cancel, null);
 511        builder.setTitle(R.string.delete_bookmark);
 512        if (hasConversation) {
 513            builder.setMessage(JidDialog.style(this, R.string.remove_bookmark_and_close, bookmark.getJid().toEscapedString()));
 514        } else {
 515            builder.setMessage(JidDialog.style(this, R.string.remove_bookmark, bookmark.getJid().toEscapedString()));
 516        }
 517        builder.setPositiveButton(hasConversation ? R.string.delete_and_close : R.string.delete, (dialog, which) -> {
 518            bookmark.setConversation(null);
 519            final Account account = bookmark.getAccount();
 520            xmppConnectionService.deleteBookmark(account, bookmark);
 521            if (conversation != null) {
 522                xmppConnectionService.archiveConversation(conversation);
 523            }
 524            filter(mSearchEditText.getText().toString());
 525        });
 526        builder.create().show();
 527
 528    }
 529
 530    @SuppressLint("InflateParams")
 531    protected void showCreateContactDialog(final String prefilledJid, final Invite invite) {
 532        FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
 533        Fragment prev = getSupportFragmentManager().findFragmentByTag(FRAGMENT_TAG_DIALOG);
 534        if (prev != null) {
 535            ft.remove(prev);
 536        }
 537        ft.addToBackStack(null);
 538        EnterJidDialog dialog = EnterJidDialog.newInstance(
 539                mActivatedAccounts,
 540                getString(R.string.add_contact),
 541                getString(R.string.add),
 542                prefilledJid,
 543                invite == null ? null : invite.account,
 544                invite == null || !invite.hasFingerprints(),
 545                true
 546        );
 547
 548        dialog.setOnEnterJidDialogPositiveListener((accountJid, contactJid) -> {
 549            if (!xmppConnectionServiceBound) {
 550                return false;
 551            }
 552
 553            final Account account = xmppConnectionService.findAccountByJid(accountJid);
 554            if (account == null) {
 555                return true;
 556            }
 557
 558            final Contact contact = account.getRoster().getContact(contactJid);
 559            if (invite != null && invite.getName() != null) {
 560                contact.setServerName(invite.getName());
 561            }
 562            if (contact.isSelf()) {
 563                switchToConversation(contact);
 564                return true;
 565            } else if (contact.showInRoster()) {
 566                throw new EnterJidDialog.JidError(getString(R.string.contact_already_exists));
 567            } else {
 568                final String preAuth = invite == null ? null : invite.getParameter(XmppUri.PARAMETER_PRE_AUTH);
 569                xmppConnectionService.createContact(contact, true, preAuth);
 570                if (invite != null && invite.hasFingerprints()) {
 571                    xmppConnectionService.verifyFingerprints(contact, invite.getFingerprints());
 572                }
 573                switchToConversationDoNotAppend(contact, invite == null ? null : invite.getBody());
 574                return true;
 575            }
 576        });
 577        dialog.show(ft, FRAGMENT_TAG_DIALOG);
 578    }
 579
 580    @SuppressLint("InflateParams")
 581    protected void showJoinConferenceDialog(final String prefilledJid) {
 582        FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
 583        Fragment prev = getSupportFragmentManager().findFragmentByTag(FRAGMENT_TAG_DIALOG);
 584        if (prev != null) {
 585            ft.remove(prev);
 586        }
 587        ft.addToBackStack(null);
 588        JoinConferenceDialog joinConferenceFragment = JoinConferenceDialog.newInstance(prefilledJid, mActivatedAccounts);
 589        joinConferenceFragment.show(ft, FRAGMENT_TAG_DIALOG);
 590    }
 591
 592    private void showCreatePrivateGroupChatDialog() {
 593        FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
 594        Fragment prev = getSupportFragmentManager().findFragmentByTag(FRAGMENT_TAG_DIALOG);
 595        if (prev != null) {
 596            ft.remove(prev);
 597        }
 598        ft.addToBackStack(null);
 599        CreatePrivateGroupChatDialog createConferenceFragment = CreatePrivateGroupChatDialog.newInstance(mActivatedAccounts);
 600        createConferenceFragment.show(ft, FRAGMENT_TAG_DIALOG);
 601    }
 602
 603    private void showPublicChannelDialog() {
 604        FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
 605        Fragment prev = getSupportFragmentManager().findFragmentByTag(FRAGMENT_TAG_DIALOG);
 606        if (prev != null) {
 607            ft.remove(prev);
 608        }
 609        ft.addToBackStack(null);
 610        CreatePublicChannelDialog dialog = CreatePublicChannelDialog.newInstance(mActivatedAccounts);
 611        dialog.show(ft, FRAGMENT_TAG_DIALOG);
 612    }
 613
 614    public static Account getSelectedAccount(final Context context, final AutoCompleteTextView spinner) {
 615        if (spinner == null || !spinner.isEnabled()) {
 616            return null;
 617        }
 618        if (context instanceof XmppActivity) {
 619            final Jid jid;
 620            try {
 621                jid = Jid.ofEscaped(spinner.getText().toString());
 622            } catch (final IllegalArgumentException e) {
 623                return null;
 624            }
 625            final XmppConnectionService service = ((XmppActivity) context).xmppConnectionService;
 626            if (service == null) {
 627                return null;
 628            }
 629            return service.findAccountByJid(jid);
 630        } else {
 631            return null;
 632        }
 633    }
 634
 635    protected void switchToConversation(Contact contact) {
 636        Conversation conversation = xmppConnectionService.findOrCreateConversation(contact.getAccount(), contact.getJid(), false, true);
 637        switchToConversation(conversation);
 638    }
 639
 640    protected void switchToConversationDoNotAppend(Contact contact, String body) {
 641        Conversation conversation = xmppConnectionService.findOrCreateConversation(contact.getAccount(), contact.getJid(), false, true);
 642        switchToConversationDoNotAppend(conversation, body);
 643    }
 644
 645    @Override
 646    public void invalidateOptionsMenu() {
 647        boolean isExpanded = mMenuSearchView != null && mMenuSearchView.isActionViewExpanded();
 648        String text = mSearchEditText != null ? mSearchEditText.getText().toString() : "";
 649        if (isExpanded) {
 650            mInitialSearchValue.push(text);
 651            oneShotKeyboardSuppress.set(true);
 652        }
 653        super.invalidateOptionsMenu();
 654    }
 655
 656    private void updateSearchViewHint() {
 657        if (binding == null || mSearchEditText == null) {
 658            return;
 659        }
 660        if (binding.startConversationViewPager.getCurrentItem() == 0) {
 661            mSearchEditText.setHint(R.string.search_contacts);
 662            mSearchEditText.setContentDescription(getString(R.string.search_contacts));
 663        } else {
 664            mSearchEditText.setHint(R.string.search_group_chats);
 665            mSearchEditText.setContentDescription(getString(R.string.search_group_chats));
 666        }
 667    }
 668
 669    @Override
 670    public boolean onCreateOptionsMenu(final Menu menu) {
 671        getMenuInflater().inflate(R.menu.start_conversation, menu);
 672        AccountUtils.showHideMenuItems(menu);
 673        final MenuItem menuHideOffline = menu.findItem(R.id.action_hide_offline);
 674        final MenuItem qrCodeScanMenuItem = menu.findItem(R.id.action_scan_qr_code);
 675        final MenuItem privacyPolicyMenuItem = menu.findItem(R.id.action_privacy_policy);
 676        privacyPolicyMenuItem.setVisible(
 677                BuildConfig.PRIVACY_POLICY != null
 678                        && QuickConversationsService.isPlayStoreFlavor());
 679        qrCodeScanMenuItem.setVisible(isCameraFeatureAvailable());
 680        if (QuickConversationsService.isQuicksy()) {
 681            menuHideOffline.setVisible(false);
 682        } else {
 683            menuHideOffline.setVisible(true);
 684            menuHideOffline.setChecked(this.mHideOfflineContacts);
 685        }
 686        mMenuSearchView = menu.findItem(R.id.action_search);
 687        mMenuSearchView.setOnActionExpandListener(mOnActionExpandListener);
 688        View mSearchView = mMenuSearchView.getActionView();
 689        mSearchEditText = mSearchView.findViewById(R.id.search_field);
 690        mSearchEditText.addTextChangedListener(mSearchTextWatcher);
 691        mSearchEditText.setOnEditorActionListener(mSearchDone);
 692        String initialSearchValue = mInitialSearchValue.pop();
 693        if (initialSearchValue != null) {
 694            mMenuSearchView.expandActionView();
 695            mSearchEditText.append(initialSearchValue);
 696            filter(initialSearchValue);
 697        }
 698        updateSearchViewHint();
 699        return super.onCreateOptionsMenu(menu);
 700    }
 701
 702    @Override
 703    public boolean onOptionsItemSelected(MenuItem item) {
 704        if (MenuDoubleTabUtil.shouldIgnoreTap()) {
 705            return false;
 706        }
 707        switch (item.getItemId()) {
 708            case android.R.id.home:
 709                navigateBack();
 710                return true;
 711            case R.id.action_scan_qr_code:
 712                UriHandlerActivity.scan(this);
 713                return true;
 714            case R.id.action_hide_offline:
 715                mHideOfflineContacts = !item.isChecked();
 716                getPreferences().edit().putBoolean("hide_offline", mHideOfflineContacts).apply();
 717                if (mSearchEditText != null) {
 718                    filter(mSearchEditText.getText().toString());
 719                }
 720                invalidateOptionsMenu();
 721        }
 722        return super.onOptionsItemSelected(item);
 723    }
 724
 725    @Override
 726    public boolean onKeyUp(int keyCode, KeyEvent event) {
 727        if (keyCode == KeyEvent.KEYCODE_SEARCH && !event.isLongPress()) {
 728            openSearch();
 729            return true;
 730        }
 731        int c = event.getUnicodeChar();
 732        if (c > 32) {
 733            if (mSearchEditText != null && !mSearchEditText.isFocused()) {
 734                openSearch();
 735                mSearchEditText.append(Character.toString((char) c));
 736                return true;
 737            }
 738        }
 739        return super.onKeyUp(keyCode, event);
 740    }
 741
 742    private void openSearch() {
 743        if (mMenuSearchView != null) {
 744            mMenuSearchView.expandActionView();
 745        }
 746    }
 747
 748    @Override
 749    public void onActivityResult(int requestCode, int resultCode, Intent intent) {
 750        if (resultCode == RESULT_OK) {
 751            if (xmppConnectionServiceBound) {
 752                this.mPostponedActivityResult = null;
 753                if (requestCode == REQUEST_CREATE_CONFERENCE) {
 754                    Account account = extractAccount(intent);
 755                    final String name = intent.getStringExtra(ChooseContactActivity.EXTRA_GROUP_CHAT_NAME);
 756                    final List<Jid> jids = ChooseContactActivity.extractJabberIds(intent);
 757                    if (account != null && jids.size() > 0) {
 758                        if (xmppConnectionService.createAdhocConference(account, name, jids, mAdhocConferenceCallback)) {
 759                            mToast = Toast.makeText(this, R.string.creating_conference, Toast.LENGTH_LONG);
 760                            mToast.show();
 761                        }
 762                    }
 763                }
 764            } else {
 765                this.mPostponedActivityResult = new Pair<>(requestCode, intent);
 766            }
 767        }
 768        super.onActivityResult(requestCode, requestCode, intent);
 769    }
 770
 771    private void askForContactsPermissions() {
 772        if (QuickConversationsService.isContactListIntegration(this)
 773                && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
 774            if (checkSelfPermission(Manifest.permission.READ_CONTACTS)
 775                    != PackageManager.PERMISSION_GRANTED) {
 776                if (mRequestedContactsPermission.compareAndSet(false, true)) {
 777                    final String consent =
 778                            PreferenceManager.getDefaultSharedPreferences(getApplicationContext())
 779                                    .getString(PREF_KEY_CONTACT_INTEGRATION_CONSENT, null);
 780                    final boolean requiresConsent =
 781                            (QuickConversationsService.isQuicksy()
 782                                            || QuickConversationsService.isPlayStoreFlavor())
 783                                    && !"agreed".equals(consent);
 784                    if (requiresConsent && "declined".equals(consent)) {
 785                        Log.d(Config.LOGTAG,"not asking for contacts permission because consent has been declined");
 786                        return;
 787                    }
 788                    if (requiresConsent
 789                            || shouldShowRequestPermissionRationale(
 790                                    Manifest.permission.READ_CONTACTS)) {
 791                        final MaterialAlertDialogBuilder builder = new MaterialAlertDialogBuilder(this);
 792                        final AtomicBoolean requestPermission = new AtomicBoolean(false);
 793                        if (QuickConversationsService.isQuicksy()) {
 794                            builder.setTitle(R.string.quicksy_wants_your_consent);
 795                            builder.setMessage(
 796                                    Html.fromHtml(
 797                                            getString(R.string.sync_with_contacts_quicksy_static)));
 798                        } else {
 799                            builder.setTitle(R.string.sync_with_contacts);
 800                            builder.setMessage(
 801                                    getString(
 802                                            R.string.sync_with_contacts_long,
 803                                            getString(R.string.app_name)));
 804                        }
 805                        @StringRes int confirmButtonText;
 806                        if (requiresConsent) {
 807                            confirmButtonText = R.string.agree_and_continue;
 808                        } else {
 809                            confirmButtonText = R.string.next;
 810                        }
 811                        builder.setPositiveButton(
 812                                confirmButtonText,
 813                                (dialog, which) -> {
 814                                    if (requiresConsent) {
 815                                        PreferenceManager.getDefaultSharedPreferences(
 816                                                        getApplicationContext())
 817                                                .edit()
 818                                                .putString(
 819                                                        PREF_KEY_CONTACT_INTEGRATION_CONSENT, "agreed")
 820                                                .apply();
 821                                    }
 822                                    if (requestPermission.compareAndSet(false, true)) {
 823                                        requestPermissions(
 824                                                new String[] {Manifest.permission.READ_CONTACTS},
 825                                                REQUEST_SYNC_CONTACTS);
 826                                    }
 827                                });
 828                        if (requiresConsent) {
 829                            builder.setNegativeButton(R.string.decline, (dialog, which) -> PreferenceManager.getDefaultSharedPreferences(
 830                                            getApplicationContext())
 831                                    .edit()
 832                                    .putString(
 833                                            PREF_KEY_CONTACT_INTEGRATION_CONSENT, "declined")
 834                                    .apply());
 835                        } else {
 836                            builder.setOnDismissListener(
 837                                    dialog -> {
 838                                        if (requestPermission.compareAndSet(false, true)) {
 839                                            requestPermissions(
 840                                                    new String[] {
 841                                                        Manifest.permission.READ_CONTACTS
 842                                                    },
 843                                                    REQUEST_SYNC_CONTACTS);
 844                                        }
 845                                    });
 846                        }
 847                        builder.setCancelable(requiresConsent);
 848                        final AlertDialog dialog = builder.create();
 849                        dialog.setCanceledOnTouchOutside(requiresConsent);
 850                        dialog.setOnShowListener(
 851                                dialogInterface -> {
 852                                    final TextView tv = dialog.findViewById(android.R.id.message);
 853                                    if (tv != null) {
 854                                        tv.setMovementMethod(LinkMovementMethod.getInstance());
 855                                    }
 856                                });
 857                        dialog.show();
 858                    } else {
 859                        requestPermissions(
 860                                new String[] {Manifest.permission.READ_CONTACTS},
 861                                REQUEST_SYNC_CONTACTS);
 862                    }
 863                }
 864            }
 865        }
 866    }
 867
 868    @Override
 869    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
 870        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
 871        if (grantResults.length > 0)
 872            if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
 873                ScanActivity.onRequestPermissionResult(this, requestCode, grantResults);
 874                if (requestCode == REQUEST_SYNC_CONTACTS && xmppConnectionServiceBound) {
 875                    if (QuickConversationsService.isQuicksy()) {
 876                        setRefreshing(true);
 877                    }
 878                    xmppConnectionService.loadPhoneContacts();
 879                    xmppConnectionService.startContactObserver();
 880                }
 881            }
 882    }
 883
 884    private void configureHomeButton() {
 885        final ActionBar actionBar = getSupportActionBar();
 886        if (actionBar == null) {
 887            return;
 888        }
 889        boolean openConversations = !createdByViewIntent && !xmppConnectionService.isConversationsListEmpty(null);
 890        actionBar.setDisplayHomeAsUpEnabled(openConversations);
 891        actionBar.setDisplayHomeAsUpEnabled(openConversations);
 892
 893    }
 894
 895    @Override
 896    protected void onBackendConnected() {
 897        if (QuickConversationsService.isContactListIntegration(this)
 898                && (Build.VERSION.SDK_INT < Build.VERSION_CODES.M
 899                        || checkSelfPermission(Manifest.permission.READ_CONTACTS)
 900                                == PackageManager.PERMISSION_GRANTED)) {
 901            xmppConnectionService.getQuickConversationsService().considerSyncBackground(false);
 902        }
 903        if (mPostponedActivityResult != null) {
 904            onActivityResult(mPostponedActivityResult.first, RESULT_OK, mPostponedActivityResult.second);
 905            this.mPostponedActivityResult = null;
 906        }
 907        this.mActivatedAccounts.clear();
 908        this.mActivatedAccounts.addAll(AccountUtils.getEnabledAccounts(xmppConnectionService));
 909        configureHomeButton();
 910        Intent intent = pendingViewIntent.pop();
 911        if (intent != null && processViewIntent(intent)) {
 912            filter(null);
 913        } else {
 914            if (mSearchEditText != null) {
 915                filter(mSearchEditText.getText().toString());
 916            } else {
 917                filter(null);
 918            }
 919        }
 920        Fragment fragment = getSupportFragmentManager().findFragmentByTag(FRAGMENT_TAG_DIALOG);
 921        if (fragment instanceof OnBackendConnected) {
 922            Log.d(Config.LOGTAG, "calling on backend connected on dialog");
 923            ((OnBackendConnected) fragment).onBackendConnected();
 924        }
 925        if (QuickConversationsService.isQuicksy()) {
 926            setRefreshing(xmppConnectionService.getQuickConversationsService().isSynchronizing());
 927        }
 928        if (QuickConversationsService.isConversations() && AccountUtils.hasEnabledAccounts(xmppConnectionService) && this.contacts.size() == 0 && this.conferences.size() == 0 && mOpenedFab.compareAndSet(false, true)) {
 929            binding.speedDial.open();
 930        }
 931    }
 932
 933    protected boolean processViewIntent(@NonNull Intent intent) {
 934        final String inviteUri = intent.getStringExtra(EXTRA_INVITE_URI);
 935        if (inviteUri != null) {
 936            final Invite invite = new Invite(inviteUri);
 937            invite.account = intent.getStringExtra(EXTRA_ACCOUNT);
 938            if (invite.isValidJid()) {
 939                return invite.invite();
 940            }
 941        }
 942        final String action = intent.getAction();
 943        if (action == null) {
 944            return false;
 945        }
 946        switch (action) {
 947            case Intent.ACTION_SENDTO:
 948            case Intent.ACTION_VIEW:
 949                Uri uri = intent.getData();
 950                if (uri != null) {
 951                    Invite invite = new Invite(intent.getData(), intent.getBooleanExtra("scanned", false));
 952                    invite.account = intent.getStringExtra(EXTRA_ACCOUNT);
 953                    invite.forceDialog = intent.getBooleanExtra("force_dialog", false);
 954                    return invite.invite();
 955                } else {
 956                    return false;
 957                }
 958        }
 959        return false;
 960    }
 961
 962    private boolean handleJid(Invite invite) {
 963        List<Contact> contacts = xmppConnectionService.findContacts(invite.getJid(), invite.account);
 964        if (invite.isAction(XmppUri.ACTION_JOIN)) {
 965            Conversation muc = xmppConnectionService.findFirstMuc(invite.getJid());
 966            if (muc != null && !invite.forceDialog) {
 967                switchToConversationDoNotAppend(muc, invite.getBody());
 968                return true;
 969            } else {
 970                showJoinConferenceDialog(invite.getJid().asBareJid().toEscapedString());
 971                return false;
 972            }
 973        } else if (contacts.size() == 0) {
 974            showCreateContactDialog(invite.getJid().toEscapedString(), invite);
 975            return false;
 976        } else if (contacts.size() == 1) {
 977            Contact contact = contacts.get(0);
 978            if (!invite.isSafeSource() && invite.hasFingerprints()) {
 979                displayVerificationWarningDialog(contact, invite);
 980            } else {
 981                if (invite.hasFingerprints()) {
 982                    if (xmppConnectionService.verifyFingerprints(contact, invite.getFingerprints())) {
 983                        Toast.makeText(this, R.string.verified_fingerprints, Toast.LENGTH_SHORT).show();
 984                    }
 985                }
 986                if (invite.account != null) {
 987                    xmppConnectionService.getShortcutService().report(contact);
 988                }
 989                switchToConversationDoNotAppend(contact, invite.getBody());
 990            }
 991            return true;
 992        } else {
 993            if (mMenuSearchView != null) {
 994                mMenuSearchView.expandActionView();
 995                mSearchEditText.setText("");
 996                mSearchEditText.append(invite.getJid().toEscapedString());
 997                filter(invite.getJid().toEscapedString());
 998            } else {
 999                mInitialSearchValue.push(invite.getJid().toEscapedString());
1000            }
1001            return true;
1002        }
1003    }
1004
1005    private void displayVerificationWarningDialog(final Contact contact, final Invite invite) {
1006        final MaterialAlertDialogBuilder builder = new MaterialAlertDialogBuilder(this);
1007        builder.setTitle(R.string.verify_omemo_keys);
1008        View view = getLayoutInflater().inflate(R.layout.dialog_verify_fingerprints, null);
1009        final CheckBox isTrustedSource = view.findViewById(R.id.trusted_source);
1010        TextView warning = view.findViewById(R.id.warning);
1011        warning.setText(JidDialog.style(this, R.string.verifying_omemo_keys_trusted_source, contact.getJid().asBareJid().toEscapedString(), contact.getDisplayName()));
1012        builder.setView(view);
1013        builder.setPositiveButton(R.string.confirm, (dialog, which) -> {
1014            if (isTrustedSource.isChecked() && invite.hasFingerprints()) {
1015                xmppConnectionService.verifyFingerprints(contact, invite.getFingerprints());
1016            }
1017            switchToConversationDoNotAppend(contact, invite.getBody());
1018        });
1019        builder.setNegativeButton(R.string.cancel, (dialog, which) -> StartConversationActivity.this.finish());
1020        AlertDialog dialog = builder.create();
1021        dialog.setCanceledOnTouchOutside(false);
1022        dialog.setOnCancelListener(dialog1 -> StartConversationActivity.this.finish());
1023        dialog.show();
1024    }
1025
1026    protected void filter(String needle) {
1027        if (xmppConnectionServiceBound) {
1028            this.filterContacts(needle);
1029            this.filterConferences(needle);
1030        }
1031    }
1032
1033    protected void filterContacts(String needle) {
1034        this.contacts.clear();
1035        final List<Account> accounts = xmppConnectionService.getAccounts();
1036        for (final Account account : accounts) {
1037            if (account.isEnabled()) {
1038                for (Contact contact : account.getRoster().getContacts()) {
1039                    Presence.Status s = contact.getShownStatus();
1040                    if (contact.showInContactList() && contact.match(this, needle)
1041                            && (!this.mHideOfflineContacts
1042                            || (needle != null && !needle.trim().isEmpty())
1043                            || s.compareTo(Presence.Status.OFFLINE) < 0)) {
1044                        this.contacts.add(contact);
1045                    }
1046                }
1047            }
1048        }
1049        Collections.sort(this.contacts);
1050        mContactsAdapter.notifyDataSetChanged();
1051    }
1052
1053    protected void filterConferences(String needle) {
1054        this.conferences.clear();
1055        for (final Account account : xmppConnectionService.getAccounts()) {
1056            if (account.isEnabled()) {
1057                for (final Bookmark bookmark : account.getBookmarks()) {
1058                    if (bookmark.match(this, needle)) {
1059                        this.conferences.add(bookmark);
1060                    }
1061                }
1062            }
1063        }
1064        Collections.sort(this.conferences);
1065        mConferenceAdapter.notifyDataSetChanged();
1066    }
1067
1068    @Override
1069    public void OnUpdateBlocklist(final Status status) {
1070        refreshUi();
1071    }
1072
1073    @Override
1074    protected void refreshUiReal() {
1075        if (mSearchEditText != null) {
1076            filter(mSearchEditText.getText().toString());
1077        }
1078        configureHomeButton();
1079        if (QuickConversationsService.isQuicksy()) {
1080            setRefreshing(xmppConnectionService.getQuickConversationsService().isSynchronizing());
1081        }
1082    }
1083
1084    @Override
1085    public void onBackPressed() {
1086        if (binding.speedDial.isOpen()) {
1087            binding.speedDial.close();
1088            return;
1089        }
1090        navigateBack();
1091    }
1092
1093    private void navigateBack() {
1094        if (!createdByViewIntent && xmppConnectionService != null && !xmppConnectionService.isConversationsListEmpty(null)) {
1095            Intent intent = new Intent(this, ConversationsActivity.class);
1096            intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
1097            startActivity(intent);
1098        }
1099        finish();
1100    }
1101
1102    @Override
1103    public void onCreateDialogPositiveClick(AutoCompleteTextView spinner, String name) {
1104        if (!xmppConnectionServiceBound) {
1105            return;
1106        }
1107        final Account account = getSelectedAccount(this, spinner);
1108        if (account == null) {
1109            return;
1110        }
1111        Intent intent = new Intent(getApplicationContext(), ChooseContactActivity.class);
1112        intent.putExtra(ChooseContactActivity.EXTRA_SHOW_ENTER_JID, false);
1113        intent.putExtra(ChooseContactActivity.EXTRA_SELECT_MULTIPLE, true);
1114        intent.putExtra(ChooseContactActivity.EXTRA_GROUP_CHAT_NAME, name.trim());
1115        intent.putExtra(ChooseContactActivity.EXTRA_ACCOUNT, account.getJid().asBareJid().toEscapedString());
1116        intent.putExtra(ChooseContactActivity.EXTRA_TITLE_RES_ID, R.string.choose_participants);
1117        startActivityForResult(intent, REQUEST_CREATE_CONFERENCE);
1118    }
1119
1120    @Override
1121    public void onJoinDialogPositiveClick(Dialog dialog, AutoCompleteTextView spinner, TextInputLayout layout, AutoCompleteTextView jid, boolean isBookmarkChecked) {
1122        if (!xmppConnectionServiceBound) {
1123            return;
1124        }
1125        final Account account = getSelectedAccount(this, spinner);
1126        if (account == null) {
1127            return;
1128        }
1129        final String input = jid.getText().toString().trim();
1130        Jid conferenceJid;
1131        try {
1132            conferenceJid = Jid.ofEscaped(input);
1133        } catch (final IllegalArgumentException e) {
1134            final XmppUri xmppUri = new XmppUri(input);
1135            if (xmppUri.isValidJid() && xmppUri.isAction(XmppUri.ACTION_JOIN)) {
1136                final Editable editable = jid.getEditableText();
1137                editable.clear();
1138                editable.append(xmppUri.getJid().toEscapedString());
1139                conferenceJid = xmppUri.getJid();
1140            } else {
1141                layout.setError(getString(R.string.invalid_jid));
1142                return;
1143            }
1144        }
1145
1146        if (isBookmarkChecked) {
1147            Bookmark bookmark = account.getBookmark(conferenceJid);
1148            if (bookmark != null) {
1149                dialog.dismiss();
1150                openConversationsForBookmark(bookmark);
1151            } else {
1152                bookmark = new Bookmark(account, conferenceJid.asBareJid());
1153                bookmark.setAutojoin(true);
1154                final String nick = conferenceJid.getResource();
1155                if (nick != null && !nick.isEmpty() && !nick.equals(MucOptions.defaultNick(account))) {
1156                    bookmark.setNick(nick);
1157                }
1158                xmppConnectionService.createBookmark(account, bookmark);
1159                final Conversation conversation = xmppConnectionService
1160                        .findOrCreateConversation(account, conferenceJid, true, true, true);
1161                bookmark.setConversation(conversation);
1162                dialog.dismiss();
1163                switchToConversation(conversation);
1164            }
1165        } else {
1166            final Conversation conversation = xmppConnectionService
1167                    .findOrCreateConversation(account, conferenceJid, true, true, true);
1168            dialog.dismiss();
1169            switchToConversation(conversation);
1170        }
1171    }
1172
1173    @Override
1174    public void onConversationUpdate() {
1175        refreshUi();
1176    }
1177
1178    @Override
1179    public void onRefresh() {
1180        Log.d(Config.LOGTAG, "user requested to refresh");
1181        if (QuickConversationsService.isQuicksy() && xmppConnectionService != null) {
1182            xmppConnectionService.getQuickConversationsService().considerSyncBackground(true);
1183        }
1184    }
1185
1186
1187    private void setRefreshing(boolean refreshing) {
1188        MyListFragment fragment = (MyListFragment) mListPagerAdapter.getItem(0);
1189        if (fragment != null) {
1190            fragment.setRefreshing(refreshing);
1191        }
1192    }
1193
1194    @Override
1195    public void onCreatePublicChannel(Account account, String name, Jid address) {
1196        mToast = Toast.makeText(this, R.string.creating_channel, Toast.LENGTH_LONG);
1197        mToast.show();
1198        xmppConnectionService.createPublicChannel(account, name, address, new UiCallback<Conversation>() {
1199            @Override
1200            public void success(Conversation conversation) {
1201                runOnUiThread(() -> {
1202                    hideToast();
1203                    switchToConversation(conversation);
1204                });
1205
1206            }
1207
1208            @Override
1209            public void error(int errorCode, Conversation conversation) {
1210                runOnUiThread(() -> {
1211                    replaceToast(getString(errorCode));
1212                    switchToConversation(conversation);
1213                });
1214            }
1215
1216            @Override
1217            public void userInputRequired(PendingIntent pi, Conversation object) {
1218
1219            }
1220        });
1221    }
1222
1223    public static class MyListFragment extends SwipeRefreshListFragment {
1224        private AdapterView.OnItemClickListener mOnItemClickListener;
1225        private int mResContextMenu;
1226
1227        public void setContextMenu(final int res) {
1228            this.mResContextMenu = res;
1229        }
1230
1231        @Override
1232        public void onListItemClick(final ListView l, final View v, final int position, final long id) {
1233            if (mOnItemClickListener != null) {
1234                mOnItemClickListener.onItemClick(l, v, position, id);
1235            }
1236        }
1237
1238        public void setOnListItemClickListener(AdapterView.OnItemClickListener l) {
1239            this.mOnItemClickListener = l;
1240        }
1241
1242        @Override
1243        public void onViewCreated(@NonNull final View view, final Bundle savedInstanceState) {
1244            super.onViewCreated(view, savedInstanceState);
1245            registerForContextMenu(getListView());
1246            getListView().setFastScrollEnabled(true);
1247            getListView().setDivider(null);
1248            getListView().setDividerHeight(0);
1249        }
1250
1251        @Override
1252        public void onCreateContextMenu(@NonNull final ContextMenu menu, @NonNull final View v, final ContextMenuInfo menuInfo) {
1253            super.onCreateContextMenu(menu, v, menuInfo);
1254            final StartConversationActivity activity = (StartConversationActivity) getActivity();
1255            if (activity == null) {
1256                return;
1257            }
1258            activity.getMenuInflater().inflate(mResContextMenu, menu);
1259            final AdapterView.AdapterContextMenuInfo acmi = (AdapterContextMenuInfo) menuInfo;
1260            if (mResContextMenu == R.menu.conference_context) {
1261                activity.conference_context_id = acmi.position;
1262                final Bookmark bookmark = (Bookmark) activity.conferences.get(acmi.position);
1263                final Conversation conversation = bookmark.getConversation();
1264                final MenuItem share = menu.findItem(R.id.context_share_uri);
1265                final MenuItem delete = menu.findItem(R.id.context_delete_conference);
1266                if (conversation != null) {
1267                    delete.setTitle(R.string.delete_and_close);
1268                } else {
1269                    delete.setTitle(R.string.delete_bookmark);
1270                }
1271                share.setVisible(conversation == null || !conversation.isPrivateAndNonAnonymous());
1272            } else if (mResContextMenu == R.menu.contact_context) {
1273                activity.contact_context_id = acmi.position;
1274                final Contact contact = (Contact) activity.contacts.get(acmi.position);
1275                final MenuItem blockUnblockItem = menu.findItem(R.id.context_contact_block_unblock);
1276                final MenuItem showContactDetailsItem = menu.findItem(R.id.context_contact_details);
1277                final MenuItem deleteContactMenuItem = menu.findItem(R.id.context_delete_contact);
1278                if (contact.isSelf()) {
1279                    showContactDetailsItem.setVisible(false);
1280                }
1281                deleteContactMenuItem.setVisible(contact.showInRoster() && !contact.getOption(Contact.Options.SYNCED_VIA_OTHER));
1282                final XmppConnection xmpp = contact.getAccount().getXmppConnection();
1283                if (xmpp != null && xmpp.getFeatures().blocking() && !contact.isSelf()) {
1284                    if (contact.isBlocked()) {
1285                        blockUnblockItem.setTitle(R.string.unblock_contact);
1286                    } else {
1287                        blockUnblockItem.setTitle(R.string.block_contact);
1288                    }
1289                } else {
1290                    blockUnblockItem.setVisible(false);
1291                }
1292            }
1293        }
1294
1295        @Override
1296        public boolean onContextItemSelected(final MenuItem item) {
1297            StartConversationActivity activity = (StartConversationActivity) getActivity();
1298            if (activity == null) {
1299                return true;
1300            }
1301            switch (item.getItemId()) {
1302                case R.id.context_contact_details:
1303                    activity.openDetailsForContact();
1304                    break;
1305                case R.id.context_show_qr:
1306                    activity.showQrForContact();
1307                    break;
1308                case R.id.context_contact_block_unblock:
1309                    activity.toggleContactBlock();
1310                    break;
1311                case R.id.context_delete_contact:
1312                    activity.deleteContact();
1313                    break;
1314                case R.id.context_share_uri:
1315                    activity.shareBookmarkUri();
1316                    break;
1317                case R.id.context_delete_conference:
1318                    activity.deleteConference();
1319            }
1320            return true;
1321        }
1322    }
1323
1324    public class ListPagerAdapter extends PagerAdapter {
1325        private final FragmentManager fragmentManager;
1326        private final MyListFragment[] fragments;
1327
1328        ListPagerAdapter(FragmentManager fm) {
1329            fragmentManager = fm;
1330            fragments = new MyListFragment[2];
1331        }
1332
1333        public void requestFocus(int pos) {
1334            if (fragments.length > pos) {
1335                fragments[pos].getListView().requestFocus();
1336            }
1337        }
1338
1339        @Override
1340        public void destroyItem(@NonNull ViewGroup container, int position, @NonNull Object object) {
1341            FragmentTransaction trans = fragmentManager.beginTransaction();
1342            trans.remove(fragments[position]);
1343            trans.commit();
1344            fragments[position] = null;
1345        }
1346
1347        @NonNull
1348        @Override
1349        public Fragment instantiateItem(@NonNull ViewGroup container, int position) {
1350            final Fragment fragment = getItem(position);
1351            final FragmentTransaction trans = fragmentManager.beginTransaction();
1352            trans.add(container.getId(), fragment, "fragment:" + position);
1353            try {
1354                trans.commit();
1355            } catch (IllegalStateException e) {
1356                //ignore
1357            }
1358            return fragment;
1359        }
1360
1361        @Override
1362        public int getCount() {
1363            return fragments.length;
1364        }
1365
1366        @Override
1367        public boolean isViewFromObject(@NonNull View view, @NonNull Object fragment) {
1368            return ((Fragment) fragment).getView() == view;
1369        }
1370
1371        @Nullable
1372        @Override
1373        public CharSequence getPageTitle(int position) {
1374            switch (position) {
1375                case 0:
1376                    return getResources().getString(R.string.contacts);
1377                case 1:
1378                    return getResources().getString(R.string.group_chats);
1379                default:
1380                    return super.getPageTitle(position);
1381            }
1382        }
1383
1384        Fragment getItem(int position) {
1385            if (fragments[position] == null) {
1386                final MyListFragment listFragment = new MyListFragment();
1387                if (position == 1) {
1388                    listFragment.setListAdapter(mConferenceAdapter);
1389                    listFragment.setContextMenu(R.menu.conference_context);
1390                    listFragment.setOnListItemClickListener((arg0, arg1, p, arg3) -> openConversationForBookmark(p));
1391                } else {
1392                    listFragment.setListAdapter(mContactsAdapter);
1393                    listFragment.setContextMenu(R.menu.contact_context);
1394                    listFragment.setOnListItemClickListener((arg0, arg1, p, arg3) -> openConversationForContact(p));
1395                    if (QuickConversationsService.isQuicksy()) {
1396                        listFragment.setOnRefreshListener(StartConversationActivity.this);
1397                    }
1398                }
1399                fragments[position] = listFragment;
1400            }
1401            return fragments[position];
1402        }
1403    }
1404
1405    public static void addInviteUri(Intent to, Intent from) {
1406        if (from != null && from.hasExtra(EXTRA_INVITE_URI)) {
1407            final String invite = from.getStringExtra(EXTRA_INVITE_URI);
1408            to.putExtra(EXTRA_INVITE_URI, invite);
1409        }
1410    }
1411
1412    private class Invite extends XmppUri {
1413
1414        public String account;
1415
1416        boolean forceDialog = false;
1417
1418
1419        Invite(final String uri) {
1420            super(uri);
1421        }
1422
1423        Invite(Uri uri, boolean safeSource) {
1424            super(uri, safeSource);
1425        }
1426
1427        boolean invite() {
1428            if (!isValidJid()) {
1429                Toast.makeText(StartConversationActivity.this, R.string.invalid_jid, Toast.LENGTH_SHORT).show();
1430                return false;
1431            }
1432            if (getJid() != null) {
1433                return handleJid(this);
1434            }
1435            return false;
1436        }
1437    }
1438}