anotherim/src/main/java/eu/siacs/conversations/ui/ShareWithActivity.java

package eu.siacs.conversations.ui;

import android.app.PendingIntent;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Bundle;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.Toast;

import java.net.URLConnection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

import eu.siacs.conversations.Config;
import eu.siacs.conversations.R;
import eu.siacs.conversations.entities.Account;
import eu.siacs.conversations.entities.Conversation;
import eu.siacs.conversations.entities.Message;
import eu.siacs.conversations.persistance.FileBackend;
import eu.siacs.conversations.services.XmppConnectionService;
import eu.siacs.conversations.ui.adapter.ConversationAdapter;
import eu.siacs.conversations.ui.service.EmojiService;
import eu.siacs.conversations.ui.util.PresenceSelector;
import eu.siacs.conversations.xmpp.XmppConnection;
import rocks.xmpp.addr.Jid;

public class ShareWithActivity extends XmppActivity implements XmppConnectionService.OnConversationUpdate {

	private static final int REQUEST_STORAGE_PERMISSION = 0x733f32;
	private boolean mReturnToPrevious = false;
	private Conversation mPendingConversation = null;

	@Override
	public void onConversationUpdate() {
		refreshUi();
	}

	private class Share {
		public List<Uri> uris = new ArrayList<>();
		public boolean image;
		public String account;
		public String contact;
		public String text;
		public String uuid;
		public boolean multiple = false;
		public String type;
	}

	private Share share;

	private static final int REQUEST_START_NEW_CONVERSATION = 0x0501;
	private RecyclerView mListView;
	private ConversationAdapter mAdapter;
	private List<Conversation> mConversations = new ArrayList<>();
	private Toast mToast;
	private AtomicInteger attachmentCounter = new AtomicInteger(0);

	private UiInformableCallback<Message> attachFileCallback = new UiInformableCallback<Message>() {

		@Override
		public void inform(final String text) {
			runOnUiThread(() -> replaceToast(text));
		}

		@Override
		public void userInputRequried(PendingIntent pi, Message object) {
			// TODO Auto-generated method stub

		}

		@Override
		public void success(final Message message) {
			runOnUiThread(() -> {
				if (attachmentCounter.decrementAndGet() <=0 ) {
					int resId;
					if (share.image && share.multiple) {
						resId = R.string.shared_images_with_x;
					} else if (share.image) {
						resId = R.string.shared_image_with_x;
					} else {
						resId = R.string.shared_file_with_x;
					}
					Conversation conversation = (Conversation) message.getConversation();
					replaceToast(getString(resId, conversation.getName()));
					if (mReturnToPrevious) {
						finish();
					} else {
						switchToConversation(conversation);
					}
				}
			});
		}

		@Override
		public void error(final int errorCode, Message object) {
			runOnUiThread(() -> {
				replaceToast(getString(errorCode));
				if (attachmentCounter.decrementAndGet() <=0 ) {
					finish();
				}
			});
		}
	};

	protected void hideToast() {
		if (mToast != null) {
			mToast.cancel();
		}
	}

	protected void replaceToast(String msg) {
		hideToast();
		mToast = Toast.makeText(this, msg ,Toast.LENGTH_LONG);
		mToast.show();
	}

	protected void onActivityResult(int requestCode, int resultCode, final Intent data) {
		super.onActivityResult(requestCode, resultCode, data);
		if (requestCode == REQUEST_START_NEW_CONVERSATION
				&& resultCode == RESULT_OK) {
			share.contact = data.getStringExtra("contact");
			share.account = data.getStringExtra(EXTRA_ACCOUNT);
		}
		if (xmppConnectionServiceBound
				&& share != null
				&& share.contact != null
				&& share.account != null) {
			share();
		}
	}

	@Override
	public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
		if (grantResults.length > 0)
			if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
				if (requestCode == REQUEST_STORAGE_PERMISSION) {
					if (this.mPendingConversation != null) {
						share(this.mPendingConversation);
					} else {
						Log.d(Config.LOGTAG,"unable to find stored conversation");
					}
				}
			} else {
				Toast.makeText(this, R.string.no_storage_permission, Toast.LENGTH_SHORT).show();
			}
	}

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		new EmojiService(this).init();

		setContentView(R.layout.activity_share_with);

		setSupportActionBar(findViewById(R.id.toolbar));
		if (getSupportActionBar() != null) {
			getSupportActionBar().setDisplayHomeAsUpEnabled(false);
			getSupportActionBar().setHomeButtonEnabled(false);
		}

		setTitle(getString(R.string.title_activity_sharewith));

		mListView = findViewById(R.id.choose_conversation_list);
		mAdapter = new ConversationAdapter(this, this.mConversations);
		mListView.setLayoutManager(new LinearLayoutManager(this,LinearLayoutManager.VERTICAL,false));
		mListView.setAdapter(mAdapter);
		mAdapter.setConversationClickListener((view, conversation) -> share(conversation));
		this.share = new Share();
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		getMenuInflater().inflate(R.menu.share_with, menu);
		return true;
	}

	@Override
	public boolean onOptionsItemSelected(final MenuItem item) {
		switch (item.getItemId()) {
			case R.id.action_add:
				final Intent intent = new Intent(getApplicationContext(), ChooseContactActivity.class);
				startActivityForResult(intent, REQUEST_START_NEW_CONVERSATION);
				return true;
		}
		return super.onOptionsItemSelected(item);
	}

	@Override
	public void onStart() {
		super.onStart();
		Intent intent = getIntent();
		if (intent == null) {
			return;
		}
		this.mReturnToPrevious = getPreferences().getBoolean("return_to_previous", getResources().getBoolean(R.bool.return_to_previous));
		final String type = intent.getType();
		final String action = intent.getAction();
		Log.d(Config.LOGTAG, "action: "+action+ ", type:"+type);
		share.uuid = intent.getStringExtra("uuid");
		if (Intent.ACTION_SEND.equals(action)) {
			final String text = intent.getStringExtra(Intent.EXTRA_TEXT);
			final Uri uri = intent.getParcelableExtra(Intent.EXTRA_STREAM);
			if (type != null && uri != null && (text == null || !type.equals("text/plain"))) {
				this.share.uris.clear();
				this.share.uris.add(uri);
				this.share.image = type.startsWith("image/") || isImage(uri);
				this.share.type = type;
			} else {
				this.share.text = text;
			}
		} else if (Intent.ACTION_SEND_MULTIPLE.equals(action)) {
			this.share.image = type != null && type.startsWith("image/");
			if (!this.share.image) {
				return;
			}
			this.share.uris = intent.getParcelableArrayListExtra(Intent.EXTRA_STREAM);
		}
		if (xmppConnectionServiceBound) {
			if (share.uuid != null) {
				share();
			} else {
				xmppConnectionService.populateWithOrderedConversations(mConversations, this.share.uris.size() == 0);
			}
		}

	}

	protected boolean isImage(Uri uri) {
		try {
			String guess = URLConnection.guessContentTypeFromName(uri.toString());
			return (guess != null && guess.startsWith("image/"));
		} catch (final StringIndexOutOfBoundsException ignored) {
			return false;
		}
	}

	@Override
	void onBackendConnected() {
		if (xmppConnectionServiceBound && share != null
				&& ((share.contact != null && share.account != null) || share.uuid != null)) {
			share();
			return;
		}
		refreshUiReal();
	}

	private void share() {
		final Conversation conversation;
		if (share.uuid != null) {
			conversation = xmppConnectionService.findConversationByUuid(share.uuid);
			if (conversation == null) {
				return;
			}
		}else{
			Account account;
			try {
				account = xmppConnectionService.findAccountByJid(Jid.of(share.account));
			} catch (final IllegalArgumentException e) {
				account = null;
			}
			if (account == null) {
				return;
			}

			try {
				conversation = xmppConnectionService
						.findOrCreateConversation(account, Jid.of(share.contact), false,true);
			} catch (final IllegalArgumentException e) {
				return;
			}
		}
		share(conversation);
	}

	private void share(final Conversation conversation) {
		if (share.uris.size() != 0 && !hasStoragePermission(REQUEST_STORAGE_PERMISSION)) {
			mPendingConversation = conversation;
			return;
		}
		final Account account = conversation.getAccount();
		final XmppConnection connection = account.getXmppConnection();
		final long max = connection == null ? -1 : connection.getFeatures().getMaxHttpUploadSize();
		mListView.setEnabled(false);
		if (conversation.getNextEncryption() == Message.ENCRYPTION_PGP && !hasPgp()) {
			if (share.uuid == null) {
				showInstallPgpDialog();
			} else {
				Toast.makeText(this,R.string.openkeychain_not_installed,Toast.LENGTH_SHORT).show();
				finish();
			}
			return;
		}
		if (share.uris.size() != 0) {
			PresenceSelector.OnPresenceSelected callback = () -> {
				attachmentCounter.set(share.uris.size());
				if (share.image) {
					share.multiple = share.uris.size() > 1;
					replaceToast(getString(share.multiple ? R.string.preparing_images : R.string.preparing_image));
					for (Iterator<Uri> i = share.uris.iterator(); i.hasNext(); i.remove()) {
						final Uri uri = i.next();
						delegateUriPermissionsToService(uri);
						xmppConnectionService.attachImageToConversation(conversation, uri, attachFileCallback);
					}
				} else {
					replaceToast(getString(R.string.preparing_file));
					final Uri uri = share.uris.get(0);
					delegateUriPermissionsToService(uri);
					xmppConnectionService.attachFileToConversation(conversation, uri, share.type,  attachFileCallback);
				}
			};
			if (account.httpUploadAvailable()
					&& ((share.image && !neverCompressPictures())
					|| conversation.getMode() == Conversation.MODE_MULTI
					|| FileBackend.allFilesUnderSize(this, share.uris, max))) {
				callback.onPresenceSelected();
			} else {
				selectPresence(conversation, callback);
			}
		} else {
			if (mReturnToPrevious && this.share.text != null && !this.share.text.isEmpty() ) {
				final PresenceSelector.OnPresenceSelected callback = new PresenceSelector.OnPresenceSelected() {

					private void finishAndSend(Message message) {
						replaceToast(getString(R.string.shared_text_with_x, conversation.getName()));
						finish();
					}

					private UiCallback<Message> messageEncryptionCallback = new UiCallback<Message>() {
						@Override
						public void success(final Message message) {
							runOnUiThread(() -> finishAndSend(message));
						}

						@Override
						public void error(final int errorCode, Message object) {
							runOnUiThread(() -> {
								replaceToast(getString(errorCode));
								finish();
							});
						}

						@Override
						public void userInputRequried(PendingIntent pi, Message object) {
							finish();
						}
					};

					@Override
					public void onPresenceSelected() {

						final int encryption = conversation.getNextEncryption();

						Message message = new Message(conversation,share.text, encryption);

						Log.d(Config.LOGTAG,"on presence selected encrpytion="+encryption);

						if (encryption == Message.ENCRYPTION_PGP) {
							replaceToast(getString(R.string.encrypting_message));
							xmppConnectionService.getPgpEngine().encrypt(message,messageEncryptionCallback);
							return;
						}
						xmppConnectionService.sendMessage(message);
						finishAndSend(message);
					}
				};
				if (conversation.getNextEncryption() == Message.ENCRYPTION_OTR) {
					selectPresence(conversation, callback);
				} else {
					callback.onPresenceSelected();
				}
			} else {
				switchToConversation(conversation, this.share.text, true);
			}
		}

	}

	public void refreshUiReal() {
		xmppConnectionService.populateWithOrderedConversations(mConversations, this.share != null && this.share.uris.size() == 0);
		mAdapter.notifyDataSetChanged();
	}

	@Override
	public void onBackPressed() {
		if (attachmentCounter.get() >= 1) {
			replaceToast(getString(R.string.sharing_files_please_wait));
		} else {
			super.onBackPressed();
		}
	}
}