conversations-classic/src/main/java/eu/siacs/conversations/ui/StartConversationActivity.java

808 lines
25 KiB
Java
Raw Normal View History

2014-06-30 18:39:15 +00:00
package eu.siacs.conversations.ui;
import android.annotation.SuppressLint;
import android.annotation.TargetApi;
import android.app.ActionBar;
import android.app.ActionBar.Tab;
import android.app.ActionBar.TabListener;
2014-07-10 11:19:42 +00:00
import android.app.AlertDialog;
import android.app.Fragment;
import android.app.FragmentTransaction;
import android.app.ListFragment;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.content.Intent;
import android.net.Uri;
2014-11-03 19:00:20 +00:00
import android.nfc.NdefMessage;
import android.nfc.NdefRecord;
2014-11-03 19:00:20 +00:00
import android.nfc.NfcAdapter;
2014-11-04 08:30:03 +00:00
import android.os.Build;
import android.os.Bundle;
2014-11-03 19:00:20 +00:00
import android.os.Parcelable;
import android.support.v13.app.FragmentPagerAdapter;
import android.support.v4.view.ViewPager;
import android.text.Editable;
import android.text.TextWatcher;
2014-11-04 12:14:29 +00:00
import android.util.Log;
2014-07-09 23:55:19 +00:00
import android.view.ContextMenu;
import android.view.ContextMenu.ContextMenuInfo;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.AdapterView;
2014-07-09 23:55:19 +00:00
import android.widget.AdapterView.AdapterContextMenuInfo;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
2014-07-10 17:42:37 +00:00
import android.widget.AutoCompleteTextView;
2014-07-15 12:32:19 +00:00
import android.widget.CheckBox;
import android.widget.EditText;
import android.widget.ListView;
2014-07-10 11:19:42 +00:00
import android.widget.Spinner;
import com.google.zxing.integration.android.IntentIntegrator;
import com.google.zxing.integration.android.IntentResult;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.ArrayList;
2014-11-04 08:30:03 +00:00
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
2014-11-04 12:14:29 +00:00
import eu.siacs.conversations.Config;
import eu.siacs.conversations.R;
import eu.siacs.conversations.entities.Account;
2014-07-14 09:47:42 +00:00
import eu.siacs.conversations.entities.Bookmark;
import eu.siacs.conversations.entities.Contact;
import eu.siacs.conversations.entities.Conversation;
import eu.siacs.conversations.entities.ListItem;
2014-07-18 13:35:31 +00:00
import eu.siacs.conversations.services.XmppConnectionService.OnRosterUpdate;
import eu.siacs.conversations.ui.adapter.KnownHostsAdapter;
import eu.siacs.conversations.ui.adapter.ListItemAdapter;
2014-07-10 11:19:42 +00:00
import eu.siacs.conversations.utils.Validator;
2014-11-06 19:45:38 +00:00
import eu.siacs.conversations.xmpp.jid.InvalidJidException;
import eu.siacs.conversations.xmpp.jid.Jid;
public class StartConversationActivity extends XmppActivity {
2014-06-30 18:39:15 +00:00
private Tab mContactsTab;
private Tab mConferencesTab;
private ViewPager mViewPager;
private MyListFragment mContactsListFragment = new MyListFragment();
2014-11-06 19:45:38 +00:00
private List<ListItem> contacts = new ArrayList<>();
private ArrayAdapter<ListItem> mContactsAdapter;
private MyListFragment mConferenceListFragment = new MyListFragment();
private List<ListItem> conferences = new ArrayList<ListItem>();
private ArrayAdapter<ListItem> mConferenceAdapter;
2014-07-10 11:19:42 +00:00
private List<String> mActivatedAccounts = new ArrayList<String>();
2014-07-10 17:42:37 +00:00
private List<String> mKnownHosts;
2014-07-11 17:48:41 +00:00
private List<String> mKnownConferenceHosts;
private Invite mPendingInvite = null;
private Menu mOptionsMenu;
private EditText mSearchEditText;
2014-07-15 15:11:43 +00:00
2014-07-14 09:47:42 +00:00
public int conference_context_id;
public int contact_context_id;
private TabListener mTabListener = new TabListener() {
@Override
public void onTabUnselected(Tab tab, FragmentTransaction ft) {
return;
}
@Override
public void onTabSelected(Tab tab, FragmentTransaction ft) {
mViewPager.setCurrentItem(tab.getPosition());
onTabChanged();
}
@Override
public void onTabReselected(Tab tab, FragmentTransaction ft) {
return;
}
};
private ViewPager.SimpleOnPageChangeListener mOnPageChangeListener = new ViewPager.SimpleOnPageChangeListener() {
@Override
public void onPageSelected(int position) {
getActionBar().setSelectedNavigationItem(position);
onTabChanged();
}
};
private MenuItem.OnActionExpandListener mOnActionExpandListener = new MenuItem.OnActionExpandListener() {
@Override
public boolean onMenuItemActionExpand(MenuItem item) {
mSearchEditText.post(new Runnable() {
@Override
public void run() {
mSearchEditText.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(mSearchEditText,
InputMethodManager.SHOW_IMPLICIT);
}
});
return true;
}
@Override
public boolean onMenuItemActionCollapse(MenuItem item) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(mSearchEditText.getWindowToken(),
InputMethodManager.HIDE_IMPLICIT_ONLY);
mSearchEditText.setText("");
2014-07-14 09:47:42 +00:00
filter(null);
return true;
}
};
private TextWatcher mSearchTextWatcher = new TextWatcher() {
@Override
public void afterTextChanged(Editable editable) {
2014-07-14 09:47:42 +00:00
filter(editable.toString());
}
@Override
public void beforeTextChanged(CharSequence s, int start, int count,
int after) {
}
@Override
public void onTextChanged(CharSequence s, int start, int before,
int count) {
}
};
2014-07-18 13:35:31 +00:00
private OnRosterUpdate onRosterUpdate = new OnRosterUpdate() {
2014-07-18 13:35:31 +00:00
@Override
public void onRosterUpdate() {
runOnUiThread(new Runnable() {
2014-07-18 13:35:31 +00:00
@Override
public void run() {
if (mSearchEditText != null) {
filter(mSearchEditText.getText().toString());
}
2014-07-18 13:35:31 +00:00
}
});
}
};
private MenuItem mMenuSearchView;
private String mInitialJid;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_start_conversation);
mViewPager = (ViewPager) findViewById(R.id.start_conversation_view_pager);
ActionBar actionBar = getActionBar();
actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS);
mContactsTab = actionBar.newTab().setText(R.string.contacts)
.setTabListener(mTabListener);
mConferencesTab = actionBar.newTab().setText(R.string.conferences)
.setTabListener(mTabListener);
actionBar.addTab(mContactsTab);
actionBar.addTab(mConferencesTab);
mViewPager.setOnPageChangeListener(mOnPageChangeListener);
mViewPager.setAdapter(new FragmentPagerAdapter(getFragmentManager()) {
@Override
public int getCount() {
return 2;
}
@Override
public Fragment getItem(int position) {
if (position == 0) {
return mContactsListFragment;
} else {
return mConferenceListFragment;
}
}
});
mConferenceAdapter = new ListItemAdapter(this, conferences);
mConferenceListFragment.setListAdapter(mConferenceAdapter);
2014-07-14 09:47:42 +00:00
mConferenceListFragment.setContextMenu(R.menu.conference_context);
2014-07-15 15:11:43 +00:00
mConferenceListFragment
.setOnListItemClickListener(new OnItemClickListener() {
2014-07-14 09:47:42 +00:00
2014-07-15 15:11:43 +00:00
@Override
public void onItemClick(AdapterView<?> arg0, View arg1,
int position, long arg3) {
2014-07-15 15:11:43 +00:00
openConversationForBookmark(position);
}
});
mContactsAdapter = new ListItemAdapter(this, contacts);
mContactsListFragment.setListAdapter(mContactsAdapter);
2014-07-14 09:47:42 +00:00
mContactsListFragment.setContextMenu(R.menu.contact_context);
mContactsListFragment
.setOnListItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> arg0, View arg1,
int position, long arg3) {
2014-07-09 23:55:19 +00:00
openConversationForContact(position);
}
});
}
2014-07-18 13:35:31 +00:00
@Override
public void onStop() {
super.onStop();
xmppConnectionService.removeOnRosterUpdateListener();
}
2014-07-09 23:55:19 +00:00
protected void openConversationForContact(int position) {
Contact contact = (Contact) contacts.get(position);
Conversation conversation = xmppConnectionService
.findOrCreateConversation(contact.getAccount(),
contact.getJid(), false);
2014-07-14 09:47:42 +00:00
switchToConversation(conversation);
}
2014-07-15 15:11:43 +00:00
2014-07-14 09:47:42 +00:00
protected void openConversationForContact() {
int position = contact_context_id;
openConversationForContact(position);
}
2014-07-15 15:11:43 +00:00
2014-07-14 09:47:42 +00:00
protected void openConversationForBookmark() {
openConversationForBookmark(conference_context_id);
}
2014-07-15 15:11:43 +00:00
2014-07-14 09:47:42 +00:00
protected void openConversationForBookmark(int position) {
Bookmark bookmark = (Bookmark) conferences.get(position);
2014-07-15 15:11:43 +00:00
Conversation conversation = xmppConnectionService
.findOrCreateConversation(bookmark.getAccount(),
bookmark.getJid(), true);
conversation.setBookmark(bookmark);
if (!conversation.getMucOptions().online()) {
xmppConnectionService.joinMuc(conversation);
}
2014-07-15 12:32:19 +00:00
if (!bookmark.autojoin()) {
bookmark.setAutojoin(true);
xmppConnectionService.pushBookmarks(bookmark.getAccount());
}
2014-07-14 09:47:42 +00:00
switchToConversation(conversation);
2014-07-09 23:55:19 +00:00
}
2014-07-14 09:47:42 +00:00
protected void openDetailsForContact() {
int position = contact_context_id;
2014-07-09 23:55:19 +00:00
Contact contact = (Contact) contacts.get(position);
switchToContactDetails(contact);
}
2014-07-14 09:47:42 +00:00
protected void deleteContact() {
int position = contact_context_id;
final Contact contact = (Contact) contacts.get(position);
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setNegativeButton(R.string.cancel, null);
builder.setTitle(R.string.action_delete_contact);
builder.setMessage(getString(R.string.remove_contact_text,
contact.getJid()));
builder.setPositiveButton(R.string.delete, new OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
xmppConnectionService.deleteContactOnServer(contact);
filter(mSearchEditText.getText().toString());
}
});
builder.create().show();
2014-07-09 23:55:19 +00:00
}
2014-07-15 15:11:43 +00:00
2014-07-15 12:32:19 +00:00
protected void deleteConference() {
int position = conference_context_id;
final Bookmark bookmark = (Bookmark) conferences.get(position);
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setNegativeButton(R.string.cancel, null);
builder.setTitle(R.string.delete_bookmark);
builder.setMessage(getString(R.string.remove_bookmark_text,
bookmark.getJid()));
builder.setPositiveButton(R.string.delete, new OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
bookmark.unregisterConversation();
Account account = bookmark.getAccount();
account.getBookmarks().remove(bookmark);
xmppConnectionService.pushBookmarks(account);
filter(mSearchEditText.getText().toString());
}
});
builder.create().show();
2014-07-15 12:32:19 +00:00
}
@SuppressLint("InflateParams")
protected void showCreateContactDialog(String prefilledJid) {
2014-07-10 11:19:42 +00:00
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle(R.string.create_contact);
View dialogView = getLayoutInflater().inflate(
R.layout.create_contact_dialog, null);
2014-07-10 11:19:42 +00:00
final Spinner spinner = (Spinner) dialogView.findViewById(R.id.account);
final AutoCompleteTextView jid = (AutoCompleteTextView) dialogView
.findViewById(R.id.jid);
jid.setAdapter(new KnownHostsAdapter(this,
2014-09-28 13:21:56 +00:00
android.R.layout.simple_list_item_1, mKnownHosts));
if (prefilledJid != null) {
jid.append(prefilledJid);
}
2014-07-10 11:19:42 +00:00
populateAccountSpinner(spinner);
builder.setView(dialogView);
builder.setNegativeButton(R.string.cancel, null);
builder.setPositiveButton(R.string.create, null);
final AlertDialog dialog = builder.create();
dialog.show();
dialog.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener(
new View.OnClickListener() {
@Override
public void onClick(View v) {
if (!xmppConnectionServiceBound) {
return;
}
if (Validator.isValidJid(jid.getText().toString())) {
2014-11-06 19:45:38 +00:00
final Jid accountJid;
try {
accountJid = Jid.fromString((String) spinner
.getSelectedItem());
} catch (final InvalidJidException e) {
return;
}
final Jid contactJid;
try {
contactJid = Jid.fromString(jid.getText().toString());
} catch (final InvalidJidException e) {
return;
}
Account account = xmppConnectionService
.findAccountByJid(accountJid);
2014-08-31 14:28:21 +00:00
if (account == null) {
2014-08-29 10:14:10 +00:00
dialog.dismiss();
return;
}
2014-11-06 19:45:38 +00:00
Contact contact = account.getRoster().getContact(contactJid);
if (contact.showInRoster()) {
jid.setError(getString(R.string.contact_already_exists));
} else {
xmppConnectionService.createContact(contact);
dialog.dismiss();
2014-10-04 16:32:05 +00:00
switchToConversation(contact);
}
} else {
jid.setError(getString(R.string.invalid_jid));
}
2014-07-10 11:19:42 +00:00
}
});
2014-07-10 11:19:42 +00:00
}
@SuppressLint("InflateParams")
2014-11-03 19:00:20 +00:00
protected void showJoinConferenceDialog(String prefilledJid) {
2014-07-11 17:48:41 +00:00
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle(R.string.join_conference);
View dialogView = getLayoutInflater().inflate(
R.layout.join_conference_dialog, null);
2014-07-11 17:48:41 +00:00
final Spinner spinner = (Spinner) dialogView.findViewById(R.id.account);
final AutoCompleteTextView jid = (AutoCompleteTextView) dialogView
.findViewById(R.id.jid);
jid.setAdapter(new KnownHostsAdapter(this,
android.R.layout.simple_list_item_1, mKnownConferenceHosts));
2014-11-03 19:00:20 +00:00
if (prefilledJid != null) {
jid.append(prefilledJid);
}
2014-07-11 17:48:41 +00:00
populateAccountSpinner(spinner);
2014-07-15 15:11:43 +00:00
final CheckBox bookmarkCheckBox = (CheckBox) dialogView
.findViewById(R.id.bookmark);
2014-07-11 17:48:41 +00:00
builder.setView(dialogView);
builder.setNegativeButton(R.string.cancel, null);
builder.setPositiveButton(R.string.join, null);
final AlertDialog dialog = builder.create();
dialog.show();
dialog.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener(
new View.OnClickListener() {
@Override
public void onClick(View v) {
if (!xmppConnectionServiceBound) {
return;
}
if (Validator.isValidJid(jid.getText().toString())) {
2014-11-06 19:45:38 +00:00
final Jid accountJid;
try {
accountJid = Jid.fromString((String) spinner.getSelectedItem());
} catch (final InvalidJidException e) {
return;
}
final Jid conferenceJid;
try {
conferenceJid = Jid.fromString(jid.getText().toString());
} catch (final InvalidJidException e) {
return; // TODO: Do some error handling...
}
Account account = xmppConnectionService
.findAccountByJid(accountJid);
if (account == null) {
2014-10-05 12:05:46 +00:00
dialog.dismiss();
return;
}
2014-07-15 12:32:19 +00:00
if (bookmarkCheckBox.isChecked()) {
if (account.hasBookmarkFor(conferenceJid)) {
jid.setError(getString(R.string.bookmark_already_exists));
} else {
2014-07-15 15:11:43 +00:00
Bookmark bookmark = new Bookmark(account,
conferenceJid);
2014-07-15 12:32:19 +00:00
bookmark.setAutojoin(true);
account.getBookmarks().add(bookmark);
2014-07-15 15:11:43 +00:00
xmppConnectionService
.pushBookmarks(account);
2014-07-15 12:32:19 +00:00
Conversation conversation = xmppConnectionService
.findOrCreateConversation(account,
conferenceJid, true);
conversation.setBookmark(bookmark);
if (!conversation.getMucOptions().online()) {
xmppConnectionService
.joinMuc(conversation);
}
2014-10-04 16:32:05 +00:00
dialog.dismiss();
2014-07-15 15:11:43 +00:00
switchToConversation(conversation);
2014-07-15 12:32:19 +00:00
}
} else {
Conversation conversation = xmppConnectionService
2014-07-15 15:11:43 +00:00
.findOrCreateConversation(account,
conferenceJid, true);
if (!conversation.getMucOptions().online()) {
xmppConnectionService.joinMuc(conversation);
}
2014-10-04 16:32:05 +00:00
dialog.dismiss();
2014-07-15 12:32:19 +00:00
switchToConversation(conversation);
}
} else {
jid.setError(getString(R.string.invalid_jid));
}
}
});
2014-07-11 17:48:41 +00:00
}
2014-07-10 11:19:42 +00:00
protected void switchToConversation(Contact contact) {
Conversation conversation = xmppConnectionService
.findOrCreateConversation(contact.getAccount(),
contact.getJid(), false);
2014-07-11 17:48:41 +00:00
switchToConversation(conversation);
2014-07-10 11:19:42 +00:00
}
2014-07-10 11:19:42 +00:00
private void populateAccountSpinner(Spinner spinner) {
2014-11-06 19:45:38 +00:00
ArrayAdapter<String> adapter = new ArrayAdapter<>(this,
android.R.layout.simple_spinner_item, mActivatedAccounts);
2014-07-10 11:19:42 +00:00
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
spinner.setAdapter(adapter);
}
2014-07-09 23:55:19 +00:00
@Override
public boolean onCreateOptionsMenu(Menu menu) {
this.mOptionsMenu = menu;
getMenuInflater().inflate(R.menu.start_conversation, menu);
2014-10-26 17:54:10 +00:00
MenuItem menuCreateContact = menu
.findItem(R.id.action_create_contact);
2014-10-26 17:54:10 +00:00
MenuItem menuCreateConference = menu
2014-07-11 17:48:41 +00:00
.findItem(R.id.action_join_conference);
2014-10-26 17:54:10 +00:00
mMenuSearchView = menu.findItem(R.id.action_search);
mMenuSearchView.setOnActionExpandListener(mOnActionExpandListener);
View mSearchView = mMenuSearchView.getActionView();
mSearchEditText = (EditText) mSearchView
.findViewById(R.id.search_field);
mSearchEditText.addTextChangedListener(mSearchTextWatcher);
2014-07-04 12:22:17 +00:00
if (getActionBar().getSelectedNavigationIndex() == 0) {
menuCreateConference.setVisible(false);
} else {
menuCreateContact.setVisible(false);
}
if (mInitialJid != null) {
mMenuSearchView.expandActionView();
mSearchEditText.append(mInitialJid);
filter(mInitialJid);
}
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.action_create_contact:
showCreateContactDialog(null);
return true;
case R.id.action_join_conference:
showJoinConferenceDialog(null);
return true;
case R.id.action_scan_qr_code:
new IntentIntegrator(this).initiateScan();
return true;
}
return super.onOptionsItemSelected(item);
}
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_SEARCH && !event.isLongPress()) {
mOptionsMenu.findItem(R.id.action_search).expandActionView();
return true;
}
return super.onKeyUp(keyCode, event);
}
@Override
public void onActivityResult(int requestCode, int resultCode, Intent intent) {
if ((requestCode & 0xFFFF) == IntentIntegrator.REQUEST_CODE) {
IntentResult scanResult = IntentIntegrator.parseActivityResult(requestCode, resultCode, intent);
if (scanResult != null && scanResult.getFormatName() != null) {
String data = scanResult.getContents();
2014-11-04 08:35:36 +00:00
Invite invite = new Invite(data);
if (xmppConnectionServiceBound) {
2014-11-04 08:35:36 +00:00
invite.invite();
} else if (invite.jid != null) {
this.mPendingInvite = invite;
} else {
this.mPendingInvite = null;
}
}
}
super.onActivityResult(requestCode, requestCode, intent);
}
2014-06-30 18:39:15 +00:00
@Override
protected void onBackendConnected() {
xmppConnectionService.setOnRosterUpdateListener(this.onRosterUpdate);
2014-07-10 11:19:42 +00:00
this.mActivatedAccounts.clear();
for (Account account : xmppConnectionService.getAccounts()) {
if (account.getStatus() != Account.STATUS_DISABLED) {
2014-11-06 19:45:38 +00:00
this.mActivatedAccounts.add(account.getJid().toString());
2014-07-10 11:19:42 +00:00
}
}
2014-07-10 17:42:37 +00:00
this.mKnownHosts = xmppConnectionService.getKnownHosts();
this.mKnownConferenceHosts = xmppConnectionService
.getKnownConferenceHosts();
if (this.mPendingInvite != null) {
2014-11-04 08:35:36 +00:00
mPendingInvite.invite();
this.mPendingInvite = null;
} else if (!handleIntent(getIntent())) {
if (mSearchEditText != null) {
filter(mSearchEditText.getText().toString());
} else {
filter(null);
}
}
setIntent(null);
}
2014-11-04 19:02:33 +00:00
@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
Invite getInviteJellyBean(NdefRecord record) {
return new Invite(record.toUri());
}
2014-11-03 19:00:20 +00:00
protected boolean handleIntent(Intent intent) {
if (intent == null || intent.getAction() == null) {
2014-11-03 19:00:20 +00:00
return false;
}
switch (intent.getAction()) {
2014-11-03 19:00:20 +00:00
case Intent.ACTION_SENDTO:
case Intent.ACTION_VIEW:
2014-11-04 12:27:54 +00:00
Log.d(Config.LOGTAG, "received uri=" + intent.getData());
return new Invite(intent.getData()).invite();
2014-11-03 19:00:20 +00:00
case NfcAdapter.ACTION_NDEF_DISCOVERED:
2014-11-04 12:14:29 +00:00
for (Parcelable message : getIntent().getParcelableArrayExtra(NfcAdapter.EXTRA_NDEF_MESSAGES)) {
if (message instanceof NdefMessage) {
Log.d(Config.LOGTAG, "received message=" + message);
for (NdefRecord record : ((NdefMessage)message).getRecords()) {
switch (record.getTnf()) {
2014-11-04 19:02:33 +00:00
case NdefRecord.TNF_WELL_KNOWN:
2014-11-04 12:14:29 +00:00
if (Arrays.equals(record.getType(), NdefRecord.RTD_URI)) {
if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
2014-11-04 19:02:33 +00:00
return getInviteJellyBean(record).invite();
2014-11-04 12:14:29 +00:00
} else {
2014-11-04 12:27:54 +00:00
byte[] payload = record.getPayload();
if (payload[0] == 0) {
return new Invite(Uri.parse(new String(Arrays.copyOfRange(
payload, 1, payload.length)))).invite();
2014-11-04 12:14:29 +00:00
}
}
}
}
}
2014-11-04 08:30:03 +00:00
}
2014-11-03 19:00:20 +00:00
}
}
2014-11-04 12:27:54 +00:00
return false;
}
private boolean handleJid(String jid) {
2014-09-28 13:21:56 +00:00
List<Contact> contacts = xmppConnectionService.findContacts(jid);
if (contacts.size() == 0) {
showCreateContactDialog(jid);
return false;
} else if (contacts.size() == 1) {
switchToConversation(contacts.get(0));
return true;
} else {
if (mMenuSearchView != null) {
mMenuSearchView.expandActionView();
mSearchEditText.setText("");
mSearchEditText.append(jid);
filter(jid);
} else {
mInitialJid = jid;
}
return true;
}
}
2014-07-15 15:11:43 +00:00
2014-07-14 09:47:42 +00:00
protected void filter(String needle) {
if (xmppConnectionServiceBound) {
this.filterContacts(needle);
this.filterConferences(needle);
}
2014-07-14 09:47:42 +00:00
}
protected void filterContacts(String needle) {
this.contacts.clear();
for (Account account : xmppConnectionService.getAccounts()) {
if (account.getStatus() != Account.STATUS_DISABLED) {
for (Contact contact : account.getRoster().getContacts()) {
if (contact.showInRoster() && contact.match(needle)) {
this.contacts.add(contact);
}
}
}
}
Collections.sort(this.contacts);
mContactsAdapter.notifyDataSetChanged();
}
2014-07-15 15:11:43 +00:00
2014-07-14 09:47:42 +00:00
protected void filterConferences(String needle) {
this.conferences.clear();
for (Account account : xmppConnectionService.getAccounts()) {
if (account.getStatus() != Account.STATUS_DISABLED) {
2014-07-15 15:11:43 +00:00
for (Bookmark bookmark : account.getBookmarks()) {
2014-07-14 09:47:42 +00:00
if (bookmark.match(needle)) {
this.conferences.add(bookmark);
}
}
}
}
Collections.sort(this.conferences);
mConferenceAdapter.notifyDataSetChanged();
}
private void onTabChanged() {
2014-07-09 21:13:23 +00:00
invalidateOptionsMenu();
}
public static class MyListFragment extends ListFragment {
private AdapterView.OnItemClickListener mOnItemClickListener;
2014-07-14 09:47:42 +00:00
private int mResContextMenu;
2014-07-15 15:11:43 +00:00
2014-07-14 09:47:42 +00:00
public void setContextMenu(int res) {
this.mResContextMenu = res;
}
@Override
public void onListItemClick(ListView l, View v, int position, long id) {
if (mOnItemClickListener != null) {
mOnItemClickListener.onItemClick(l, v, position, id);
}
}
public void setOnListItemClickListener(AdapterView.OnItemClickListener l) {
this.mOnItemClickListener = l;
}
2014-06-30 18:39:15 +00:00
2014-07-09 23:55:19 +00:00
@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
registerForContextMenu(getListView());
getListView().setFastScrollEnabled(true);
2014-07-09 23:55:19 +00:00
}
@Override
public void onCreateContextMenu(ContextMenu menu, View v,
ContextMenuInfo menuInfo) {
2014-07-09 23:55:19 +00:00
super.onCreateContextMenu(menu, v, menuInfo);
StartConversationActivity activity = (StartConversationActivity) getActivity();
2014-07-15 15:11:43 +00:00
activity.getMenuInflater().inflate(mResContextMenu, menu);
2014-07-09 23:55:19 +00:00
AdapterView.AdapterContextMenuInfo acmi = (AdapterContextMenuInfo) menuInfo;
2014-07-14 09:47:42 +00:00
if (mResContextMenu == R.menu.conference_context) {
activity.conference_context_id = acmi.position;
} else {
activity.contact_context_id = acmi.position;
}
2014-07-09 23:55:19 +00:00
}
@Override
public boolean onContextItemSelected(MenuItem item) {
StartConversationActivity activity = (StartConversationActivity) getActivity();
switch (item.getItemId()) {
case R.id.context_start_conversation:
activity.openConversationForContact();
break;
case R.id.context_contact_details:
activity.openDetailsForContact();
break;
case R.id.context_delete_contact:
activity.deleteContact();
break;
case R.id.context_join_conference:
activity.openConversationForBookmark();
break;
case R.id.context_delete_conference:
activity.deleteConference();
2014-07-09 23:55:19 +00:00
}
return true;
}
}
private class Invite {
2014-11-04 08:35:36 +00:00
private String jid;
private boolean muc;
Invite(Uri uri) {
parse(uri);
}
Invite(String uri) {
try {
parse(Uri.parse(uri));
} catch (IllegalArgumentException e) {
jid = null;
}
}
boolean invite() {
if (jid != null) {
if (muc) {
showJoinConferenceDialog(jid);
} else {
return handleJid(jid);
}
}
return false;
}
void parse(Uri uri) {
2014-11-04 12:27:54 +00:00
String scheme = uri.getScheme();
if ("xmpp".equals(scheme)) {
// sample: xmpp:jid@foo.com
muc = "join".equalsIgnoreCase(uri.getQuery());
if (uri.getAuthority() != null) {
jid = uri.getAuthority();
} else {
jid = uri.getSchemeSpecificPart().split("\\?")[0];
}
} else if ("imto".equals(scheme)) {
// sample: imto://xmpp/jid@foo.com
try {
jid = URLDecoder.decode(uri.getEncodedPath(), "UTF-8").split("/")[1];
2014-11-06 19:45:38 +00:00
} catch (final UnsupportedEncodingException ignored) {
2014-11-04 12:27:54 +00:00
}
2014-11-04 08:35:36 +00:00
}
}
}
2014-06-30 18:39:15 +00:00
}