Initial commit

app/src/main/java/com/termux/app/DialogUtils.java

@@ -0,0 +1,43 @@
+package com.termux.app;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+import android.util.TypedValue;
+import android.view.ViewGroup.LayoutParams;
+import android.widget.EditText;
+import android.widget.LinearLayout;
+
+final class DialogUtils {
+
+	public interface TextSetListener {
+		void onTextSet(String text);
+	}
+
+	static void textInput(Activity activity, int titleText, int positiveButtonText, String initialText, final TextSetListener onPositive) {
+		final EditText input = new EditText(activity);
+		input.setSingleLine();
+		if (initialText != null) input.setText(initialText);
+
+		float dipInPixels = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 1, activity.getResources().getDisplayMetrics());
+		// https://www.google.com/design/spec/components/dialogs.html#dialogs-specs
+		int paddingTopAndSides = Math.round(16 * dipInPixels);
+		int paddingBottom = Math.round(24 * dipInPixels);
+
+		LinearLayout layout = new LinearLayout(activity);
+		layout.setOrientation(LinearLayout.VERTICAL);
+		layout.setLayoutParams(new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT));
+		// layout.setGravity(Gravity.CLIP_VERTICAL);
+		layout.setPadding(paddingTopAndSides, paddingTopAndSides, paddingTopAndSides, paddingBottom);
+		layout.addView(input);
+
+		new AlertDialog.Builder(activity).setTitle(titleText).setView(layout).setPositiveButton(positiveButtonText, new DialogInterface.OnClickListener() {
+			@Override
+			public void onClick(DialogInterface d, int whichButton) {
+				onPositive.onTextSet(input.getText().toString());
+			}
+		}).setNegativeButton(android.R.string.cancel, null).show();
+		input.requestFocus();
+	}
+
+}

app/src/main/java/com/termux/app/FullScreenHelper.java

@@ -0,0 +1,68 @@
+package com.termux.app;
+
+import android.app.Activity;
+import android.graphics.Rect;
+import android.view.View;
+import android.view.ViewTreeObserver;
+import android.view.Window;
+import android.view.WindowManager;
+import android.widget.FrameLayout;
+import android.widget.FrameLayout.LayoutParams;
+
+/**
+ * Utility to make the touch keyboard and immersive mode work with full screen activities.
+ * 
+ * See https://code.google.com/p/android/issues/detail?id=5497
+ */
+final class FullScreenHelper implements ViewTreeObserver.OnGlobalLayoutListener {
+
+	private boolean mEnabled = false;
+	private final Activity mActivity;
+	private final Rect mWindowRect = new Rect();
+
+	public FullScreenHelper(Activity activity) {
+		this.mActivity = activity;
+	}
+
+	public void setImmersive(boolean enabled) {
+		Window win = mActivity.getWindow();
+
+		if (enabled == mEnabled) {
+			if (!enabled) win.setFlags(0, WindowManager.LayoutParams.FLAG_FULLSCREEN);
+			return;
+		}
+		mEnabled = enabled;
+
+		final View childViewOfContent = ((FrameLayout) mActivity.findViewById(android.R.id.content)).getChildAt(0);
+		if (enabled) {
+			win.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
+			setImmersiveMode();
+			childViewOfContent.getViewTreeObserver().addOnGlobalLayoutListener(this);
+		} else {
+			win.setFlags(0, WindowManager.LayoutParams.FLAG_FULLSCREEN);
+			win.getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_VISIBLE);
+			childViewOfContent.getViewTreeObserver().removeOnGlobalLayoutListener(this);
+			((LayoutParams) childViewOfContent.getLayoutParams()).height = android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+		}
+	}
+
+	private void setImmersiveMode() {
+		mActivity.getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
+	}
+
+	@Override
+	public void onGlobalLayout() {
+		final View childViewOfContent = ((FrameLayout) mActivity.findViewById(android.R.id.content)).getChildAt(0);
+
+		if (mEnabled) setImmersiveMode();
+
+		childViewOfContent.getWindowVisibleDisplayFrame(mWindowRect);
+		int usableHeightNow = Math.min(mWindowRect.height(), childViewOfContent.getRootView().getHeight());
+		FrameLayout.LayoutParams layout = (LayoutParams) childViewOfContent.getLayoutParams();
+		if (layout.height != usableHeightNow) {
+			layout.height = usableHeightNow;
+			childViewOfContent.requestLayout();
+		}
+	}
+
+}

app/src/main/java/com/termux/app/TermuxActivity.java

@@ -0,0 +1,752 @@
+package com.termux.app;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import com.termux.R;
+import com.termux.drawer.DrawerLayout;
+import com.termux.terminal.TerminalSession;
+import com.termux.terminal.TerminalSession.SessionChangedCallback;
+import com.termux.view.TerminalKeyListener;
+import com.termux.view.TerminalView;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.ActivityNotFoundException;
+import android.content.BroadcastReceiver;
+import android.content.ClipData;
+import android.content.ClipboardManager;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnShowListener;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.ServiceConnection;
+import android.content.res.Resources;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Typeface;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.Vibrator;
+import android.text.SpannableString;
+import android.text.Spanned;
+import android.text.TextUtils;
+import android.text.style.StyleSpan;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.Gravity;
+import android.view.KeyEvent;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.View.OnKeyListener;
+import android.view.View.OnLongClickListener;
+import android.view.ViewGroup;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.AdapterView.OnItemLongClickListener;
+import android.widget.ArrayAdapter;
+import android.widget.ListView;
+import android.widget.TextView;
+import android.widget.Toast;
+
+/**
+ * A terminal emulator activity.
+ * 
+ * See
+ * <ul>
+ * <li>http://www.mongrel-phones.com.au/default/how_to_make_a_local_service_and_bind_to_it_in_android</li>
+ * <li>https://code.google.com/p/android/issues/detail?id=6426</li>
+ * </ul>
+ * about memory leaks.
+ */
+public final class TermuxActivity extends Activity implements ServiceConnection {
+
+	private static final int CONTEXTMENU_SELECT_ID = 0;
+	private static final int CONTEXTMENU_PASTE_ID = 3;
+	private static final int CONTEXTMENU_KILL_PROCESS_ID = 4;
+	private static final int CONTEXTMENU_RESET_TERMINAL_ID = 5;
+	private static final int CONTEXTMENU_STYLING_ID = 6;
+	private static final int CONTEXTMENU_TOGGLE_FULLSCREEN_ID = 7;
+	private static final int CONTEXTMENU_HELP_ID = 8;
+
+	private static final int MAX_SESSIONS = 8;
+
+	private static final String RELOAD_STYLE_ACTION = "com.termux.app.reload_style";
+
+	/** The main view of the activity showing the terminal. */
+	TerminalView mTerminalView;
+
+	final FullScreenHelper mFullScreenHelper = new FullScreenHelper(this);
+
+	TermuxPreferences mSettings;
+
+	/**
+	 * The connection to the {@link TermuxService}. Requested in {@link #onCreate(Bundle)} with a call to
+	 * {@link #bindService(Intent, ServiceConnection, int)}, and obtained and stored in
+	 * {@link #onServiceConnected(ComponentName, IBinder)}.
+	 */
+	TermuxService mTermService;
+
+	/** Initialized in {@link #onServiceConnected(ComponentName, IBinder)}. */
+	ArrayAdapter<TerminalSession> mListViewAdapter;
+
+	/** The last toast shown, used cancel current toast before showing new in {@link #showToast(String, boolean)}. */
+	Toast mLastToast;
+
+	/**
+	 * If between onResume() and onStop(). Note that only one session is in the foreground of the terminal view at the
+	 * time, so if the session causing a change is not in the foreground it should probably be treated as background.
+	 */
+	boolean mIsVisible;
+
+	private final BroadcastReceiver mBroadcastReceiever = new BroadcastReceiver() {
+		@Override
+		public void onReceive(Context context, Intent intent) {
+			if (mIsVisible) {
+				String whatToReload = intent.getStringExtra(RELOAD_STYLE_ACTION);
+				if (whatToReload == null || "colors".equals(whatToReload)) mTerminalView.checkForColors();
+				if (whatToReload == null || "font".equals(whatToReload)) mTerminalView.checkForTypeface();
+			}
+		}
+	};
+
+	@Override
+	public void onCreate(Bundle bundle) {
+		super.onCreate(bundle);
+
+		// Prevent overdraw:
+		getWindow().getDecorView().setBackground(null);
+
+		setContentView(R.layout.drawer_layout);
+		mTerminalView = (TerminalView) findViewById(R.id.terminal_view);
+		mSettings = new TermuxPreferences(this);
+		mTerminalView.setTextSize(mSettings.getFontSize());
+		mFullScreenHelper.setImmersive(mSettings.isFullScreen());
+		mTerminalView.requestFocus();
+
+		OnKeyListener keyListener = new OnKeyListener() {
+			@Override
+			public boolean onKey(View v, int keyCode, KeyEvent event) {
+				if (event.getAction() != KeyEvent.ACTION_DOWN) return false;
+
+				final TerminalSession currentSession = getCurrentTermSession();
+
+				if (keyCode == KeyEvent.KEYCODE_ENTER && !currentSession.isRunning()) {
+					// Return pressed with finished session - remove it.
+					currentSession.finishIfRunning();
+
+					int index = mTermService.removeTermSession(currentSession);
+					mListViewAdapter.notifyDataSetChanged();
+					if (mTermService.getSessions().isEmpty()) {
+						// There are no sessions to show, so finish the activity.
+						finish();
+					} else {
+						if (index >= mTermService.getSessions().size()) {
+							index = mTermService.getSessions().size() - 1;
+						}
+						switchToSession(mTermService.getSessions().get(index));
+					}
+					return true;
+				} else if (!(event.isCtrlPressed() && event.isShiftPressed())) {
+					// Only hook shortcuts with Ctrl+Shift down.
+					return false;
+				}
+
+				// Get the unmodified code point:
+				int unicodeChar = event.getUnicodeChar(0);
+
+				if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN || unicodeChar == 'n'/* next */) {
+					int index = mTermService.getSessions().indexOf(currentSession);
+					if (++index >= mTermService.getSessions().size()) index = 0;
+					switchToSession(mTermService.getSessions().get(index));
+				} else if (keyCode == KeyEvent.KEYCODE_DPAD_UP || unicodeChar == 'p' /* previous */) {
+					int index = mTermService.getSessions().indexOf(currentSession);
+					if (--index < 0) index = mTermService.getSessions().size() - 1;
+					switchToSession(mTermService.getSessions().get(index));
+				} else if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
+					getDrawer().openDrawer(Gravity.START);
+				} else if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
+					getDrawer().closeDrawers();
+				} else if (unicodeChar == 'f'/* full screen */) {
+					toggleImmersive();
+				} else if (unicodeChar == 'm'/* menu */) {
+					mTerminalView.showContextMenu();
+				} else if (unicodeChar == 'r'/* rename */) {
+					renameSession(currentSession);
+				} else if (unicodeChar == 'c'/* create */) {
+					addNewSession(false, null);
+				} else if (unicodeChar == 'u' /* urls */) {
+					showUrlSelection();
+				} else if (unicodeChar == 'v') {
+					doPaste();
+				} else if (unicodeChar == '+' || event.getUnicodeChar(KeyEvent.META_SHIFT_ON) == '+') {
+					// We also check for the shifted char here since shift may be required to produce '+',
+					// see https://github.com/termux/termux-api/issues/2
+					changeFontSize(true);
+				} else if (unicodeChar == '-') {
+					changeFontSize(false);
+				} else if (unicodeChar >= '1' && unicodeChar <= '9') {
+					int num = unicodeChar - '1';
+					if (mTermService.getSessions().size() > num) switchToSession(mTermService.getSessions().get(num));
+				}
+				return true;
+			}
+		};
+		mTerminalView.setOnKeyListener(keyListener);
+		findViewById(R.id.left_drawer_list).setOnKeyListener(keyListener);
+
+		mTerminalView.setOnKeyListener(new TerminalKeyListener() {
+			@Override
+			public float onScale(float scale) {
+				if (scale < 0.9f || scale > 1.1f) {
+					boolean increase = scale > 1.f;
+					changeFontSize(increase);
+					return 1.0f;
+				}
+				return scale;
+			}
+
+			@Override
+			public void onLongPress(MotionEvent event) {
+				mTerminalView.showContextMenu();
+			}
+
+			@Override
+			public void onSingleTapUp(MotionEvent e) {
+				// Toggle keyboard visibility if tapping with a finger:
+				InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+				imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
+			}
+
+		});
+
+		findViewById(R.id.new_session_button).setOnClickListener(new OnClickListener() {
+			@Override
+			public void onClick(View v) {
+				addNewSession(false, null);
+			}
+		});
+
+		findViewById(R.id.new_session_button).setOnLongClickListener(new OnLongClickListener() {
+			@Override
+			public boolean onLongClick(View v) {
+				Resources res = getResources();
+				new AlertDialog.Builder(TermuxActivity.this).setTitle(R.string.new_session)
+						.setItems(new String[] { res.getString(R.string.new_session_normal_unnamed), res.getString(R.string.new_session_normal_named),
+								res.getString(R.string.new_session_failsafe) }, new DialogInterface.OnClickListener() {
+					@Override
+					public void onClick(DialogInterface dialog, int which) {
+						switch (which) {
+						case 0:
+							addNewSession(false, null);
+							break;
+						case 1:
+							DialogUtils.textInput(TermuxActivity.this, R.string.session_new_named_title, R.string.session_new_named_positive_button, null,
+									new DialogUtils.TextSetListener() {
+								@Override
+								public void onTextSet(String text) {
+									addNewSession(false, text);
+								}
+							});
+							break;
+						case 2:
+							addNewSession(true, null);
+							break;
+						}
+					}
+				}).show();
+				return true;
+			}
+		});
+
+		findViewById(R.id.toggle_keyboard_button).setOnClickListener(new OnClickListener() {
+			@Override
+			public void onClick(View v) {
+				InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+				imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
+				getDrawer().closeDrawers();
+			}
+		});
+
+		registerForContextMenu(mTerminalView);
+
+		Intent serviceIntent = new Intent(this, TermuxService.class);
+		// Start the service and make it run regardless of who is bound to it:
+		startService(serviceIntent);
+		if (!bindService(serviceIntent, this, 0)) throw new RuntimeException("bindService() failed");
+
+		mTerminalView.checkForTypeface();
+		mTerminalView.checkForColors();
+	}
+
+	/**
+	 * Part of the {@link ServiceConnection} interface. The service is bound with
+	 * {@link #bindService(Intent, ServiceConnection, int)} in {@link #onCreate(Bundle)} which will cause a call to this
+	 * callback method.
+	 */
+	@Override
+	public void onServiceConnected(ComponentName componentName, IBinder service) {
+		mTermService = ((TermuxService.LocalBinder) service).service;
+
+		mTermService.mSessionChangeCallback = new SessionChangedCallback() {
+			@Override
+			public void onTextChanged(TerminalSession changedSession) {
+				if (!mIsVisible) return;
+				if (getCurrentTermSession() == changedSession) mTerminalView.onScreenUpdated();
+			}
+
+			@Override
+			public void onTitleChanged(TerminalSession updatedSession) {
+				if (!mIsVisible) return;
+				if (updatedSession != getCurrentTermSession()) {
+					// Only show toast for other sessions than the current one, since the user
+					// probably consciously caused the title change to change in the current session
+					// and don't want an annoying toast for that.
+					showToast(toToastTitle(updatedSession), false);
+				}
+				mListViewAdapter.notifyDataSetChanged();
+			}
+
+			@Override
+			public void onSessionFinished(final TerminalSession finishedSession) {
+				if (mTermService.mWantsToStop) {
+					// The service wants to stop as soon as possible.
+					finish();
+					return;
+				}
+				if (mIsVisible && finishedSession != getCurrentTermSession()) {
+					// Show toast for non-current sessions that exit.
+					int indexOfSession = mTermService.getSessions().indexOf(finishedSession);
+					// Verify that session was not removed before we got told about it finishing:
+					if (indexOfSession >= 0) showToast(toToastTitle(finishedSession) + " - exited", true);
+				}
+				mListViewAdapter.notifyDataSetChanged();
+			}
+
+			@Override
+			public void onClipboardText(TerminalSession session, String text) {
+				if (!mIsVisible) return;
+				showToast("Clipboard set:\n\"" + text + "\"", true);
+				ClipboardManager clipboard = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);
+				clipboard.setPrimaryClip(new ClipData(null, new String[] { "text/plain" }, new ClipData.Item(text)));
+			}
+
+			@Override
+			public void onBell(TerminalSession session) {
+				if (mIsVisible) ((Vibrator) getSystemService(VIBRATOR_SERVICE)).vibrate(50);
+			}
+		};
+
+		ListView listView = (ListView) findViewById(R.id.left_drawer_list);
+		mListViewAdapter = new ArrayAdapter<TerminalSession>(getApplicationContext(), R.layout.line_in_drawer, mTermService.getSessions()) {
+			final StyleSpan boldSpan = new StyleSpan(Typeface.BOLD);
+			final StyleSpan italicSpan = new StyleSpan(Typeface.ITALIC);
+
+			@Override
+			public View getView(int position, View convertView, ViewGroup parent) {
+				View row = convertView;
+				if (row == null) {
+					LayoutInflater inflater = getLayoutInflater();
+					row = inflater.inflate(R.layout.line_in_drawer, parent, false);
+				}
+
+				TerminalSession sessionAtRow = getItem(position);
+				boolean sessionRunning = sessionAtRow.isRunning();
+
+				TextView firstLineView = (TextView) row.findViewById(R.id.row_line);
+
+				String name = sessionAtRow.mSessionName;
+				String sessionTitle = sessionAtRow.getTitle();
+
+				String numberPart = "[" + (position + 1) + "] ";
+				String sessionNamePart = (TextUtils.isEmpty(name) ? "" : name);
+				String sessionTitlePart = (TextUtils.isEmpty(sessionTitle) ? "" : ((sessionNamePart.isEmpty() ? "" : "\n") + sessionTitle));
+
+				String text = numberPart + sessionNamePart + sessionTitlePart;
+				SpannableString styledText = new SpannableString(text);
+				styledText.setSpan(boldSpan, 0, numberPart.length() + sessionNamePart.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+				styledText.setSpan(italicSpan, numberPart.length() + sessionNamePart.length(), text.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+
+				firstLineView.setText(styledText);
+
+				if (sessionRunning) {
+					firstLineView.setPaintFlags(firstLineView.getPaintFlags() & ~Paint.STRIKE_THRU_TEXT_FLAG);
+				} else {
+					firstLineView.setPaintFlags(firstLineView.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
+				}
+				int color = sessionRunning || sessionAtRow.getExitStatus() == 0 ? Color.BLACK : Color.RED;
+				firstLineView.setTextColor(color);
+				return row;
+			}
+		};
+		listView.setAdapter(mListViewAdapter);
+		listView.setOnItemClickListener(new OnItemClickListener() {
+			@Override
+			public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+				TerminalSession clickedSession = mListViewAdapter.getItem(position);
+				switchToSession(clickedSession);
+				getDrawer().closeDrawers();
+			}
+		});
+		listView.setOnItemLongClickListener(new AdapterView.OnItemLongClickListener() {
+			@Override
+			public boolean onItemLongClick(AdapterView<?> parent, View view, final int position, long id) {
+				final TerminalSession selectedSession = mListViewAdapter.getItem(position);
+				renameSession(selectedSession);
+				return true;
+			}
+		});
+
+		if (mTermService.getSessions().isEmpty()) {
+			if (mIsVisible) {
+				TermuxInstaller.setupIfNeeded(TermuxActivity.this, new Runnable() {
+					@Override
+					public void run() {
+						if (TermuxPreferences.isShowWelcomeDialog(TermuxActivity.this)) {
+							new AlertDialog.Builder(TermuxActivity.this).setTitle(R.string.welcome_dialog_title).setMessage(R.string.welcome_dialog_body)
+									.setCancelable(false).setPositiveButton(android.R.string.ok, null)
+									.setNegativeButton(R.string.welcome_dialog_dont_show_again_button, new DialogInterface.OnClickListener() {
+								@Override
+								public void onClick(DialogInterface dialog, int which) {
+									TermuxPreferences.disableWelcomeDialog(TermuxActivity.this);
+									dialog.dismiss();
+								}
+							}).show();
+						}
+						addNewSession(false, null);
+					}
+				});
+			} else {
+				// The service connected while not in foreground - just bail out.
+				finish();
+			}
+		} else {
+			switchToSession(getStoredCurrentSessionOrLast());
+		}
+	}
+
+	@SuppressLint("InflateParams")
+	void renameSession(final TerminalSession sessionToRename) {
+		DialogUtils.textInput(this, R.string.session_rename_title, R.string.session_rename_positive_button, sessionToRename.mSessionName,
+				new DialogUtils.TextSetListener() {
+					@Override
+					public void onTextSet(String text) {
+						sessionToRename.mSessionName = text;
+					}
+				});
+	}
+
+	@Override
+	public void onServiceDisconnected(ComponentName name) {
+		if (mTermService != null) {
+			// Respect being stopped from the TermuxService notification action.
+			finish();
+		}
+	}
+
+	TerminalSession getCurrentTermSession() {
+		return mTerminalView.getCurrentSession();
+	}
+
+	@Override
+	public void onStart() {
+		super.onStart();
+		mIsVisible = true;
+
+		if (mTermService != null) {
+			// The service has connected, but data may have changed since we were last in the foreground.
+			switchToSession(getStoredCurrentSessionOrLast());
+			mListViewAdapter.notifyDataSetChanged();
+		}
+
+		registerReceiver(mBroadcastReceiever, new IntentFilter(RELOAD_STYLE_ACTION));
+	}
+
+	@Override
+	protected void onStop() {
+		super.onStop();
+		mIsVisible = false;
+		TerminalSession currentSession = getCurrentTermSession();
+		if (currentSession != null) TermuxPreferences.storeCurrentSession(this, currentSession);
+		unregisterReceiver(mBroadcastReceiever);
+		getDrawer().closeDrawers();
+	}
+
+	@Override
+	public void onBackPressed() {
+		if (getDrawer().isDrawerOpen(Gravity.START))
+			getDrawer().closeDrawers();
+		else
+			finish();
+	}
+
+	@Override
+	public void onDestroy() {
+		super.onDestroy();
+		if (mTermService != null) {
+			// Do not leave service with references to activity.
+			mTermService.mSessionChangeCallback = null;
+			mTermService = null;
+		}
+		unbindService(this);
+	}
+
+	DrawerLayout getDrawer() {
+		return (DrawerLayout) findViewById(R.id.drawer_layout);
+	}
+
+	void addNewSession(boolean failSafe, String sessionName) {
+		if (mTermService.getSessions().size() >= MAX_SESSIONS) {
+			new AlertDialog.Builder(this).setTitle(R.string.max_terminals_reached_title).setMessage(R.string.max_terminals_reached_message)
+					.setPositiveButton(android.R.string.ok, null).show();
+		} else {
+			String executablePath = (failSafe ? "/system/bin/sh" : null);
+			TerminalSession newSession = mTermService.createTermSession(executablePath, null, null, failSafe);
+			if (sessionName != null) {
+				newSession.mSessionName = sessionName;
+			}
+			switchToSession(newSession);
+			getDrawer().closeDrawers();
+		}
+	}
+
+	/** Try switching to session and note about it, but do nothing if already displaying the session. */
+	void switchToSession(TerminalSession session) {
+		if (mTerminalView.attachSession(session)) noteSessionInfo();
+	}
+
+	String toToastTitle(TerminalSession session) {
+		final int indexOfSession = mTermService.getSessions().indexOf(session);
+		StringBuilder toastTitle = new StringBuilder("[" + (indexOfSession + 1) + "]");
+		if (!TextUtils.isEmpty(session.mSessionName)) {
+			toastTitle.append(" ").append(session.mSessionName);
+		}
+		String title = session.getTitle();
+		if (!TextUtils.isEmpty(title)) {
+			// Space to "[${NR}] or newline after session name:
+			toastTitle.append(session.mSessionName == null ? " " : "\n");
+			toastTitle.append(title);
+		}
+		return toastTitle.toString();
+	}
+
+	void noteSessionInfo() {
+		if (!mIsVisible) return;
+		TerminalSession session = getCurrentTermSession();
+		final int indexOfSession = mTermService.getSessions().indexOf(session);
+		showToast(toToastTitle(session), false);
+		mListViewAdapter.notifyDataSetChanged();
+		final ListView lv = ((ListView) findViewById(R.id.left_drawer_list));
+		lv.setItemChecked(indexOfSession, true);
+		lv.smoothScrollToPosition(indexOfSession);
+	}
+
+	@Override
+	public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+		TerminalSession currentSession = getCurrentTermSession();
+		if (currentSession == null) return;
+
+		ClipboardManager clipboard = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);
+		menu.add(Menu.NONE, CONTEXTMENU_PASTE_ID, Menu.NONE, R.string.paste_text).setEnabled(clipboard.hasPrimaryClip());
+		menu.add(Menu.NONE, CONTEXTMENU_SELECT_ID, Menu.NONE, R.string.select);
+		menu.add(Menu.NONE, CONTEXTMENU_RESET_TERMINAL_ID, Menu.NONE, R.string.reset_terminal);
+		menu.add(Menu.NONE, CONTEXTMENU_KILL_PROCESS_ID, Menu.NONE, R.string.kill_process).setEnabled(currentSession.isRunning());
+		menu.add(Menu.NONE, CONTEXTMENU_TOGGLE_FULLSCREEN_ID, Menu.NONE, R.string.toggle_fullscreen).setCheckable(true).setChecked(mSettings.isFullScreen());
+		menu.add(Menu.NONE, CONTEXTMENU_STYLING_ID, Menu.NONE, R.string.style_terminal);
+		menu.add(Menu.NONE, CONTEXTMENU_HELP_ID, Menu.NONE, R.string.help);
+	}
+
+	/** Hook system menu to show context menu instead. */
+	@Override
+	public boolean onCreateOptionsMenu(Menu menu) {
+		mTerminalView.showContextMenu();
+		return false;
+	}
+
+	void showUrlSelection() {
+		String text = getCurrentTermSession().getEmulator().getScreen().getTranscriptText();
+		// Pattern for recognizing a URL, based off RFC 3986
+		// http://stackoverflow.com/questions/5713558/detect-and-extract-url-from-a-string
+		final Pattern urlPattern = Pattern.compile(
+				"(?:^|[\\W])((ht|f)tp(s?):\\/\\/|www\\.)" + "(([\\w\\-]+\\.){1,}?([\\w\\-.~]+\\/?)*" + "[\\p{Alnum}.,%_=?&#\\-+()\\[\\]\\*$~@!:/{};']*)",
+				Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
+		LinkedHashSet<CharSequence> urlSet = new LinkedHashSet<>();
+		Matcher matcher = urlPattern.matcher(text);
+		while (matcher.find()) {
+			int matchStart = matcher.start(1);
+			int matchEnd = matcher.end();
+			String url = text.substring(matchStart, matchEnd);
+			urlSet.add(url);
+		}
+
+		if (urlSet.isEmpty()) {
+			new AlertDialog.Builder(this).setMessage(R.string.select_url_no_found).show();
+			return;
+		}
+
+		final CharSequence[] urls = urlSet.toArray(new CharSequence[urlSet.size()]);
+		Collections.reverse(Arrays.asList(urls)); // Latest first.
+
+		// Click to copy url to clipboard:
+		final AlertDialog dialog = new AlertDialog.Builder(TermuxActivity.this).setItems(urls, new DialogInterface.OnClickListener() {
+			@Override
+			public void onClick(DialogInterface di, int which) {
+				String url = (String) urls[which];
+				ClipboardManager clipboard = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);
+				clipboard.setPrimaryClip(new ClipData(null, new String[] { "text/plain" }, new ClipData.Item(url)));
+				Toast.makeText(TermuxActivity.this, R.string.select_url_copied_to_clipboard, Toast.LENGTH_LONG).show();
+			}
+		}).setTitle(R.string.select_url_dialog_title).create();
+
+		// Long press to open URL:
+		dialog.setOnShowListener(new OnShowListener() {
+			@Override
+			public void onShow(DialogInterface di) {
+				ListView lv = dialog.getListView(); // this is a ListView with your "buds" in it
+				lv.setOnItemLongClickListener(new OnItemLongClickListener() {
+					@Override
+					public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {
+						dialog.dismiss();
+						String url = (String) urls[position];
+						startActivity(Intent.createChooser(new Intent(Intent.ACTION_VIEW, Uri.parse(url)), null));
+						return true;
+					}
+				});
+			}
+		});
+
+		dialog.show();
+	}
+
+	@Override
+	public boolean onContextItemSelected(MenuItem item) {
+		switch (item.getItemId()) {
+		case CONTEXTMENU_SELECT_ID:
+			CharSequence[] items = new CharSequence[] { getString(R.string.select_text), getString(R.string.select_url),
+					getString(R.string.select_all_and_share) };
+			new AlertDialog.Builder(this).setItems(items, new DialogInterface.OnClickListener() {
+				@Override
+				public void onClick(DialogInterface dialog, int which) {
+					switch (which) {
+					case 0:
+						mTerminalView.toggleSelectingText();
+						break;
+					case 1:
+						showUrlSelection();
+						break;
+					case 2:
+						TerminalSession session = getCurrentTermSession();
+						if (session != null) {
+							Intent intent = new Intent(Intent.ACTION_SEND);
+							intent.setType("text/plain");
+							intent.putExtra(Intent.EXTRA_TEXT, session.getEmulator().getScreen().getTranscriptText().trim());
+							intent.putExtra(Intent.EXTRA_SUBJECT, getString(R.string.share_transcript_title));
+							startActivity(Intent.createChooser(intent, getString(R.string.share_transcript_chooser_title)));
+						}
+						break;
+					}
+					dialog.dismiss();
+				}
+			}).show();
+			return true;
+		case CONTEXTMENU_PASTE_ID:
+			doPaste();
+			return true;
+		case CONTEXTMENU_KILL_PROCESS_ID:
+			final AlertDialog.Builder b = new AlertDialog.Builder(this);
+			b.setIcon(android.R.drawable.ic_dialog_alert);
+			b.setMessage(R.string.confirm_kill_process);
+			b.setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {
+				@Override
+				public void onClick(DialogInterface dialog, int id) {
+					dialog.dismiss();
+					getCurrentTermSession().finishIfRunning();
+				}
+			});
+			b.setNegativeButton(android.R.string.no, null);
+			b.show();
+			return true;
+		case CONTEXTMENU_RESET_TERMINAL_ID: {
+			TerminalSession session = getCurrentTermSession();
+			if (session != null) {
+				session.reset();
+				showToast(getResources().getString(R.string.reset_toast_notification), true);
+			}
+			return true;
+		}
+		case CONTEXTMENU_STYLING_ID: {
+			Intent stylingIntent = new Intent();
+			stylingIntent.setClassName("com.termux.styling", "com.termux.styling.TermuxStyleActivity");
+			try {
+				startActivity(stylingIntent);
+			} catch (ActivityNotFoundException e) {
+				new AlertDialog.Builder(this).setMessage(R.string.styling_not_installed)
+						.setPositiveButton(R.string.styling_install, new android.content.DialogInterface.OnClickListener() {
+							@Override
+							public void onClick(DialogInterface dialog, int which) {
+								startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("http://play.google.com/store/apps/details?id=com.termux.styling")));
+							}
+						}).setNegativeButton(android.R.string.cancel, null).show();
+			}
+		}
+			return true;
+		case CONTEXTMENU_TOGGLE_FULLSCREEN_ID:
+			toggleImmersive();
+			return true;
+		case CONTEXTMENU_HELP_ID:
+			startActivity(new Intent(this, TermuxHelpActivity.class));
+			return true;
+		default:
+			return super.onContextItemSelected(item);
+		}
+	}
+
+	void toggleImmersive() {
+		boolean newValue = !mSettings.isFullScreen();
+		mSettings.setFullScreen(this, newValue);
+		mFullScreenHelper.setImmersive(newValue);
+	}
+
+	void changeFontSize(boolean increase) {
+		mSettings.changeFontSize(this, increase);
+		mTerminalView.setTextSize(mSettings.getFontSize());
+	}
+
+	void doPaste() {
+		ClipboardManager clipboard = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);
+		ClipData clipData = clipboard.getPrimaryClip();
+		if (clipData == null) return;
+		CharSequence paste = clipData.getItemAt(0).coerceToText(this);
+		if (!TextUtils.isEmpty(paste)) getCurrentTermSession().getEmulator().paste(paste.toString());
+	}
+
+	/** The current session as stored or the last one if that does not exist. */
+	public TerminalSession getStoredCurrentSessionOrLast() {
+		TerminalSession stored = TermuxPreferences.getCurrentSession(this);
+		if (stored != null) return stored;
+		int numberOfSessions = mTermService.getSessions().size();
+		if (numberOfSessions == 0) return null;
+		return mTermService.getSessions().get(numberOfSessions - 1);
+	}
+
+	/** Show a toast and dismiss the last one if still visible. */
+	void showToast(String text, boolean longDuration) {
+		if (mLastToast != null) mLastToast.cancel();
+		mLastToast = Toast.makeText(TermuxActivity.this, text, longDuration ? Toast.LENGTH_LONG : Toast.LENGTH_SHORT);
+		mLastToast.setGravity(Gravity.TOP, 0, 0);
+		mLastToast.show();
+	}
+
+}

app/src/main/java/com/termux/app/TermuxHelpActivity.java

@@ -0,0 +1,46 @@
+package com.termux.app;
+
+import android.app.Activity;
+import android.content.ActivityNotFoundException;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+
+/** Basic embedded browser for viewing the bundled help page. */
+public final class TermuxHelpActivity extends Activity {
+
+	private WebView mWebView;
+
+	@Override
+	protected void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		mWebView = new WebView(this);
+		setContentView(mWebView);
+		mWebView.setWebViewClient(new WebViewClient() {
+			@Override
+			public boolean shouldOverrideUrlLoading(WebView view, String url) {
+				try {
+					startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse(url)).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK));
+				} catch (ActivityNotFoundException e) {
+					// TODO: Android TV does not have a system browser - but needs better method of getting back
+					// than navigating deep here.
+					return false;
+				}
+				return true;
+			}
+		});
+		mWebView.loadUrl("file:///android_asset/help.html");
+	}
+
+	@Override
+	public void onBackPressed() {
+		if (mWebView.canGoBack()) {
+			mWebView.goBack();
+		} else {
+			super.onBackPressed();
+		}
+	}
+
+}

app/src/main/java/com/termux/app/TermuxInstaller.java

@@ -0,0 +1,193 @@
+package com.termux.app;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStreamReader;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.ProgressDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.content.DialogInterface.OnDismissListener;
+import android.system.Os;
+import android.util.Log;
+import android.util.Pair;
+
+import com.termux.R;
+import com.termux.terminal.EmulatorDebug;
+
+/**
+ * Install the Termux bootstrap packages if necessary by following the below steps:
+ * 
+ * (1) If $PREFIX already exist, assume that it is correct and be done. Note that this relies on that we do not create a
+ * broken $PREFIX folder below.
+ * 
+ * (2) A progress dialog is shown with "Installing..." message and a spinner.
+ * 
+ * (3) A staging folder, $STAGING_PREFIX, is {@link #deleteFolder(File)} if left over from broken installation below.
+ * 
+ * (4) The architecture is determined and an appropriate bootstrap zip url is determined in {@link #determineZipUrl()}.
+ * 
+ * (5) The zip, containing entries relative to the $PREFIX, is is downloaded and extracted by a zip input stream
+ * continously encountering zip file entries:
+ * 
+ * (5.1) If the zip entry encountered is SYMLINKS.txt, go through it and remember all symlinks to setup.
+ * 
+ * (5.2) For every other zip entry, extract it into $STAGING_PREFIX and set execute permissions if necessary.
+ */
+final class TermuxInstaller {
+
+	/** Performs setup if necessary. */
+	static void setupIfNeeded(final Activity activity, final Runnable whenDone) {
+		// Termux can only be run as the primary user (device owner) since only that
+		// account has the expected file system paths. Verify that:
+		android.os.UserManager um = (android.os.UserManager) activity.getSystemService(Context.USER_SERVICE);
+		boolean isPrimaryUser = um.getSerialNumberForUser(android.os.Process.myUserHandle()) == 0;
+		if (!isPrimaryUser) {
+			new AlertDialog.Builder(activity).setTitle(R.string.bootstrap_error_title).setMessage(R.string.bootstrap_error_not_primary_user_message)
+					.setOnDismissListener(new OnDismissListener() {
+						@Override
+						public void onDismiss(DialogInterface dialog) {
+							System.exit(0);
+						}
+					}).setPositiveButton(android.R.string.ok, null).show();
+			return;
+		}
+
+		final File PREFIX_FILE = new File(TermuxService.PREFIX_PATH);
+		if (PREFIX_FILE.isDirectory()) {
+			whenDone.run();
+			return;
+		}
+
+		final ProgressDialog progress = ProgressDialog.show(activity, null, activity.getString(R.string.bootstrap_installer_body), true, false);
+		new Thread() {
+			@Override
+			public void run() {
+				try {
+					final String STAGING_PREFIX_PATH = TermuxService.FILES_PATH + "/usr-staging";
+					final File STAGING_PREFIX_FILE = new File(STAGING_PREFIX_PATH);
+
+					if (STAGING_PREFIX_FILE.exists()) {
+						deleteFolder(STAGING_PREFIX_FILE);
+					}
+
+					final byte[] buffer = new byte[8096];
+					final List<Pair<String, String>> symlinks = new ArrayList<>(50);
+
+					final URL zipUrl = determineZipUrl();
+					try (ZipInputStream zipInput = new ZipInputStream(zipUrl.openStream())) {
+						ZipEntry zipEntry;
+						while ((zipEntry = zipInput.getNextEntry()) != null) {
+							if (zipEntry.getName().equals("SYMLINKS.txt")) {
+								BufferedReader symlinksReader = new BufferedReader(new InputStreamReader(zipInput));
+								String line;
+								while ((line = symlinksReader.readLine()) != null) {
+									String[] parts = line.split("←");
+									if (parts.length != 2) throw new RuntimeException("Malformed symlink line: " + line);
+									String oldPath = parts[0];
+									String newPath = STAGING_PREFIX_PATH + "/" + parts[1];
+									symlinks.add(Pair.create(oldPath, newPath));
+								}
+							} else {
+								String zipEntryName = zipEntry.getName();
+								File targetFile = new File(STAGING_PREFIX_PATH, zipEntryName);
+								if (zipEntry.isDirectory()) {
+									if (!targetFile.mkdirs()) throw new RuntimeException("Failed to create directory: " + targetFile.getAbsolutePath());
+								} else {
+									try (FileOutputStream outStream = new FileOutputStream(targetFile)) {
+										int readBytes;
+										while ((readBytes = zipInput.read(buffer)) != -1)
+											outStream.write(buffer, 0, readBytes);
+									}
+									if (zipEntryName.startsWith("bin/") || zipEntryName.startsWith("libexec") || zipEntryName.startsWith("lib/apt/methods")) {
+										Os.chmod(targetFile.getAbsolutePath(), 0700);
+									}
+								}
+							}
+						}
+					}
+
+					if (symlinks.isEmpty()) throw new RuntimeException("No SYMLINKS.txt encountered");
+					for (Pair<String, String> symlink : symlinks) {
+						Os.symlink(symlink.first, symlink.second);
+					}
+
+					if (!STAGING_PREFIX_FILE.renameTo(PREFIX_FILE)) {
+						throw new RuntimeException("Unable to rename staging folder");
+					}
+
+					activity.runOnUiThread(new Runnable() {
+						@Override
+						public void run() {
+							whenDone.run();
+						}
+					});
+				} catch (final Exception e) {
+					Log.e(EmulatorDebug.LOG_TAG, "Bootstrap error", e);
+					activity.runOnUiThread(new Runnable() {
+						@Override
+						public void run() {
+							new AlertDialog.Builder(activity).setTitle(R.string.bootstrap_error_title).setMessage(R.string.bootstrap_error_body)
+									.setNegativeButton(R.string.bootstrap_error_abort, new OnClickListener() {
+								@Override
+								public void onClick(DialogInterface dialog, int which) {
+									dialog.dismiss();
+									activity.finish();
+								}
+							}).setPositiveButton(R.string.bootstrap_error_try_again, new OnClickListener() {
+								@Override
+								public void onClick(DialogInterface dialog, int which) {
+									dialog.dismiss();
+									TermuxInstaller.setupIfNeeded(activity, whenDone);
+								}
+							}).show();
+						}
+					});
+				} finally {
+					activity.runOnUiThread(new Runnable() {
+						@Override
+						public void run() {
+							progress.dismiss();
+						}
+					});
+				}
+			}
+		}.start();
+	}
+
+	/** Get bootstrap zip url for this systems cpu architecture. */
+	static URL determineZipUrl() throws MalformedURLException {
+		String arch = System.getProperty("os.arch");
+		if (arch.startsWith("arm") || arch.equals("aarch64")) {
+			// Handle different arm variants such as armv7l:
+			arch = "arm";
+		} else if (arch.equals("x86_64")) {
+			arch = "i686";
+		}
+		return new URL("http://apt.termux.com/bootstrap/bootstrap-" + arch + ".zip");
+	}
+
+	/** Delete a folder and all its content or throw. */
+	static void deleteFolder(File fileOrDirectory) {
+		File[] children = fileOrDirectory.listFiles();
+		if (children != null) {
+			for (File child : children) {
+				deleteFolder(child);
+			}
+		}
+		if (!fileOrDirectory.delete()) {
+			throw new RuntimeException("Unable to delete " + (fileOrDirectory.isDirectory() ? "directory " : "file ") + fileOrDirectory.getAbsolutePath());
+		}
+	}
+
+}

app/src/main/java/com/termux/app/TermuxPreferences.java

@@ -0,0 +1,89 @@
+package com.termux.app;
+
+import com.termux.terminal.TerminalSession;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.preference.PreferenceManager;
+import android.util.TypedValue;
+
+final class TermuxPreferences {
+
+	private final int MIN_FONTSIZE;
+	private static final int MAX_FONTSIZE = 256;
+	private static final String FULLSCREEN_KEY = "fullscreen";
+	private static final String FONTSIZE_KEY = "fontsize";
+	private static final String CURRENT_SESSION_KEY = "current_session";
+	private static final String SHOW_WELCOME_DIALOG_KEY = "intro_dialog";
+
+	private boolean mFullScreen;
+	private int mFontSize;
+
+	TermuxPreferences(Context context) {
+		SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
+
+		float dipInPixels = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 1, context.getResources().getDisplayMetrics());
+
+		// This is a bit arbitrary and sub-optimal. We want to give a sensible default for minimum font size
+		// to prevent invisible text due to zoom be mistake:
+		MIN_FONTSIZE = (int) (4f * dipInPixels);
+
+		mFullScreen = prefs.getBoolean(FULLSCREEN_KEY, false);
+
+		// http://www.google.com/design/spec/style/typography.html#typography-line-height
+		int defaultFontSize = Math.round(12 * dipInPixels);
+		// Make it divisible by 2 since that is the minimal adjustment step:
+		if (defaultFontSize % 2 == 1) defaultFontSize--;
+
+		try {
+			mFontSize = Integer.parseInt(prefs.getString(FONTSIZE_KEY, Integer.toString(defaultFontSize)));
+		} catch (NumberFormatException | ClassCastException e) {
+			mFontSize = defaultFontSize;
+		}
+		mFontSize = Math.max(MIN_FONTSIZE, Math.min(mFontSize, MAX_FONTSIZE));
+	}
+
+	boolean isFullScreen() {
+		return mFullScreen;
+	}
+
+	void setFullScreen(Context context, boolean newValue) {
+		mFullScreen = newValue;
+		SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
+		prefs.edit().putBoolean(FULLSCREEN_KEY, newValue).apply();
+	}
+
+	int getFontSize() {
+		return mFontSize;
+	}
+
+	void changeFontSize(Context context, boolean increase) {
+		mFontSize += (increase ? 1 : -1) * 2;
+		mFontSize = Math.max(MIN_FONTSIZE, Math.min(mFontSize, MAX_FONTSIZE));
+
+		SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
+		prefs.edit().putString(FONTSIZE_KEY, Integer.toString(mFontSize)).apply();
+	}
+
+	static void storeCurrentSession(Context context, TerminalSession session) {
+		PreferenceManager.getDefaultSharedPreferences(context).edit().putString(TermuxPreferences.CURRENT_SESSION_KEY, session.mHandle).commit();
+	}
+
+	static TerminalSession getCurrentSession(TermuxActivity context) {
+		String sessionHandle = PreferenceManager.getDefaultSharedPreferences(context).getString(TermuxPreferences.CURRENT_SESSION_KEY, "");
+		for (int i = 0, len = context.mTermService.getSessions().size(); i < len; i++) {
+			TerminalSession session = context.mTermService.getSessions().get(i);
+			if (session.mHandle.equals(sessionHandle)) return session;
+		}
+		return null;
+	}
+
+	public static boolean isShowWelcomeDialog(Context context) {
+		return PreferenceManager.getDefaultSharedPreferences(context).getBoolean(SHOW_WELCOME_DIALOG_KEY, true);
+	}
+
+	public static void disableWelcomeDialog(Context context) {
+		PreferenceManager.getDefaultSharedPreferences(context).edit().putBoolean(SHOW_WELCOME_DIALOG_KEY, false).apply();
+	}
+
+}

app/src/main/java/com/termux/app/TermuxService.java

@@ -0,0 +1,346 @@
+package com.termux.app;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.termux.R;
+import com.termux.terminal.EmulatorDebug;
+import com.termux.terminal.TerminalSession;
+import com.termux.terminal.TerminalSession.SessionChangedCallback;
+
+import android.annotation.SuppressLint;
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.content.res.Resources;
+import android.net.Uri;
+import android.net.wifi.WifiManager;
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.PowerManager;
+import android.util.Log;
+import android.widget.ArrayAdapter;
+
+/**
+ * A service holding a list of terminal sessions, {@link #mTerminalSessions}, showing a foreground notification while
+ * running so that it is not terminated. The user interacts with the session through {@link TermuxActivity}, but this
+ * service may outlive the activity when the user or the system disposes of the activity. In that case the user may
+ * restart {@link TermuxActivity} later to yet again access the sessions.
+ * 
+ * In order to keep both terminal sessions and spawned processes (who may outlive the terminal sessions) alive as long
+ * as wanted by the user this service is a foreground service, {@link Service#startForeground(int, Notification)}.
+ * 
+ * Optionally may hold a wake and a wifi lock, in which case that is shown in the notification - see
+ * {@link #buildNotification()}.
+ */
+public final class TermuxService extends Service implements SessionChangedCallback {
+
+	/** Note that this is a symlink on the Android M preview. */
+	@SuppressLint("SdCardPath")
+	public static final String FILES_PATH = "/data/data/com.termux/files";
+	public static final String PREFIX_PATH = FILES_PATH + "/usr";
+	public static final String HOME_PATH = FILES_PATH + "/home";
+
+	private static final int NOTIFICATION_ID = 1337;
+
+	/** Intent action to stop the service. */
+	private static final String ACTION_STOP_SERVICE = "com.termux.service_stop";
+	/** Intent action to toggle the wake lock, {@link #mWakeLock}, which this service may hold. */
+	private static final String ACTION_LOCK_WAKE = "com.termux.service_toggle_wake_lock";
+	/** Intent action to toggle the wifi lock, {@link #mWifiLock}, which this service may hold. */
+	private static final String ACTION_LOCK_WIFI = "com.termux.service_toggle_wifi_lock";
+	/** Intent action to launch a new terminal session. Executed from TermuxWidgetProvider. */
+	private static final String ACTION_EXECUTE = "com.termux.service_execute";
+
+	/** This service is only bound from inside the same process and never uses IPC. */
+	class LocalBinder extends Binder {
+		public final TermuxService service = TermuxService.this;
+	}
+
+	private final IBinder mBinder = new LocalBinder();
+
+	/**
+	 * The terminal sessions which this service manages.
+	 *
+	 * Note that this list is observed by {@link TermuxActivity#mListViewAdapter}, so any changes must be made on the UI
+	 * thread and followed by a call to {@link ArrayAdapter#notifyDataSetChanged()} }.
+	 */
+	final List<TerminalSession> mTerminalSessions = new ArrayList<>();
+
+	/** Note that the service may often outlive the activity, so need to clear this reference. */
+	SessionChangedCallback mSessionChangeCallback;
+
+	private PowerManager.WakeLock mWakeLock;
+	private WifiManager.WifiLock mWifiLock;
+
+	/** If the user has executed the {@link #ACTION_STOP_SERVICE} intent. */
+	boolean mWantsToStop = false;
+
+	@SuppressLint("Wakelock")
+	@Override
+	public int onStartCommand(Intent intent, int flags, int startId) {
+		String action = intent.getAction();
+		if (ACTION_STOP_SERVICE.equals(action)) {
+			mWantsToStop = true;
+			for (int i = 0; i < mTerminalSessions.size(); i++)
+				mTerminalSessions.get(i).finishIfRunning();
+			stopSelf();
+		} else if (ACTION_LOCK_WAKE.equals(action)) {
+			if (mWakeLock == null) {
+				PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
+				mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, EmulatorDebug.LOG_TAG);
+				mWakeLock.acquire();
+			} else {
+				mWakeLock.release();
+				mWakeLock = null;
+			}
+			updateNotification();
+		} else if (ACTION_LOCK_WIFI.equals(action)) {
+			if (mWifiLock == null) {
+				WifiManager wm = (WifiManager) getSystemService(Context.WIFI_SERVICE);
+				mWifiLock = wm.createWifiLock(WifiManager.WIFI_MODE_FULL_HIGH_PERF, EmulatorDebug.LOG_TAG);
+				mWifiLock.acquire();
+			} else {
+				mWifiLock.release();
+				mWifiLock = null;
+			}
+			updateNotification();
+		} else if (ACTION_EXECUTE.equals(action)) {
+			Uri executableUri = intent.getData();
+			String executablePath = (executableUri == null ? null : executableUri.getPath());
+			String[] arguments = (executableUri == null ? null : intent.getStringArrayExtra("com.termux.execute.arguments"));
+			String cwd = intent.getStringExtra("com.termux.execute.cwd");
+			TerminalSession newSession = createTermSession(executablePath, arguments, cwd, false);
+
+			// Transform executable path to session name, e.g. "/bin/do-something.sh" => "do something.sh".
+			if (executablePath != null) {
+				int lastSlash = executablePath.lastIndexOf('/');
+				String name = (lastSlash == -1) ? executablePath : executablePath.substring(lastSlash + 1);
+				name = name.replace('-', ' ');
+				newSession.mSessionName = name;
+			}
+
+			// Make the newly created session the current one to be displayed:
+			TermuxPreferences.storeCurrentSession(this, newSession);
+
+			// Launch the main Termux app, which will now show to current session:
+			startActivity(new Intent(this, TermuxActivity.class).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK));
+		} else if (action != null) {
+			Log.e(EmulatorDebug.LOG_TAG, "Unknown TermuxService action: '" + action + "'");
+		}
+
+		// If this service really do get killed, there is no point restarting it automatically - let the user do on next
+		// start of {@link Term):
+		return Service.START_NOT_STICKY;
+	}
+
+	@Override
+	public IBinder onBind(Intent intent) {
+		return mBinder;
+	}
+
+	@Override
+	public void onCreate() {
+		startForeground(NOTIFICATION_ID, buildNotification());
+	}
+
+	/** Update the shown foreground service notification after making any changes that affect it. */
+	private void updateNotification() {
+		if (mWakeLock == null && mWifiLock == null && getSessions().isEmpty()) {
+			// Exit if we are updating after the user disabled all locks with no sessions.
+			stopSelf();
+		} else {
+			((NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE)).notify(NOTIFICATION_ID, buildNotification());
+		}
+	}
+
+	private Notification buildNotification() {
+		Intent notifyIntent = new Intent(this, TermuxActivity.class);
+		// PendingIntent#getActivity(): "Note that the activity will be started outside of the context of an existing
+		// activity, so you must use the Intent.FLAG_ACTIVITY_NEW_TASK launch flag in the Intent":
+		notifyIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+		PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notifyIntent, 0);
+
+		int sessionCount = mTerminalSessions.size();
+		String contentText = sessionCount + " terminal session" + (sessionCount == 1 ? "" : "s");
+
+		boolean wakeLockHeld = mWakeLock != null;
+		boolean wifiLockHeld = mWifiLock != null;
+		if (wakeLockHeld && wifiLockHeld) {
+			contentText += " (wake&wifi lock held)";
+		} else if (wakeLockHeld) {
+			contentText += " (wake lock held)";
+		} else if (wifiLockHeld) {
+			contentText += " (wifi lock held)";
+		}
+
+		Notification.Builder builder = new Notification.Builder(this);
+		builder.setContentTitle(getText(R.string.application_name));
+		builder.setContentText(contentText);
+		builder.setSmallIcon(R.drawable.ic_service_notification);
+		builder.setContentIntent(pendingIntent);
+		builder.setOngoing(true);
+
+		// If holding a wake or wifi lock consider the notification of high priority since it's using power,
+		// otherwise use a minimal priority since this is just a background service notification:
+		builder.setPriority((wakeLockHeld || wifiLockHeld) ? Notification.PRIORITY_HIGH : Notification.PRIORITY_MIN);
+
+		// No need to show a timestamp:
+		builder.setShowWhen(false);
+
+		// Background color for small notification icon:
+		builder.setColor(0xFF000000);
+
+		Resources res = getResources();
+		Intent exitIntent = new Intent(this, TermuxService.class).setAction(ACTION_STOP_SERVICE);
+		builder.addAction(android.R.drawable.ic_delete, res.getString(R.string.notification_action_exit), PendingIntent.getService(this, 0, exitIntent, 0));
+
+		Intent toggleWakeLockIntent = new Intent(this, TermuxService.class).setAction(ACTION_LOCK_WAKE);
+		builder.addAction(android.R.drawable.ic_lock_lock, res.getString(R.string.notification_action_wakelock),
+				PendingIntent.getService(this, 0, toggleWakeLockIntent, 0));
+
+		Intent toggleWifiLockIntent = new Intent(this, TermuxService.class).setAction(ACTION_LOCK_WIFI);
+		builder.addAction(android.R.drawable.ic_lock_lock, res.getString(R.string.notification_action_wifilock),
+				PendingIntent.getService(this, 0, toggleWifiLockIntent, 0));
+
+		return builder.build();
+	}
+
+	@Override
+	public void onDestroy() {
+		if (mWakeLock != null) mWakeLock.release();
+		if (mWifiLock != null) mWifiLock.release();
+
+		stopForeground(true);
+
+		for (int i = 0; i < mTerminalSessions.size(); i++)
+			mTerminalSessions.get(i).finishIfRunning();
+		mTerminalSessions.clear();
+	}
+
+	public List<TerminalSession> getSessions() {
+		return mTerminalSessions;
+	}
+
+	TerminalSession createTermSession(String executablePath, String[] arguments, String cwd, boolean failSafe) {
+		new File(HOME_PATH).mkdirs();
+
+		if (cwd == null) cwd = HOME_PATH;
+
+		final String termEnv = "TERM=xterm-256color";
+		final String homeEnv = "HOME=" + HOME_PATH;
+		final String prefixEnv = "PREFIX=" + PREFIX_PATH;
+		final String androidRootEnv = "ANDROID_ROOT=" + System.getenv("ANDROID_ROOT");
+		final String androidDataEnv = "ANDROID_DATA=" + System.getenv("ANDROID_DATA");
+		String[] env;
+		if (failSafe) {
+			env = new String[] { termEnv, homeEnv, prefixEnv, androidRootEnv, androidDataEnv };
+		} else {
+			final String ps1Env = "PS1=$ ";
+			final String ldEnv = "LD_LIBRARY_PATH=" + PREFIX_PATH + "/lib";
+			final String langEnv = "LANG=en_US.UTF-8";
+			final String pathEnv = "PATH=" + PREFIX_PATH + "/bin:" + PREFIX_PATH + "/bin/applets:" + System.getenv("PATH");
+			final String pwdEnv = "PWD=" + cwd;
+
+			env = new String[] { termEnv, homeEnv, prefixEnv, ps1Env, ldEnv, langEnv, pathEnv, pwdEnv, androidRootEnv, androidDataEnv };
+		}
+
+		String shellName;
+		if (executablePath == null) {
+			File shell = new File(HOME_PATH, ".termux/shell");
+			if (shell.exists()) {
+				try {
+					File canonicalFile = shell.getCanonicalFile();
+					if (canonicalFile.isFile() && canonicalFile.canExecute()) {
+						executablePath = canonicalFile.getName().equals("busybox") ? (PREFIX_PATH + "/bin/ash") : canonicalFile.getAbsolutePath();
+					} else {
+						Log.w(EmulatorDebug.LOG_TAG, "$HOME/.termux/shell points to non-executable shell: " + canonicalFile.getAbsolutePath());
+					}
+				} catch (IOException e) {
+					Log.e(EmulatorDebug.LOG_TAG, "Error checking $HOME/.termux/shell", e);
+				}
+			}
+
+			if (executablePath == null) {
+				// Try bash, zsh and ash in that order:
+				for (String shellBinary : new String[] { "bash", "zsh", "ash" }) {
+					File shellFile = new File(PREFIX_PATH + "/bin/" + shellBinary);
+					if (shellFile.canExecute()) {
+						executablePath = shellFile.getAbsolutePath();
+						break;
+					}
+				}
+			}
+
+			if (executablePath == null) {
+				// Fall back to system shell as last resort:
+				executablePath = "/system/bin/sh";
+			}
+
+			String[] parts = executablePath.split("/");
+			shellName = "-" + parts[parts.length - 1];
+		} else {
+			int lastSlashIndex = executablePath.lastIndexOf('/');
+			shellName = lastSlashIndex == -1 ? executablePath : executablePath.substring(lastSlashIndex + 1);
+		}
+
+		String[] args;
+		if (arguments == null) {
+			args = new String[] { shellName };
+		} else {
+			args = new String[arguments.length + 1];
+			args[0] = shellName;
+
+			System.arraycopy(arguments, 0, args, 1, arguments.length);
+		}
+
+		TerminalSession session = new TerminalSession(executablePath, cwd, args, env, this);
+		mTerminalSessions.add(session);
+		updateNotification();
+		return session;
+	}
+
+	public int removeTermSession(TerminalSession sessionToRemove) {
+		int indexOfRemoved = mTerminalSessions.indexOf(sessionToRemove);
+		mTerminalSessions.remove(indexOfRemoved);
+		if (mTerminalSessions.isEmpty() && mWakeLock == null) {
+			// Finish if there are no sessions left and the wake lock is not held, otherwise keep the service alive if
+			// holding wake lock since there may be daemon processes (e.g. sshd) running.
+			stopSelf();
+		} else {
+			updateNotification();
+		}
+		return indexOfRemoved;
+	}
+
+	@Override
+	public void onTitleChanged(TerminalSession changedSession) {
+		if (mSessionChangeCallback != null) mSessionChangeCallback.onTitleChanged(changedSession);
+	}
+
+	@Override
+	public void onSessionFinished(final TerminalSession finishedSession) {
+		if (mSessionChangeCallback != null) mSessionChangeCallback.onSessionFinished(finishedSession);
+	}
+
+	@Override
+	public void onTextChanged(TerminalSession changedSession) {
+		if (mSessionChangeCallback != null) mSessionChangeCallback.onTextChanged(changedSession);
+	}
+
+	@Override
+	public void onClipboardText(TerminalSession session, String text) {
+		if (mSessionChangeCallback != null) mSessionChangeCallback.onClipboardText(session, text);
+	}
+
+	@Override
+	public void onBell(TerminalSession session) {
+		if (mSessionChangeCallback != null) mSessionChangeCallback.onBell(session);
+	}
+
+}

app/src/main/java/com/termux/drawer/DrawerLayoutCompatApi21.java

@@ -0,0 +1,88 @@
+package com.termux.drawer;
+
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.WindowInsets;
+
+/**
+ * Provides functionality for DrawerLayout unique to API 21
+ */
+@SuppressLint("RtlHardcoded")
+@TargetApi(Build.VERSION_CODES.LOLLIPOP)
+class DrawerLayoutCompatApi21 {
+
+	private static final int[] THEME_ATTRS = { android.R.attr.colorPrimaryDark };
+
+	public static void configureApplyInsets(DrawerLayout drawerLayout) {
+		drawerLayout.setOnApplyWindowInsetsListener(new InsetsListener());
+		drawerLayout.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
+	}
+
+	public static void dispatchChildInsets(View child, Object insets, int gravity) {
+		WindowInsets wi = (WindowInsets) insets;
+		if (gravity == Gravity.LEFT) {
+			wi = wi.replaceSystemWindowInsets(wi.getSystemWindowInsetLeft(), wi.getSystemWindowInsetTop(), 0, wi.getSystemWindowInsetBottom());
+		} else if (gravity == Gravity.RIGHT) {
+			wi = wi.replaceSystemWindowInsets(0, wi.getSystemWindowInsetTop(), wi.getSystemWindowInsetRight(), wi.getSystemWindowInsetBottom());
+		}
+		child.dispatchApplyWindowInsets(wi);
+	}
+
+	public static void applyMarginInsets(ViewGroup.MarginLayoutParams lp, Object insets, int gravity) {
+		WindowInsets wi = (WindowInsets) insets;
+		if (gravity == Gravity.LEFT) {
+			wi = wi.replaceSystemWindowInsets(wi.getSystemWindowInsetLeft(), wi.getSystemWindowInsetTop(), 0, wi.getSystemWindowInsetBottom());
+		} else if (gravity == Gravity.RIGHT) {
+			wi = wi.replaceSystemWindowInsets(0, wi.getSystemWindowInsetTop(), wi.getSystemWindowInsetRight(), wi.getSystemWindowInsetBottom());
+		}
+		lp.leftMargin = wi.getSystemWindowInsetLeft();
+		lp.topMargin = wi.getSystemWindowInsetTop();
+		lp.rightMargin = wi.getSystemWindowInsetRight();
+		lp.bottomMargin = wi.getSystemWindowInsetBottom();
+	}
+
+	public static int getTopInset(Object insets) {
+		return insets != null ? ((WindowInsets) insets).getSystemWindowInsetTop() : 0;
+	}
+
+	public static Drawable getDefaultStatusBarBackground(Context context) {
+		final TypedArray a = context.obtainStyledAttributes(THEME_ATTRS);
+		try {
+			return a.getDrawable(0);
+		} finally {
+			a.recycle();
+		}
+	}
+
+	static class InsetsListener implements View.OnApplyWindowInsetsListener {
+		@Override
+		public WindowInsets onApplyWindowInsets(View v, WindowInsets insets) {
+			final DrawerLayout drawerLayout = (DrawerLayout) v;
+			drawerLayout.setChildInsets(insets, insets.getSystemWindowInsetTop() > 0);
+			return insets.consumeSystemWindowInsets();
+		}
+	}
+}

app/src/main/java/com/termux/drawer/package-info.java

@@ -0,0 +1,10 @@
+/**
+ * Extraction (and some minor cleanup to get rid of warnings) of DrawerLayout from the
+ * <a href="http://developer.android.com/tools/support-library/index.html">Android Support Library</a>.
+ * 
+ * Source at:
+ * https://android.googlesource.com/platform/frameworks/support/+/refs/heads/master/v4/java/android/support/v4/widget/DrawerLayout.java
+ * https://android.googlesource.com/platform/frameworks/support/+/refs/heads/master/v4/java/android/support/v4/widget/ViewDragHelper.java
+ */
+package com.termux.drawer;
+

app/src/main/java/com/termux/terminal/ByteQueue.java

@@ -0,0 +1,108 @@
+package com.termux.terminal;
+
+/** A circular byte buffer allowing one producer and one consumer thread. */
+final class ByteQueue {
+
+	private final byte[] mBuffer;
+	private int mHead;
+	private int mStoredBytes;
+	private boolean mOpen = true;
+
+	public ByteQueue(int size) {
+		mBuffer = new byte[size];
+	}
+
+	public synchronized void close() {
+		mOpen = false;
+		notify();
+	}
+
+	public synchronized int read(byte[] buffer, boolean block) {
+		while (mStoredBytes == 0 && mOpen) {
+			if (block) {
+				try {
+					wait();
+				} catch (InterruptedException e) {
+					// Ignore.
+				}
+			} else {
+				return 0;
+			}
+		}
+		if (!mOpen) return -1;
+
+		int totalRead = 0;
+		int bufferLength = mBuffer.length;
+		boolean wasFull = bufferLength == mStoredBytes;
+		int length = buffer.length;
+		int offset = 0;
+		while (length > 0 && mStoredBytes > 0) {
+			int oneRun = Math.min(bufferLength - mHead, mStoredBytes);
+			int bytesToCopy = Math.min(length, oneRun);
+			System.arraycopy(mBuffer, mHead, buffer, offset, bytesToCopy);
+			mHead += bytesToCopy;
+			if (mHead >= bufferLength) mHead = 0;
+			mStoredBytes -= bytesToCopy;
+			length -= bytesToCopy;
+			offset += bytesToCopy;
+			totalRead += bytesToCopy;
+		}
+		if (wasFull) notify();
+		return totalRead;
+	}
+
+	/**
+	 * Attempt to write the specified portion of the provided buffer to the queue.
+	 * 
+	 * Returns whether the output was totally written, false if it was closed before.
+	 */
+	public boolean write(byte[] buffer, int offset, int lengthToWrite) {
+		if (lengthToWrite + offset > buffer.length) {
+			throw new IllegalArgumentException("length + offset > buffer.length");
+		} else if (lengthToWrite <= 0) {
+			throw new IllegalArgumentException("length <= 0");
+		}
+
+		final int bufferLength = mBuffer.length;
+
+		synchronized (this) {
+			while (lengthToWrite > 0) {
+				while (bufferLength == mStoredBytes && mOpen) {
+					try {
+						wait();
+					} catch (InterruptedException e) {
+						// Ignore.
+					}
+				}
+				if (!mOpen) return false;
+				final boolean wasEmpty = mStoredBytes == 0;
+				int bytesToWriteBeforeWaiting = Math.min(lengthToWrite, bufferLength - mStoredBytes);
+				lengthToWrite -= bytesToWriteBeforeWaiting;
+
+				while (bytesToWriteBeforeWaiting > 0) {
+					int tail = mHead + mStoredBytes;
+					int oneRun;
+					if (tail >= bufferLength) {
+						// Buffer: [.............]
+						// ________________H_______T
+						// =>
+						// Buffer: [.............]
+						// ___________T____H
+						// onRun= _____----_
+						tail = tail - bufferLength;
+						oneRun = mHead - tail;
+					} else {
+						oneRun = bufferLength - tail;
+					}
+					int bytesToCopy = Math.min(oneRun, bytesToWriteBeforeWaiting);
+					System.arraycopy(buffer, offset, mBuffer, tail, bytesToCopy);
+					offset += bytesToCopy;
+					bytesToWriteBeforeWaiting -= bytesToCopy;
+					mStoredBytes += bytesToCopy;
+				}
+				if (wasEmpty) notify();
+			}
+		}
+		return true;
+	}
+}

app/src/main/java/com/termux/terminal/EmulatorDebug.java

@@ -0,0 +1,10 @@
+package com.termux.terminal;
+
+import android.util.Log;
+
+public final class EmulatorDebug {
+
+	/** The tag to use with {@link Log}. */
+	public static final String LOG_TAG = "termux";
+
+}

app/src/main/java/com/termux/terminal/JNI.java

@@ -0,0 +1,55 @@
+package com.termux.terminal;
+
+/**
+ * Native methods for creating and managing pseudoterminal subprocesses. C code is in jni/termux.c.
+ */
+final class JNI {
+
+	static {
+		System.loadLibrary("termux");
+	}
+
+	/**
+	 * Create a subprocess. Differs from {@link ProcessBuilder} in that a pseudoterminal is used to communicate with the
+	 * subprocess.
+	 * 
+	 * Callers are responsible for calling {@link #close(int)} on the returned file descriptor.
+	 * 
+	 * @param cmd
+	 *            The command to execute
+	 * @param cwd
+	 *            The current working directory for the executed command
+	 * @param args
+	 *            An array of arguments to the command
+	 * @param envVars
+	 *            An array of strings of the form "VAR=value" to be added to the environment of the process
+	 * @param processId
+	 *            A one-element array to which the process ID of the started process will be written.
+	 * @return the file descriptor resulting from opening /dev/ptmx master device. The sub process will have opened the
+	 *         slave device counterpart (/dev/pts/$N) and have it as stdint, stdout and stderr.
+	 */
+	public static native int createSubprocess(String cmd, String cwd, String[] args, String[] envVars, int[] processId);
+
+	/** Set the window size for a given pty, which allows connected programs to learn how large their screen is. */
+	public static native void setPtyWindowSize(int fd, int rows, int cols);
+
+	/**
+	 * Causes the calling thread to wait for the process associated with the receiver to finish executing.
+	 * 
+	 * @return if >= 0, the exit status of the process. If < 0, the signal causing the process to stop negated.
+	 */
+	public static native int waitFor(int processId);
+
+	/**
+	 * Send SIGHUP to a process group.
+	 * 
+	 * There exists a kill(2) system call wrapper in {@link android.os.Process#sendSignal(int, int)}, but that makes a
+	 * "if (pid > 0)" check so cannot be used for sending to a process group:
+	 * https://android.googlesource.com/platform/frameworks/base/+/donut-release/core/jni/android_util_Process.cpp
+	 */
+	public static native void hangupProcessGroup(int processId);
+
+	/** Close a file descriptor through the close(2) system call. */
+	public static native void close(int fileDescriptor);
+
+}

app/src/main/java/com/termux/terminal/KeyHandler.java

@@ -0,0 +1,310 @@
+package com.termux.terminal;
+
+import static android.view.KeyEvent.KEYCODE_BREAK;
+import static android.view.KeyEvent.KEYCODE_DEL;
+import static android.view.KeyEvent.KEYCODE_DPAD_CENTER;
+import static android.view.KeyEvent.KEYCODE_DPAD_DOWN;
+import static android.view.KeyEvent.KEYCODE_DPAD_LEFT;
+import static android.view.KeyEvent.KEYCODE_DPAD_RIGHT;
+import static android.view.KeyEvent.KEYCODE_DPAD_UP;
+import static android.view.KeyEvent.KEYCODE_ENTER;
+import static android.view.KeyEvent.KEYCODE_ESCAPE;
+import static android.view.KeyEvent.KEYCODE_F1;
+import static android.view.KeyEvent.KEYCODE_F10;
+import static android.view.KeyEvent.KEYCODE_F11;
+import static android.view.KeyEvent.KEYCODE_F12;
+import static android.view.KeyEvent.KEYCODE_F2;
+import static android.view.KeyEvent.KEYCODE_F3;
+import static android.view.KeyEvent.KEYCODE_F4;
+import static android.view.KeyEvent.KEYCODE_F5;
+import static android.view.KeyEvent.KEYCODE_F6;
+import static android.view.KeyEvent.KEYCODE_F7;
+import static android.view.KeyEvent.KEYCODE_F8;
+import static android.view.KeyEvent.KEYCODE_F9;
+import static android.view.KeyEvent.KEYCODE_FORWARD_DEL;
+import static android.view.KeyEvent.KEYCODE_INSERT;
+import static android.view.KeyEvent.KEYCODE_MOVE_END;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_0;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_1;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_2;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_3;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_4;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_5;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_6;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_7;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_8;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_9;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_ADD;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_COMMA;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_DIVIDE;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_DOT;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_ENTER;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_EQUALS;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_MULTIPLY;
+import static android.view.KeyEvent.KEYCODE_NUMPAD_SUBTRACT;
+import static android.view.KeyEvent.KEYCODE_NUM_LOCK;
+import static android.view.KeyEvent.KEYCODE_PAGE_DOWN;
+import static android.view.KeyEvent.KEYCODE_PAGE_UP;
+import static android.view.KeyEvent.KEYCODE_SYSRQ;
+import static android.view.KeyEvent.KEYCODE_TAB;
+import static android.view.KeyEvent.KEYCODE_HOME;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import android.view.KeyEvent;
+
+public final class KeyHandler {
+
+	public static final int KEYMOD_ALT = 0x80000000;
+	public static final int KEYMOD_CTRL = 0x40000000;
+	public static final int KEYMOD_SHIFT = 0x20000000;
+
+	private static final Map<String, Integer> TERMCAP_TO_KEYCODE = new HashMap<>();
+	static {
+		// terminfo: http://pubs.opengroup.org/onlinepubs/7990989799/xcurses/terminfo.html
+		// termcap: http://man7.org/linux/man-pages/man5/termcap.5.html
+		TERMCAP_TO_KEYCODE.put("%i", KEYMOD_SHIFT | KEYCODE_DPAD_RIGHT);
+		TERMCAP_TO_KEYCODE.put("#2", KEYMOD_SHIFT | KEYCODE_HOME); // Shifted home
+		TERMCAP_TO_KEYCODE.put("#4", KEYMOD_SHIFT | KEYCODE_DPAD_LEFT);
+		TERMCAP_TO_KEYCODE.put("*7", KEYMOD_SHIFT | KEYCODE_MOVE_END); // Shifted end key
+
+		TERMCAP_TO_KEYCODE.put("k1", KEYCODE_F1);
+		TERMCAP_TO_KEYCODE.put("k2", KEYCODE_F2);
+		TERMCAP_TO_KEYCODE.put("k3", KEYCODE_F3);
+		TERMCAP_TO_KEYCODE.put("k4", KEYCODE_F4);
+		TERMCAP_TO_KEYCODE.put("k5", KEYCODE_F5);
+		TERMCAP_TO_KEYCODE.put("k6", KEYCODE_F6);
+		TERMCAP_TO_KEYCODE.put("k7", KEYCODE_F7);
+		TERMCAP_TO_KEYCODE.put("k8", KEYCODE_F8);
+		TERMCAP_TO_KEYCODE.put("k9", KEYCODE_F9);
+		TERMCAP_TO_KEYCODE.put("k;", KEYCODE_F10);
+		TERMCAP_TO_KEYCODE.put("F1", KEYCODE_F11);
+		TERMCAP_TO_KEYCODE.put("F2", KEYCODE_F12);
+		TERMCAP_TO_KEYCODE.put("F3", KEYMOD_SHIFT | KEYCODE_F1);
+		TERMCAP_TO_KEYCODE.put("F4", KEYMOD_SHIFT | KEYCODE_F2);
+		TERMCAP_TO_KEYCODE.put("F5", KEYMOD_SHIFT | KEYCODE_F3);
+		TERMCAP_TO_KEYCODE.put("F6", KEYMOD_SHIFT | KEYCODE_F4);
+		TERMCAP_TO_KEYCODE.put("F7", KEYMOD_SHIFT | KEYCODE_F5);
+		TERMCAP_TO_KEYCODE.put("F8", KEYMOD_SHIFT | KEYCODE_F6);
+		TERMCAP_TO_KEYCODE.put("F9", KEYMOD_SHIFT | KEYCODE_F7);
+		TERMCAP_TO_KEYCODE.put("FA", KEYMOD_SHIFT | KEYCODE_F8);
+		TERMCAP_TO_KEYCODE.put("FB", KEYMOD_SHIFT | KEYCODE_F9);
+		TERMCAP_TO_KEYCODE.put("FC", KEYMOD_SHIFT | KEYCODE_F10);
+		TERMCAP_TO_KEYCODE.put("FD", KEYMOD_SHIFT | KEYCODE_F11);
+		TERMCAP_TO_KEYCODE.put("FE", KEYMOD_SHIFT | KEYCODE_F12);
+
+		TERMCAP_TO_KEYCODE.put("kb", KEYCODE_DEL); // backspace key
+
+		TERMCAP_TO_KEYCODE.put("kd", KEYCODE_DPAD_DOWN); // terminfo=kcud1, down-arrow key
+		TERMCAP_TO_KEYCODE.put("kh", KeyEvent.KEYCODE_HOME);
+		TERMCAP_TO_KEYCODE.put("kl", KEYCODE_DPAD_LEFT);
+		TERMCAP_TO_KEYCODE.put("kr", KEYCODE_DPAD_RIGHT);
+
+		// K1=Upper left of keypad:
+		// t_K1 <kHome> keypad home key
+		// t_K3 <kPageUp> keypad page-up key
+		// t_K4 <kEnd> keypad end key
+		// t_K5 <kPageDown> keypad page-down key
+		TERMCAP_TO_KEYCODE.put("K1", KeyEvent.KEYCODE_HOME);
+		TERMCAP_TO_KEYCODE.put("K3", KeyEvent.KEYCODE_PAGE_UP);
+		TERMCAP_TO_KEYCODE.put("K4", KeyEvent.KEYCODE_MOVE_END);
+		TERMCAP_TO_KEYCODE.put("K5", KeyEvent.KEYCODE_PAGE_DOWN);
+
+		TERMCAP_TO_KEYCODE.put("ku", KEYCODE_DPAD_UP);
+
+		TERMCAP_TO_KEYCODE.put("kB", KEYMOD_SHIFT | KEYCODE_TAB); // termcap=kB, terminfo=kcbt: Back-tab
+		TERMCAP_TO_KEYCODE.put("kD", KEYCODE_FORWARD_DEL); // terminfo=kdch1, delete-character key
+		TERMCAP_TO_KEYCODE.put("kDN", KEYMOD_SHIFT | KEYCODE_DPAD_DOWN); // non-standard shifted arrow down
+		TERMCAP_TO_KEYCODE.put("kF", KEYMOD_SHIFT | KEYCODE_DPAD_DOWN); // terminfo=kind, scroll-forward key
+		TERMCAP_TO_KEYCODE.put("kI", KEYCODE_INSERT);
+		TERMCAP_TO_KEYCODE.put("kN", KEYCODE_PAGE_UP);
+		TERMCAP_TO_KEYCODE.put("kP", KEYCODE_PAGE_DOWN);
+		TERMCAP_TO_KEYCODE.put("kR", KEYMOD_SHIFT | KEYCODE_DPAD_UP); // terminfo=kri, scroll-backward key
+		TERMCAP_TO_KEYCODE.put("kUP", KEYMOD_SHIFT | KEYCODE_DPAD_UP); // non-standard shifted up
+
+		TERMCAP_TO_KEYCODE.put("@7", KEYCODE_MOVE_END);
+		TERMCAP_TO_KEYCODE.put("@8", KEYCODE_NUMPAD_ENTER);
+	}
+
+	static String getCodeFromTermcap(String termcap, boolean cursorKeysApplication, boolean keypadApplication) {
+		Integer keyCodeAndMod = TERMCAP_TO_KEYCODE.get(termcap);
+		if (keyCodeAndMod == null) return null;
+		int keyCode = keyCodeAndMod;
+		int keyMod = 0;
+		if ((keyCode & KEYMOD_SHIFT) != 0) {
+			keyMod |= KEYMOD_SHIFT;
+			keyCode &= ~KEYMOD_SHIFT;
+		}
+		if ((keyCode & KEYMOD_CTRL) != 0) {
+			keyMod |= KEYMOD_CTRL;
+			keyCode &= ~KEYMOD_CTRL;
+		}
+		if ((keyCode & KEYMOD_ALT) != 0) {
+			keyMod |= KEYMOD_ALT;
+			keyCode &= ~KEYMOD_ALT;
+		}
+		return getCode(keyCode, keyMod, cursorKeysApplication, keypadApplication);
+	}
+
+	public static String getCode(int keyCode, int keyMode, boolean cursorApp, boolean keypadApplication) {
+		switch (keyCode) {
+		case KEYCODE_DPAD_CENTER:
+			return "\015";
+
+		case KEYCODE_DPAD_UP:
+			return (keyMode == 0) ? (cursorApp ? "\033OA" : "\033[A") : transformForModifiers("\033[1", keyMode, 'A');
+		case KEYCODE_DPAD_DOWN:
+			return (keyMode == 0) ? (cursorApp ? "\033OB" : "\033[B") : transformForModifiers("\033[1", keyMode, 'B');
+		case KEYCODE_DPAD_RIGHT:
+			return (keyMode == 0) ? (cursorApp ? "\033OC" : "\033[C") : transformForModifiers("\033[1", keyMode, 'C');
+		case KEYCODE_DPAD_LEFT:
+			return (keyMode == 0) ? (cursorApp ? "\033OD" : "\033[D") : transformForModifiers("\033[1", keyMode, 'D');
+
+		case KeyEvent.KEYCODE_HOME:
+			return (keyMode == 0) ? (cursorApp ? "\033OH" : "\033[H") : transformForModifiers("\033[1", keyMode, 'H');
+		case KEYCODE_MOVE_END:
+			return (keyMode == 0) ? (cursorApp ? "\033OF" : "\033[F") : transformForModifiers("\033[1", keyMode, 'F');
+
+			// An xterm can send function keys F1 to F4 in two modes: vt100 compatible or
+			// not. Because Vim may not know what the xterm is sending, both types of keys
+			// are recognized. The same happens for the <Home> and <End> keys.
+			// normal vt100 ~
+			// <F1> t_k1 <Esc>[11~ <xF1> <Esc>OP *<xF1>-xterm*
+			// <F2> t_k2 <Esc>[12~ <xF2> <Esc>OQ *<xF2>-xterm*
+			// <F3> t_k3 <Esc>[13~ <xF3> <Esc>OR *<xF3>-xterm*
+			// <F4> t_k4 <Esc>[14~ <xF4> <Esc>OS *<xF4>-xterm*
+			// <Home> t_kh <Esc>[7~ <xHome> <Esc>OH *<xHome>-xterm*
+			// <End> t_@7 <Esc>[4~ <xEnd> <Esc>OF *<xEnd>-xterm*
+		case KEYCODE_F1:
+			return (keyMode == 0) ? "\033OP" : transformForModifiers("\033[1", keyMode, 'P');
+		case KEYCODE_F2:
+			return (keyMode == 0) ? "\033OQ" : transformForModifiers("\033[1", keyMode, 'Q');
+		case KEYCODE_F3:
+			return (keyMode == 0) ? "\033OR" : transformForModifiers("\033[1", keyMode, 'R');
+		case KEYCODE_F4:
+			return (keyMode == 0) ? "\033OS" : transformForModifiers("\033[1", keyMode, 'S');
+		case KEYCODE_F5:
+			return transformForModifiers("\033[15", keyMode, '~');
+		case KEYCODE_F6:
+			return transformForModifiers("\033[17", keyMode, '~');
+		case KEYCODE_F7:
+			return transformForModifiers("\033[18", keyMode, '~');
+		case KEYCODE_F8:
+			return transformForModifiers("\033[19", keyMode, '~');
+		case KEYCODE_F9:
+			return transformForModifiers("\033[20", keyMode, '~');
+		case KEYCODE_F10:
+			return transformForModifiers("\033[21", keyMode, '~');
+		case KEYCODE_F11:
+			return transformForModifiers("\033[23", keyMode, '~');
+		case KEYCODE_F12:
+			return transformForModifiers("\033[24", keyMode, '~');
+
+		case KEYCODE_SYSRQ:
+			return "\033[32~"; // Sys Request / Print
+			// Is this Scroll lock? case Cancel: return "\033[33~";
+		case KEYCODE_BREAK:
+			return "\033[34~"; // Pause/Break
+
+		case KEYCODE_ESCAPE:
+		case KeyEvent.KEYCODE_BACK:
+			return "\033";
+
+		case KEYCODE_INSERT:
+			return transformForModifiers("\033[2", keyMode, '~');
+		case KEYCODE_FORWARD_DEL:
+			return transformForModifiers("\033[3", keyMode, '~');
+
+		case KEYCODE_NUMPAD_DOT:
+			return keypadApplication ? "\033On" : "\033[3~";
+
+		case KEYCODE_PAGE_UP:
+			return "\033[5~";
+		case KEYCODE_PAGE_DOWN:
+			return "\033[6~";
+		case KEYCODE_DEL:
+			// Yes, this needs to U+007F and not U+0008!
+			return "\u007F";
+		case KEYCODE_NUM_LOCK:
+			return "\033OP";
+
+		case KeyEvent.KEYCODE_SPACE:
+			// If ctrl is not down, return null so that it goes through normal input processing (which may e.g. cause a
+			// combining accent to be written):
+			return ((keyMode & KEYMOD_CTRL) == 0) ? null : "\0";
+		case KEYCODE_TAB:
+			// This is back-tab when shifted:
+			return (keyMode & KEYMOD_SHIFT) == 0 ? "\011" : "\033[Z";
+		case KEYCODE_ENTER:
+			return ((keyMode & KEYMOD_ALT) == 0) ? "\r" : "\033\r";
+
+		case KEYCODE_NUMPAD_ENTER:
+			return keypadApplication ? transformForModifiers("\033O", keyMode, 'M') : "\n";
+		case KEYCODE_NUMPAD_MULTIPLY:
+			return keypadApplication ? transformForModifiers("\033O", keyMode, 'j') : "*";
+		case KEYCODE_NUMPAD_ADD:
+			return keypadApplication ? transformForModifiers("\033O", keyMode, 'k') : "+";
+		case KEYCODE_NUMPAD_COMMA:
+			return ",";
+		case KEYCODE_NUMPAD_SUBTRACT:
+			return keypadApplication ? transformForModifiers("\033O", keyMode, 'm') : "-";
+		case KEYCODE_NUMPAD_DIVIDE:
+			return keypadApplication ? transformForModifiers("\033O", keyMode, 'o') : "/";
+		case KEYCODE_NUMPAD_0:
+			return keypadApplication ? transformForModifiers("\033O", keyMode, 'p') : "1";
+		case KEYCODE_NUMPAD_1:
+			return keypadApplication ? transformForModifiers("\033O", keyMode, 'q') : "1";
+		case KEYCODE_NUMPAD_2:
+			return keypadApplication ? transformForModifiers("\033O", keyMode, 'r') : "2";
+		case KEYCODE_NUMPAD_3:
+			return keypadApplication ? transformForModifiers("\033O", keyMode, 's') : "3";
+		case KEYCODE_NUMPAD_4:
+			return keypadApplication ? transformForModifiers("\033O", keyMode, 't') : "4";
+		case KEYCODE_NUMPAD_5:
+			return keypadApplication ? transformForModifiers("\033O", keyMode, 'u') : "5";
+		case KEYCODE_NUMPAD_6:
+			return keypadApplication ? transformForModifiers("\033O", keyMode, 'v') : "6";
+		case KEYCODE_NUMPAD_7:
+			return keypadApplication ? transformForModifiers("\033O", keyMode, 'w') : "7";
+		case KEYCODE_NUMPAD_8:
+			return keypadApplication ? transformForModifiers("\033O", keyMode, 'x') : "8";
+		case KEYCODE_NUMPAD_9:
+			return keypadApplication ? transformForModifiers("\033O", keyMode, 'y') : "9";
+		case KEYCODE_NUMPAD_EQUALS:
+			return keypadApplication ? transformForModifiers("\033O", keyMode, 'X') : "=";
+		}
+
+		return null;
+	}
+
+	private static String transformForModifiers(String start, int keymod, char lastChar) {
+		int modifier;
+		switch (keymod) {
+		case KEYMOD_SHIFT:
+			modifier = 2;
+			break;
+		case KEYMOD_ALT:
+			modifier = 3;
+			break;
+		case (KEYMOD_SHIFT | KEYMOD_ALT):
+			modifier = 4;
+			break;
+		case KEYMOD_CTRL:
+			modifier = 5;
+			break;
+		case KEYMOD_SHIFT | KEYMOD_CTRL:
+			modifier = 6;
+			break;
+		case KEYMOD_ALT | KEYMOD_CTRL:
+			modifier = 7;
+			break;
+		case KEYMOD_SHIFT | KEYMOD_ALT | KEYMOD_CTRL:
+			modifier = 8;
+			break;
+		default:
+			return start + lastChar;
+		}
+		return start + (";" + modifier) + lastChar;
+	}
+}

app/src/main/java/com/termux/terminal/TerminalBuffer.java

@@ -0,0 +1,435 @@
+package com.termux.terminal;
+
+/**
+ * A circular buffer of {@link TerminalRow}:s which keeps notes about what is visible on a logical screen and the scroll
+ * history.
+ * 
+ * See {@link #externalToInternalRow(int)} for how to map from logical screen rows to array indices.
+ */
+public final class TerminalBuffer {
+
+	TerminalRow[] mLines;
+	/** The length of {@link #mLines}. */
+	int mTotalRows;
+	/** The number of rows and columns visible on the screen. */
+	int mScreenRows, mColumns;
+	/** The number of rows kept in history. */
+	private int mActiveTranscriptRows = 0;
+	/** The index in the circular buffer where the visible screen starts. */
+	private int mScreenFirstRow = 0;
+
+	/**
+	 * Create a transcript screen.
+	 * 
+	 * @param columns
+	 *            the width of the screen in characters.
+	 * @param totalRows
+	 *            the height of the entire text area, in rows of text.
+	 * @param screenRows
+	 *            the height of just the screen, not including the transcript that holds lines that have scrolled off
+	 *            the top of the screen.
+	 */
+	public TerminalBuffer(int columns, int totalRows, int screenRows) {
+		mColumns = columns;
+		mTotalRows = totalRows;
+		mScreenRows = screenRows;
+		mLines = new TerminalRow[totalRows];
+
+		blockSet(0, 0, columns, screenRows, ' ', TextStyle.NORMAL);
+	}
+
+	public String getTranscriptText() {
+		return getSelectedText(0, -getActiveTranscriptRows(), mColumns, mScreenRows).trim();
+	}
+
+	public String getSelectedText(int selX1, int selY1, int selX2, int selY2) {
+		final StringBuilder builder = new StringBuilder();
+		final int columns = mColumns;
+
+		if (selY1 < -getActiveTranscriptRows()) selY1 = -getActiveTranscriptRows();
+		if (selY2 >= mScreenRows) selY2 = mScreenRows - 1;
+
+		for (int row = selY1; row <= selY2; row++) {
+			int x1 = (row == selY1) ? selX1 : 0;
+			int x2;
+			if (row == selY2) {
+				x2 = selX2 + 1;
+				if (x2 > columns) x2 = columns;
+			} else {
+				x2 = columns;
+			}
+			TerminalRow lineObject = mLines[externalToInternalRow(row)];
+			int x1Index = lineObject.findStartOfColumn(x1);
+			int x2Index = (x2 < mColumns) ? lineObject.findStartOfColumn(x2) : lineObject.getSpaceUsed();
+			char[] line = lineObject.mText;
+			int lastPrintingCharIndex = -1;
+			int i;
+			boolean rowLineWrap = getLineWrap(row);
+			if (rowLineWrap && x2 == columns) {
+				// If the line was wrapped, we shouldn't lose trailing space:
+				lastPrintingCharIndex = x2Index - 1;
+			} else {
+				for (i = x1Index; i < x2Index; ++i) {
+					char c = line[i];
+					if (c != ' ' && !Character.isLowSurrogate(c)) lastPrintingCharIndex = i;
+				}
+			}
+			if (lastPrintingCharIndex != -1) builder.append(line, x1Index, lastPrintingCharIndex - x1Index + 1);
+			if (!rowLineWrap && row < selY2 && row < mScreenRows - 1) builder.append('\n');
+		}
+		return builder.toString();
+	}
+
+	public int getActiveTranscriptRows() {
+		return mActiveTranscriptRows;
+	}
+
+	public int getActiveRows() {
+		return mActiveTranscriptRows + mScreenRows;
+	}
+
+	/**
+	 * Convert a row value from the public external coordinate system to our internal private coordinate system.
+	 * 
+	 * <ul>
+	 * <li>External coordinate system: -mActiveTranscriptRows to mScreenRows-1, with the screen being 0..mScreenRows-1.
+	 * <li>Internal coordinate system: the mScreenRows lines starting at mScreenFirstRow comprise the screen, while the
+	 * mActiveTranscriptRows lines ending at mScreenFirstRow-1 form the transcript (as a circular buffer).
+	 * </ul>
+	 *
+	 * External <---> Internal:
+	 * 
+	 * <pre>
+	 * [ ...                            ]           [ ...                                     ]
+	 * [ -mActiveTranscriptRows         ]           [ mScreenFirstRow - mActiveTranscriptRows ]
+	 * [ ...                            ]           [ ...                                     ]
+	 * [ 0 (visible screen starts here) ]  <----->  [ mScreenFirstRow                         ]
+	 * [ ...                            ]           [ ...                                     ]
+	 * [ mScreenRows-1                  ]           [ mScreenFirstRow + mScreenRows-1         ]
+	 * </pre>
+	 * 
+	 * @param externalRow
+	 *            a row in the external coordinate system.
+	 * @return The row corresponding to the input argument in the private coordinate system.
+	 */
+	public int externalToInternalRow(int externalRow) {
+		if (externalRow < -mActiveTranscriptRows || externalRow > mScreenRows)
+			throw new IllegalArgumentException("extRow=" + externalRow + ", mScreenRows=" + mScreenRows + ", mActiveTranscriptRows=" + mActiveTranscriptRows);
+		final int internalRow = mScreenFirstRow + externalRow;
+		return (internalRow < 0) ? (mTotalRows + internalRow) : (internalRow % mTotalRows);
+	}
+
+	public void setLineWrap(int row) {
+		mLines[externalToInternalRow(row)].mLineWrap = true;
+	}
+
+	private boolean getLineWrap(int row) {
+		return mLines[externalToInternalRow(row)].mLineWrap;
+	}
+
+	/**
+	 * Resize the screen which this transcript backs. Currently, this only works if the number of columns does not
+	 * change or the rows expand (that is, it only works when shrinking the number of rows).
+	 * 
+	 * @param newColumns
+	 *            The number of columns the screen should have.
+	 * @param newRows
+	 *            The number of rows the screen should have.
+	 * @param cursor
+	 *            An int[2] containing the (column, row) cursor location.
+	 */
+	public void resize(int newColumns, int newRows, int newTotalRows, int[] cursor, int currentStyle, boolean altScreen) {
+		// newRows > mTotalRows should not normally happen since mTotalRows is TRANSCRIPT_ROWS (10000):
+		if (newColumns == mColumns && newRows <= mTotalRows) {
+			// Fast resize where just the rows changed.
+			int shiftDownOfTopRow = mScreenRows - newRows;
+			if (shiftDownOfTopRow > 0 && shiftDownOfTopRow < mScreenRows) {
+				// Shrinking. Check if we can skip blank rows at bottom below cursor.
+				for (int i = mScreenRows - 1; i > 0; i--) {
+					if (cursor[1] >= i) break;
+					int r = externalToInternalRow(i);
+					if (mLines[r] == null || mLines[r].isBlank()) {
+						if (--shiftDownOfTopRow == 0) break;
+					}
+				}
+			} else if (shiftDownOfTopRow < 0) {
+				// Negative shift down = expanding. Only move screen up if there is transcript to show:
+				int actualShift = Math.max(shiftDownOfTopRow, -mActiveTranscriptRows);
+				if (shiftDownOfTopRow != actualShift) {
+					// The new lines revealed by the resizing are not all from the transcript. Blank the below ones.
+					for (int i = 0; i < actualShift - shiftDownOfTopRow; i++)
+						allocateFullLineIfNecessary((mScreenFirstRow + mScreenRows + i) % mTotalRows).clear(currentStyle);
+					shiftDownOfTopRow = actualShift;
+				}
+			}
+			mScreenFirstRow += shiftDownOfTopRow;
+			mScreenFirstRow = (mScreenFirstRow < 0) ? (mScreenFirstRow + mTotalRows) : (mScreenFirstRow % mTotalRows);
+			mTotalRows = newTotalRows;
+			mActiveTranscriptRows = altScreen ? 0 : Math.max(0, mActiveTranscriptRows + shiftDownOfTopRow);
+			cursor[1] -= shiftDownOfTopRow;
+			mScreenRows = newRows;
+		} else {
+			// Copy away old state and update new:
+			TerminalRow[] oldLines = mLines;
+			mLines = new TerminalRow[newTotalRows];
+			for (int i = 0; i < newTotalRows; i++)
+				mLines[i] = new TerminalRow(newColumns, currentStyle);
+
+			final int oldActiveTranscriptRows = mActiveTranscriptRows;
+			final int oldScreenFirstRow = mScreenFirstRow;
+			final int oldScreenRows = mScreenRows;
+			final int oldTotalRows = mTotalRows;
+			mTotalRows = newTotalRows;
+			mScreenRows = newRows;
+			mActiveTranscriptRows = mScreenFirstRow = 0;
+			mColumns = newColumns;
+
+			int newCursorRow = -1;
+			int newCursorColumn = -1;
+			int oldCursorRow = cursor[1];
+			int oldCursorColumn = cursor[0];
+			boolean newCursorPlaced = false;
+
+			int currentOutputExternalRow = 0;
+			int currentOutputExternalColumn = 0;
+
+			// Loop over every character in the initial state.
+			// Blank lines should be skipped only if at end of transcript (just as is done in the "fast" resize), so we
+			// keep track how many blank lines we have skipped if we later on find a non-blank line.
+			int skippedBlankLines = 0;
+			for (int externalOldRow = -oldActiveTranscriptRows; externalOldRow < oldScreenRows; externalOldRow++) {
+				// Do what externalToInternalRow() does but for the old state:
+				int internalOldRow = oldScreenFirstRow + externalOldRow;
+				internalOldRow = (internalOldRow < 0) ? (oldTotalRows + internalOldRow) : (internalOldRow % oldTotalRows);
+
+				TerminalRow oldLine = oldLines[internalOldRow];
+				boolean cursorAtThisRow = externalOldRow == oldCursorRow;
+				// The cursor may only be on a non-null line, which we should not skip:
+				if (oldLine == null || (!(!newCursorPlaced && cursorAtThisRow)) && oldLine.isBlank()) {
+					skippedBlankLines++;
+					continue;
+				} else if (skippedBlankLines > 0) {
+					// After skipping some blank lines we encounter a non-blank line. Insert the skipped blank lines.
+					for (int i = 0; i < skippedBlankLines; i++) {
+						if (currentOutputExternalRow == mScreenRows - 1) {
+							scrollDownOneLine(0, mScreenRows, currentStyle);
+						} else {
+							currentOutputExternalRow++;
+						}
+						currentOutputExternalColumn = 0;
+					}
+					skippedBlankLines = 0;
+				}
+
+				int lastNonSpaceIndex = 0;
+				boolean justToCursor = false;
+				if (cursorAtThisRow || oldLine.mLineWrap) {
+					// Take the whole line, either because of cursor on it, or if line wrapping.
+					lastNonSpaceIndex = oldLine.getSpaceUsed();
+					if (cursorAtThisRow) justToCursor = true;
+				} else {
+					for (int i = 0; i < oldLine.getSpaceUsed(); i++)
+						// NEWLY INTRODUCED BUG! Should not index oldLine.mStyle with char indices
+						if (oldLine.mText[i] != ' '/* || oldLine.mStyle[i] != currentStyle */) lastNonSpaceIndex = i + 1;
+				}
+
+				int currentOldCol = 0;
+				int styleAtCol = 0;
+				for (int i = 0; i < lastNonSpaceIndex; i++) {
+					// Note that looping over java character, not cells.
+					char c = oldLine.mText[i];
+					int codePoint = (Character.isHighSurrogate(c)) ? Character.toCodePoint(c, oldLine.mText[++i]) : c;
+					int displayWidth = WcWidth.width(codePoint);
+					// Use the last style if this is a zero-width character:
+					if (displayWidth > 0) styleAtCol = oldLine.getStyle(currentOldCol);
+
+					// Line wrap as necessary:
+					if (currentOutputExternalColumn + displayWidth > mColumns) {
+						setLineWrap(currentOutputExternalRow);
+						if (currentOutputExternalRow == mScreenRows - 1) {
+							if (newCursorPlaced) newCursorRow--;
+							scrollDownOneLine(0, mScreenRows, currentStyle);
+						} else {
+							currentOutputExternalRow++;
+						}
+						currentOutputExternalColumn = 0;
+					}
+
+					int offsetDueToCombiningChar = ((displayWidth <= 0 && currentOutputExternalColumn > 0) ? 1 : 0);
+					int outputColumn = currentOutputExternalColumn - offsetDueToCombiningChar;
+					setChar(outputColumn, currentOutputExternalRow, codePoint, styleAtCol);
+
+					if (displayWidth > 0) {
+						if (oldCursorRow == externalOldRow && oldCursorColumn == currentOldCol) {
+							newCursorColumn = currentOutputExternalColumn;
+							newCursorRow = currentOutputExternalRow;
+							newCursorPlaced = true;
+						}
+						currentOldCol += displayWidth;
+						currentOutputExternalColumn += displayWidth;
+						if (justToCursor && newCursorPlaced) break;
+					}
+				}
+				// Old row has been copied. Check if we need to insert newline if old line was not wrapping:
+				if (externalOldRow != (oldScreenRows - 1) && !oldLine.mLineWrap) {
+					if (currentOutputExternalRow == mScreenRows - 1) {
+						if (newCursorPlaced) newCursorRow--;
+						scrollDownOneLine(0, mScreenRows, currentStyle);
+					} else {
+						currentOutputExternalRow++;
+					}
+					currentOutputExternalColumn = 0;
+				}
+			}
+
+			cursor[0] = newCursorColumn;
+			cursor[1] = newCursorRow;
+		}
+
+		// Handle cursor scrolling off screen:
+		if (cursor[0] < 0 || cursor[1] < 0) cursor[0] = cursor[1] = 0;
+	}
+
+	/**
+	 * Block copy lines and associated metadata from one location to another in the circular buffer, taking wraparound
+	 * into account.
+	 * 
+	 * @param srcInternal
+	 *            The first line to be copied.
+	 * @param len
+	 *            The number of lines to be copied.
+	 */
+	private void blockCopyLinesDown(int srcInternal, int len) {
+		if (len == 0) return;
+		int totalRows = mTotalRows;
+
+		int start = len - 1;
+		// Save away line to be overwritten:
+		TerminalRow lineToBeOverWritten = mLines[(srcInternal + start + 1) % totalRows];
+		// Do the copy from bottom to top.
+		for (int i = start; i >= 0; --i)
+			mLines[(srcInternal + i + 1) % totalRows] = mLines[(srcInternal + i) % totalRows];
+		// Put back overwritten line, now above the block:
+		mLines[(srcInternal) % totalRows] = lineToBeOverWritten;
+	}
+
+	/**
+	 * Scroll the screen down one line. To scroll the whole screen of a 24 line screen, the arguments would be (0, 24).
+	 * 
+	 * @param topMargin
+	 *            First line that is scrolled.
+	 * @param bottomMargin
+	 *            One line after the last line that is scrolled.
+	 * @param style
+	 *            the style for the newly exposed line.
+	 */
+	public void scrollDownOneLine(int topMargin, int bottomMargin, int style) {
+		if (topMargin > bottomMargin - 1 || topMargin < 0 || bottomMargin > mScreenRows)
+			throw new IllegalArgumentException("topMargin=" + topMargin + ", bottomMargin=" + bottomMargin + ", mScreenRows=" + mScreenRows);
+
+		// Copy the fixed topMargin lines one line down so that they remain on screen in same position:
+		blockCopyLinesDown(mScreenFirstRow, topMargin);
+		// Copy the fixed mScreenRows-bottomMargin lines one line down so that they remain on screen in same
+		// position:
+		blockCopyLinesDown(externalToInternalRow(bottomMargin), mScreenRows - bottomMargin);
+
+		// Update the screen location in the ring buffer:
+		mScreenFirstRow = (mScreenFirstRow + 1) % mTotalRows;
+		// Note that the history has grown if not already full:
+		if (mActiveTranscriptRows < mTotalRows - mScreenRows) mActiveTranscriptRows++;
+
+		// Blank the newly revealed line above the bottom margin:
+		int blankRow = externalToInternalRow(bottomMargin - 1);
+		if (mLines[blankRow] == null) {
+			mLines[blankRow] = new TerminalRow(mColumns, style);
+		} else {
+			mLines[blankRow].clear(style);
+		}
+	}
+
+	/**
+	 * Block copy characters from one position in the screen to another. The two positions can overlap. All characters
+	 * of the source and destination must be within the bounds of the screen, or else an InvalidParameterException will
+	 * be thrown.
+	 * 
+	 * @param sx
+	 *            source X coordinate
+	 * @param sy
+	 *            source Y coordinate
+	 * @param w
+	 *            width
+	 * @param h
+	 *            height
+	 * @param dx
+	 *            destination X coordinate
+	 * @param dy
+	 *            destination Y coordinate
+	 */
+	public void blockCopy(int sx, int sy, int w, int h, int dx, int dy) {
+		if (w == 0) return;
+		if (sx < 0 || sx + w > mColumns || sy < 0 || sy + h > mScreenRows || dx < 0 || dx + w > mColumns || dy < 0 || dy + h > mScreenRows)
+			throw new IllegalArgumentException();
+		boolean copyingUp = sy > dy;
+		for (int y = 0; y < h; y++) {
+			int y2 = copyingUp ? y : (h - (y + 1));
+			TerminalRow sourceRow = allocateFullLineIfNecessary(externalToInternalRow(sy + y2));
+			allocateFullLineIfNecessary(externalToInternalRow(dy + y2)).copyInterval(sourceRow, sx, sx + w, dx);
+		}
+	}
+
+	/**
+	 * Block set characters. All characters must be within the bounds of the screen, or else and
+	 * InvalidParemeterException will be thrown. Typically this is called with a "val" argument of 32 to clear a block
+	 * of characters.
+	 */
+	public void blockSet(int sx, int sy, int w, int h, int val, int style) {
+		if (sx < 0 || sx + w > mColumns || sy < 0 || sy + h > mScreenRows) {
+			throw new IllegalArgumentException(
+					"Illegal arguments! blockSet(" + sx + ", " + sy + ", " + w + ", " + h + ", " + val + ", " + mColumns + ", " + mScreenRows + ")");
+		}
+		for (int y = 0; y < h; y++)
+			for (int x = 0; x < w; x++)
+				setChar(sx + x, sy + y, val, style);
+	}
+
+	public TerminalRow allocateFullLineIfNecessary(int row) {
+		return (mLines[row] == null) ? (mLines[row] = new TerminalRow(mColumns, 0)) : mLines[row];
+	}
+
+	public void setChar(int column, int row, int codePoint, int style) {
+		if (row >= mScreenRows || column >= mColumns)
+			throw new IllegalArgumentException("row=" + row + ", column=" + column + ", mScreenRows=" + mScreenRows + ", mColumns=" + mColumns);
+		row = externalToInternalRow(row);
+		allocateFullLineIfNecessary(row).setChar(column, codePoint, style);
+	}
+
+	public int getStyleAt(int externalRow, int column) {
+		return allocateFullLineIfNecessary(externalToInternalRow(externalRow)).getStyle(column);
+	}
+
+	/** Support for http://vt100.net/docs/vt510-rm/DECCARA and http://vt100.net/docs/vt510-rm/DECCARA */
+	public void setOrClearEffect(int bits, boolean setOrClear, boolean reverse, boolean rectangular, int leftMargin, int rightMargin, int top, int left,
+			int bottom, int right) {
+		for (int y = top; y < bottom; y++) {
+			TerminalRow line = mLines[externalToInternalRow(y)];
+			int startOfLine = (rectangular || y == top) ? left : leftMargin;
+			int endOfLine = (rectangular || y + 1 == bottom) ? right : rightMargin;
+			for (int x = startOfLine; x < endOfLine; x++) {
+				int currentStyle = line.getStyle(x);
+				int foreColor = TextStyle.decodeForeColor(currentStyle);
+				int backColor = TextStyle.decodeBackColor(currentStyle);
+				int effect = TextStyle.decodeEffect(currentStyle);
+				if (reverse) {
+					// Clear out the bits to reverse and add them back in reversed:
+					effect = (effect & ~bits) | (bits & ~effect);
+				} else if (setOrClear) {
+					effect |= bits;
+				} else {
+					effect &= ~bits;
+				}
+				line.mStyle[x] = TextStyle.encode(foreColor, backColor, effect);
+			}
+		}
+	}
+
+}

app/src/main/java/com/termux/terminal/TerminalColorScheme.java

@@ -0,0 +1,102 @@
+package com.termux.terminal;
+
+import java.util.Map;
+import java.util.Properties;
+
+/**
+ * Color scheme for a terminal with default colors, which may be overridden (and then reset) from the shell using
+ * Operating System Control (OSC) sequences.
+ * 
+ * @see TerminalColors
+ */
+public final class TerminalColorScheme {
+
+	/** http://upload.wikimedia.org/wikipedia/en/1/15/Xterm_256color_chart.svg, but with blue color brighter. */
+	private static final int[] DEFAULT_COLORSCHEME = {
+			// 16 original colors. First 8 are dim.
+			0xff000000, // black
+			0xffcd0000, // dim red
+			0xff00cd00, // dim green
+			0xffcdcd00, // dim yellow
+			0xff6495ed, // dim blue
+			0xffcd00cd, // dim magenta
+			0xff00cdcd, // dim cyan
+			0xffe5e5e5, // dim white
+			// Second 8 are bright:
+			0xff7f7f7f, // medium grey
+			0xffff0000, // bright red
+			0xff00ff00, // bright green
+			0xffffff00, // bright yellow
+			0xff5c5cff, // light blue
+			0xffff00ff, // bright magenta
+			0xff00ffff, // bright cyan
+			0xffffffff, // bright white
+
+			// 216 color cube, six shades of each color:
+			0xff000000, 0xff00005f, 0xff000087, 0xff0000af, 0xff0000d7, 0xff0000ff, 0xff005f00, 0xff005f5f, 0xff005f87, 0xff005faf, 0xff005fd7, 0xff005fff,
+			0xff008700, 0xff00875f, 0xff008787, 0xff0087af, 0xff0087d7, 0xff0087ff, 0xff00af00, 0xff00af5f, 0xff00af87, 0xff00afaf, 0xff00afd7, 0xff00afff,
+			0xff00d700, 0xff00d75f, 0xff00d787, 0xff00d7af, 0xff00d7d7, 0xff00d7ff, 0xff00ff00, 0xff00ff5f, 0xff00ff87, 0xff00ffaf, 0xff00ffd7, 0xff00ffff,
+			0xff5f0000, 0xff5f005f, 0xff5f0087, 0xff5f00af, 0xff5f00d7, 0xff5f00ff, 0xff5f5f00, 0xff5f5f5f, 0xff5f5f87, 0xff5f5faf, 0xff5f5fd7, 0xff5f5fff,
+			0xff5f8700, 0xff5f875f, 0xff5f8787, 0xff5f87af, 0xff5f87d7, 0xff5f87ff, 0xff5faf00, 0xff5faf5f, 0xff5faf87, 0xff5fafaf, 0xff5fafd7, 0xff5fafff,
+			0xff5fd700, 0xff5fd75f, 0xff5fd787, 0xff5fd7af, 0xff5fd7d7, 0xff5fd7ff, 0xff5fff00, 0xff5fff5f, 0xff5fff87, 0xff5fffaf, 0xff5fffd7, 0xff5fffff,
+			0xff870000, 0xff87005f, 0xff870087, 0xff8700af, 0xff8700d7, 0xff8700ff, 0xff875f00, 0xff875f5f, 0xff875f87, 0xff875faf, 0xff875fd7, 0xff875fff,
+			0xff878700, 0xff87875f, 0xff878787, 0xff8787af, 0xff8787d7, 0xff8787ff, 0xff87af00, 0xff87af5f, 0xff87af87, 0xff87afaf, 0xff87afd7, 0xff87afff,
+			0xff87d700, 0xff87d75f, 0xff87d787, 0xff87d7af, 0xff87d7d7, 0xff87d7ff, 0xff87ff00, 0xff87ff5f, 0xff87ff87, 0xff87ffaf, 0xff87ffd7, 0xff87ffff,
+			0xffaf0000, 0xffaf005f, 0xffaf0087, 0xffaf00af, 0xffaf00d7, 0xffaf00ff, 0xffaf5f00, 0xffaf5f5f, 0xffaf5f87, 0xffaf5faf, 0xffaf5fd7, 0xffaf5fff,
+			0xffaf8700, 0xffaf875f, 0xffaf8787, 0xffaf87af, 0xffaf87d7, 0xffaf87ff, 0xffafaf00, 0xffafaf5f, 0xffafaf87, 0xffafafaf, 0xffafafd7, 0xffafafff,
+			0xffafd700, 0xffafd75f, 0xffafd787, 0xffafd7af, 0xffafd7d7, 0xffafd7ff, 0xffafff00, 0xffafff5f, 0xffafff87, 0xffafffaf, 0xffafffd7, 0xffafffff,
+			0xffd70000, 0xffd7005f, 0xffd70087, 0xffd700af, 0xffd700d7, 0xffd700ff, 0xffd75f00, 0xffd75f5f, 0xffd75f87, 0xffd75faf, 0xffd75fd7, 0xffd75fff,
+			0xffd78700, 0xffd7875f, 0xffd78787, 0xffd787af, 0xffd787d7, 0xffd787ff, 0xffd7af00, 0xffd7af5f, 0xffd7af87, 0xffd7afaf, 0xffd7afd7, 0xffd7afff,
+			0xffd7d700, 0xffd7d75f, 0xffd7d787, 0xffd7d7af, 0xffd7d7d7, 0xffd7d7ff, 0xffd7ff00, 0xffd7ff5f, 0xffd7ff87, 0xffd7ffaf, 0xffd7ffd7, 0xffd7ffff,
+			0xffff0000, 0xffff005f, 0xffff0087, 0xffff00af, 0xffff00d7, 0xffff00ff, 0xffff5f00, 0xffff5f5f, 0xffff5f87, 0xffff5faf, 0xffff5fd7, 0xffff5fff,
+			0xffff8700, 0xffff875f, 0xffff8787, 0xffff87af, 0xffff87d7, 0xffff87ff, 0xffffaf00, 0xffffaf5f, 0xffffaf87, 0xffffafaf, 0xffffafd7, 0xffffafff,
+			0xffffd700, 0xffffd75f, 0xffffd787, 0xffffd7af, 0xffffd7d7, 0xffffd7ff, 0xffffff00, 0xffffff5f, 0xffffff87, 0xffffffaf, 0xffffffd7, 0xffffffff,
+
+			// 24 grey scale ramp:
+			0xff080808, 0xff121212, 0xff1c1c1c, 0xff262626, 0xff303030, 0xff3a3a3a, 0xff444444, 0xff4e4e4e, 0xff585858, 0xff626262, 0xff6c6c6c, 0xff767676,
+			0xff808080, 0xff8a8a8a, 0xff949494, 0xff9e9e9e, 0xffa8a8a8, 0xffb2b2b2, 0xffbcbcbc, 0xffc6c6c6, 0xffd0d0d0, 0xffdadada, 0xffe4e4e4, 0xffeeeeee,
+
+			// COLOR_INDEX_DEFAULT_FOREGROUND, COLOR_INDEX_DEFAULT_BACKGROUND and COLOR_INDEX_DEFAULT_CURSOR:
+			0xffffffff, 0xff000000, 0xffffffff };
+
+	public final int[] mDefaultColors = new int[TextStyle.NUM_INDEXED_COLORS];
+
+	public TerminalColorScheme() {
+		reset();
+	}
+
+	public void reset() {
+		System.arraycopy(DEFAULT_COLORSCHEME, 0, mDefaultColors, 0, TextStyle.NUM_INDEXED_COLORS);
+	}
+
+	public void updateWith(Properties props) {
+		reset();
+		for (Map.Entry<Object, Object> entries : props.entrySet()) {
+			String key = (String) entries.getKey();
+			String value = (String) entries.getValue();
+			int colorIndex;
+
+			if (key.equals("foreground")) {
+				colorIndex = TextStyle.COLOR_INDEX_FOREGROUND;
+			} else if (key.equals("background")) {
+				colorIndex = TextStyle.COLOR_INDEX_BACKGROUND;
+			} else if (key.equals("cursor")) {
+				colorIndex = TextStyle.COLOR_INDEX_CURSOR;
+			} else if (key.startsWith("color")) {
+				try {
+					colorIndex = Integer.parseInt(key.substring(5));
+				} catch (NumberFormatException e) {
+					throw new IllegalArgumentException("Invalid property: '" + key + "'");
+				}
+			} else {
+				throw new IllegalArgumentException("Invalid property: '" + key + "'");
+			}
+
+			int colorValue = TerminalColors.parse(value);
+			if (colorValue == 0) throw new IllegalArgumentException("Property '" + key + "' has invalid color: '" + value + "'");
+
+			mDefaultColors[colorIndex] = colorValue;
+		}
+	}
+
+}

app/src/main/java/com/termux/terminal/TerminalColors.java

@@ -0,0 +1,76 @@
+package com.termux.terminal;
+
+/** Current terminal colors (if different from default). */
+public final class TerminalColors {
+
+	/** Static data - a bit ugly but ok for now. */
+	public static final TerminalColorScheme COLOR_SCHEME = new TerminalColorScheme();
+
+	/**
+	 * The current terminal colors, which are normally set from the color theme, but may be set dynamically with the OSC
+	 * 4 control sequence.
+	 */
+	public final int[] mCurrentColors = new int[TextStyle.NUM_INDEXED_COLORS];
+
+	/** Create a new instance with default colors from the theme. */
+	public TerminalColors() {
+		reset();
+	}
+
+	/** Reset a particular indexed color with the default color from the color theme. */
+	public void reset(int index) {
+		mCurrentColors[index] = COLOR_SCHEME.mDefaultColors[index];
+	}
+
+	/** Reset all indexed colors with the default color from the color theme. */
+	public void reset() {
+		System.arraycopy(COLOR_SCHEME.mDefaultColors, 0, mCurrentColors, 0, TextStyle.NUM_INDEXED_COLORS);
+	}
+
+	/**
+	 * Parse color according to http://manpages.ubuntu.com/manpages/intrepid/man3/XQueryColor.3.html
+	 * 
+	 * Highest bit is set if successful, so return value is 0xFF${R}${G}${B}. Return 0 if failed.
+	 */
+	static int parse(String c) {
+		try {
+			int skipInitial, skipBetween;
+			if (c.charAt(0) == '#') {
+				// #RGB, #RRGGBB, #RRRGGGBBB or #RRRRGGGGBBBB. Most significant bits.
+				skipInitial = 1;
+				skipBetween = 0;
+			} else if (c.startsWith("rgb:")) {
+				// rgb:<red>/<green>/<blue> where <red>, <green>, <blue> := h | hh | hhh | hhhh. Scaled.
+				skipInitial = 4;
+				skipBetween = 1;
+			} else {
+				return 0;
+			}
+			int charsForColors = c.length() - skipInitial - 2 * skipBetween;
+			if (charsForColors % 3 != 0) return 0; // Unequal lengths.
+			int componentLength = charsForColors / 3;
+			double mult = 255 / (Math.pow(2, componentLength * 4) - 1);
+
+			int currentPosition = skipInitial;
+			String rString = c.substring(currentPosition, currentPosition + componentLength);
+			currentPosition += componentLength + skipBetween;
+			String gString = c.substring(currentPosition, currentPosition + componentLength);
+			currentPosition += componentLength + skipBetween;
+			String bString = c.substring(currentPosition, currentPosition + componentLength);
+
+			int r = (int) (Integer.parseInt(rString, 16) * mult);
+			int g = (int) (Integer.parseInt(gString, 16) * mult);
+			int b = (int) (Integer.parseInt(bString, 16) * mult);
+			return 0xFF << 24 | r << 16 | g << 8 | b;
+		} catch (NumberFormatException | IndexOutOfBoundsException e) {
+			return 0;
+		}
+	}
+
+	/** Try parse a color from a text parameter and into a specified index. */
+	public void tryParseColor(int intoIndex, String textParameter) {
+		int c = parse(textParameter);
+		if (c != 0) mCurrentColors[intoIndex] = c;
+	}
+
+}

app/src/main/java/com/termux/terminal/TerminalOutput.java

@@ -0,0 +1,26 @@
+package com.termux.terminal;
+
+import java.nio.charset.StandardCharsets;
+
+/** A client which receives callbacks from events triggered by feeding input to a {@link TerminalEmulator}. */
+public abstract class TerminalOutput {
+
+	/** Write a string using the UTF-8 encoding to the terminal client. */
+	public final void write(String data) {
+		byte[] bytes = data.getBytes(StandardCharsets.UTF_8);
+		write(bytes, 0, bytes.length);
+	}
+
+	/** Write bytes to the terminal client. */
+	public abstract void write(byte[] data, int offset, int count);
+
+	/** Notify the terminal client that the terminal title has changed. */
+	public abstract void titleChanged(String oldTitle, String newTitle);
+
+	/** Notify the terminal client that the terminal title has changed. */
+	public abstract void clipboardText(String text);
+
+	/** Notify the terminal client that a bell character (ASCII 7, bell, BEL, \a, ^G)) has been received. */
+	public abstract void onBell();
+
+}

app/src/main/java/com/termux/terminal/TerminalRow.java

@@ -0,0 +1,231 @@
+package com.termux.terminal;
+
+import java.util.Arrays;
+
+/**
+ * A row in a terminal, composed of a fixed number of cells.
+ * 
+ * The text in the row is stored in a char[] array, {@link #mText}, for quick access during rendering.
+ */
+public final class TerminalRow {
+
+	private static final float SPARE_CAPACITY_FACTOR = 1.5f;
+
+	/** The number of columns in this terminal row. */
+	private final int mColumns;
+	/** The text filling this terminal row. */
+	public char[] mText;
+	/** The number of java char:s used in {@link #mText}. */
+	private short mSpaceUsed;
+	/** If this row has been line wrapped due to text output at the end of line. */
+	boolean mLineWrap;
+	/** The style bits of each cell in the row. See {@link TextStyle}. */
+	final int[] mStyle;
+
+	/** Construct a blank row (containing only whitespace, ' ') with a specified style. */
+	public TerminalRow(int columns, int style) {
+		mColumns = columns;
+		mText = new char[(int) (SPARE_CAPACITY_FACTOR * columns)];
+		mStyle = new int[columns];
+		clear(style);
+	}
+
+	/** NOTE: The sourceX2 is exclusive. */
+	public void copyInterval(TerminalRow line, int sourceX1, int sourceX2, int destinationX) {
+		final int x1 = line.findStartOfColumn(sourceX1);
+		final int x2 = line.findStartOfColumn(sourceX2);
+		boolean startingFromSecondHalfOfWideChar = (sourceX1 > 0 && line.wideDisplayCharacterStartingAt(sourceX1 - 1));
+		final char[] sourceChars = (this == line) ? Arrays.copyOf(line.mText, line.mText.length) : line.mText;
+		int latestNonCombiningWidth = 0;
+		for (int i = x1; i < x2; i++) {
+			char sourceChar = sourceChars[i];
+			int codePoint = Character.isHighSurrogate(sourceChar) ? Character.toCodePoint(sourceChar, sourceChars[++i]) : sourceChar;
+			if (startingFromSecondHalfOfWideChar) {
+				// Just treat copying second half of wide char as copying whitespace.
+				codePoint = ' ';
+				startingFromSecondHalfOfWideChar = false;
+			}
+			int w = WcWidth.width(codePoint);
+			if (w > 0) {
+				destinationX += latestNonCombiningWidth;
+				sourceX1 += latestNonCombiningWidth;
+				latestNonCombiningWidth = w;
+			}
+			setChar(destinationX, codePoint, line.getStyle(sourceX1));
+		}
+	}
+
+	public int getSpaceUsed() {
+		return mSpaceUsed;
+	}
+
+	/** Note that the column may end of second half of wide character. */
+	public int findStartOfColumn(int column) {
+		if (column == mColumns) return getSpaceUsed();
+
+		int currentColumn = 0;
+		int currentCharIndex = 0;
+		while (true) { // 0<2 1 < 2
+			int newCharIndex = currentCharIndex;
+			char c = mText[newCharIndex++]; // cci=1, cci=2
+			boolean isHigh = Character.isHighSurrogate(c);
+			int codePoint = isHigh ? Character.toCodePoint(c, mText[newCharIndex++]) : c;
+			int wcwidth = WcWidth.width(codePoint); // 1, 2
+			if (wcwidth > 0) {
+				currentColumn += wcwidth;
+				if (currentColumn == column) {
+					while (newCharIndex < mSpaceUsed) {
+						// Skip combining chars.
+						if (Character.isHighSurrogate(mText[newCharIndex])) {
+							if (WcWidth.width(Character.toCodePoint(mText[newCharIndex], mText[newCharIndex + 1])) <= 0) {
+								newCharIndex += 2;
+							} else {
+								break;
+							}
+						} else if (WcWidth.width(mText[newCharIndex]) <= 0) {
+							newCharIndex++;
+						} else {
+							break;
+						}
+					}
+					return newCharIndex;
+				} else if (currentColumn > column) {
+					// Wide column going past end.
+					return currentCharIndex;
+				}
+			}
+			currentCharIndex = newCharIndex;
+		}
+	}
+
+	private boolean wideDisplayCharacterStartingAt(int column) {
+		for (int currentCharIndex = 0, currentColumn = 0; currentCharIndex < mSpaceUsed;) {
+			char c = mText[currentCharIndex++];
+			int codePoint = Character.isHighSurrogate(c) ? Character.toCodePoint(c, mText[currentCharIndex++]) : c;
+			int wcwidth = WcWidth.width(codePoint);
+			if (wcwidth > 0) {
+				if (currentColumn == column && wcwidth == 2) return true;
+				currentColumn += wcwidth;
+				if (currentColumn > column) return false;
+			}
+		}
+		return false;
+	}
+
+	public void clear(int style) {
+		Arrays.fill(mText, ' ');
+		Arrays.fill(mStyle, style);
+		mSpaceUsed = (short) mColumns;
+	}
+
+	// https://github.com/steven676/Android-Terminal-Emulator/commit/9a47042620bec87617f0b4f5d50568535668fe26
+	public void setChar(int columnToSet, int codePoint, int style) {
+		mStyle[columnToSet] = style;
+
+		final int newCodePointDisplayWidth = WcWidth.width(codePoint);
+		final boolean newIsCombining = newCodePointDisplayWidth <= 0;
+
+		boolean wasExtraColForWideChar = (columnToSet > 0) && wideDisplayCharacterStartingAt(columnToSet - 1);
+
+		if (newIsCombining) {
+			// When standing at second half of wide character and inserting combining:
+			if (wasExtraColForWideChar) columnToSet--;
+		} else {
+			// Check if we are overwriting the second half of a wide character starting at the previous column:
+			if (wasExtraColForWideChar) setChar(columnToSet - 1, ' ', style);
+			// Check if we are overwriting the first half of a wide character starting at the next column:
+			boolean overwritingWideCharInNextColumn = newCodePointDisplayWidth == 2 && wideDisplayCharacterStartingAt(columnToSet + 1);
+			if (overwritingWideCharInNextColumn) setChar(columnToSet + 1, ' ', style);
+		}
+
+		char[] text = mText;
+		final int oldStartOfColumnIndex = findStartOfColumn(columnToSet);
+		final int oldCodePointDisplayWidth = WcWidth.width(text, oldStartOfColumnIndex);
+
+		// Get the number of elements in the mText array this column uses now
+		int oldCharactersUsedForColumn;
+		if (columnToSet + oldCodePointDisplayWidth < mColumns) {
+			oldCharactersUsedForColumn = findStartOfColumn(columnToSet + oldCodePointDisplayWidth) - oldStartOfColumnIndex;
+		} else {
+			// Last character.
+			oldCharactersUsedForColumn = mSpaceUsed - oldStartOfColumnIndex;
+		}
+
+		// Find how many chars this column will need
+		int newCharactersUsedForColumn = Character.charCount(codePoint);
+		if (newIsCombining) {
+			// Combining characters are added to the contents of the column instead of overwriting them, so that they
+			// modify the existing contents.
+			// FIXME: Put a limit of combining characters.
+			// FIXME: Unassigned characters also get width=0.
+			newCharactersUsedForColumn += oldCharactersUsedForColumn;
+		}
+
+		int oldNextColumnIndex = oldStartOfColumnIndex + oldCharactersUsedForColumn;
+		int newNextColumnIndex = oldStartOfColumnIndex + newCharactersUsedForColumn;
+
+		final int javaCharDifference = newCharactersUsedForColumn - oldCharactersUsedForColumn;
+		if (javaCharDifference > 0) {
+			// Shift the rest of the line right.
+			int oldCharactersAfterColumn = mSpaceUsed - oldNextColumnIndex;
+			if (mSpaceUsed + javaCharDifference > text.length) {
+				// We need to grow the array
+				char[] newText = new char[text.length + mColumns];
+				System.arraycopy(text, 0, newText, 0, oldStartOfColumnIndex + oldCharactersUsedForColumn);
+				System.arraycopy(text, oldNextColumnIndex, newText, newNextColumnIndex, oldCharactersAfterColumn);
+				mText = text = newText;
+			} else {
+				System.arraycopy(text, oldNextColumnIndex, text, newNextColumnIndex, oldCharactersAfterColumn);
+			}
+		} else if (javaCharDifference < 0) {
+			// Shift the rest of the line left.
+			System.arraycopy(text, oldNextColumnIndex, text, newNextColumnIndex, mSpaceUsed - oldNextColumnIndex);
+		}
+		mSpaceUsed += javaCharDifference;
+
+		// Store char. A combining character is stored at the end of the existing contents so that it modifies them:
+		Character.toChars(codePoint, text, oldStartOfColumnIndex + (newIsCombining ? oldCharactersUsedForColumn : 0));
+
+		if (oldCodePointDisplayWidth == 2 && newCodePointDisplayWidth == 1) {
+			// Replace second half of wide char with a space. Which mean that we actually add a ' ' java character.
+			if (mSpaceUsed + 1 > text.length) {
+				char[] newText = new char[text.length + mColumns];
+				System.arraycopy(text, 0, newText, 0, newNextColumnIndex);
+				System.arraycopy(text, newNextColumnIndex, newText, newNextColumnIndex + 1, mSpaceUsed - newNextColumnIndex);
+				mText = text = newText;
+			} else {
+				System.arraycopy(text, newNextColumnIndex, text, newNextColumnIndex + 1, mSpaceUsed - newNextColumnIndex);
+			}
+			text[newNextColumnIndex] = ' ';
+
+			++mSpaceUsed;
+		} else if (oldCodePointDisplayWidth == 1 && newCodePointDisplayWidth == 2) {
+			if (columnToSet == mColumns - 1) {
+				throw new IllegalArgumentException("Cannot put wide character in last column");
+			} else if (columnToSet == mColumns - 2) {
+				// Truncate the line to the second part of this wide char:
+				mSpaceUsed = (short) newNextColumnIndex;
+			} else {
+				// Overwrite the contents of the next column, which mean we actually remove java characters. Due to the
+				// check at the beginning of this method we know that we are not overwriting a wide char.
+				int newNextNextColumnIndex = newNextColumnIndex + (Character.isHighSurrogate(mText[newNextColumnIndex]) ? 2 : 1);
+				int nextLen = newNextNextColumnIndex - newNextColumnIndex;
+
+				// Shift the array leftwards.
+				System.arraycopy(text, newNextNextColumnIndex, text, newNextColumnIndex, mSpaceUsed - newNextNextColumnIndex);
+				mSpaceUsed -= nextLen;
+			}
+		}
+	}
+
+	boolean isBlank() {
+		for (int charIndex = 0, charLen = getSpaceUsed(); charIndex < charLen; charIndex++)
+			if (mText[charIndex] != ' ') return false;
+		return true;
+	}
+
+	public final int getStyle(int column) {
+		return mStyle[column];
+	}
+
+}

app/src/main/java/com/termux/terminal/TerminalSession.java

@@ -0,0 +1,314 @@
+package com.termux.terminal;
+
+import java.io.FileDescriptor;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Field;
+import java.nio.charset.StandardCharsets;
+import java.util.UUID;
+
+import android.annotation.SuppressLint;
+import android.os.Handler;
+import android.os.Message;
+import android.util.Log;
+
+/**
+ * A terminal session, consisting of a process coupled to a terminal interface.
+ * <p>
+ * The subprocess will be executed by the constructor, and when the size is made known by a call to
+ * {@link #updateSize(int, int)} terminal emulation will begin and threads will be spawned to handle the subprocess I/O.
+ * All terminal emulation and callback methods will be performed on the main thread.
+ * <p>
+ * The child process may be exited forcefully by using the {@link #finishIfRunning()} method.
+ * 
+ * NOTE: The terminal session may outlive the EmulatorView, so be careful with callbacks!
+ */
+public final class TerminalSession extends TerminalOutput {
+
+	/** Callback to be invoked when a {@link TerminalSession} changes. */
+	public interface SessionChangedCallback {
+		void onTextChanged(TerminalSession changedSession);
+
+		void onTitleChanged(TerminalSession changedSession);
+
+		void onSessionFinished(TerminalSession finishedSession);
+
+		void onClipboardText(TerminalSession session, String text);
+
+		void onBell(TerminalSession session);
+	}
+
+	private static FileDescriptor wrapFileDescriptor(int fileDescriptor) {
+		FileDescriptor result = new FileDescriptor();
+		try {
+			Field descriptorField;
+			try {
+				descriptorField = FileDescriptor.class.getDeclaredField("descriptor");
+			} catch (NoSuchFieldException e) {
+				// For desktop java:
+				descriptorField = FileDescriptor.class.getDeclaredField("fd");
+			}
+			descriptorField.setAccessible(true);
+			descriptorField.set(result, fileDescriptor);
+		} catch (NoSuchFieldException | IllegalAccessException | IllegalArgumentException e) {
+			Log.wtf(EmulatorDebug.LOG_TAG, "Error accessing FileDescriptor#descriptor private field", e);
+			System.exit(1);
+		}
+		return result;
+	}
+
+	private static final int MSG_NEW_INPUT = 1;
+	private static final int MSG_PROCESS_EXITED = 4;
+
+	public final String mHandle = UUID.randomUUID().toString();
+
+	TerminalEmulator mEmulator;
+
+	/**
+	 * A queue written to from a separate thread when the process outputs, and read by main thread to process by
+	 * terminal emulator.
+	 */
+	final ByteQueue mProcessToTerminalIOQueue = new ByteQueue(4096);
+	/**
+	 * A queue written to from the main thread due to user interaction, and read by another thread which forwards by
+	 * writing to the {@link #mTerminalFileDescriptor}.
+	 */
+	final ByteQueue mTerminalToProcessIOQueue = new ByteQueue(4096);
+	/** Buffer to write translate code points into utf8 before writing to mTerminalToProcessIOQueue */
+	private final byte[] mUtf8InputBuffer = new byte[5];
+
+	/** Callback which gets notified when a session finishes or changes title. */
+	final SessionChangedCallback mChangeCallback;
+
+	/** The pid of the shell process or -1 if not running. */
+	int mShellPid;
+	int mShellExitStatus = -1;
+	/**
+	 * The file descriptor referencing the master half of a pseudo-terminal pair, resulting from calling
+	 * {@link JNI#createSubprocess(String, String, String[], String[], int[])}.
+	 */
+	final int mTerminalFileDescriptor;
+
+	/** Set by the application for user identification of session, not by terminal. */
+	public String mSessionName;
+
+	@SuppressLint("HandlerLeak")
+	final Handler mMainThreadHandler = new Handler() {
+		final byte[] mReceiveBuffer = new byte[4 * 1024];
+
+		@Override
+		public void handleMessage(Message msg) {
+			if (msg.what == MSG_NEW_INPUT && isRunning()) {
+				int bytesRead = mProcessToTerminalIOQueue.read(mReceiveBuffer, false);
+				if (bytesRead > 0) {
+					mEmulator.append(mReceiveBuffer, bytesRead);
+					notifyScreenUpdate();
+				}
+			} else if (msg.what == MSG_PROCESS_EXITED) {
+				int exitCode = (Integer) msg.obj;
+				cleanupResources(exitCode);
+				mChangeCallback.onSessionFinished(TerminalSession.this);
+
+				String exitDescription = "\r\n[Process completed";
+				if (exitCode > 0) {
+					// Non-zero process exit.
+					exitDescription += " with code " + exitCode;
+				} else if (exitCode < 0) {
+					// Negated signal.
+					exitDescription += " with signal " + (-exitCode);
+				}
+				exitDescription += "]";
+
+				byte[] bytesToWrite = exitDescription.getBytes(StandardCharsets.UTF_8);
+				mEmulator.append(bytesToWrite, bytesToWrite.length);
+				notifyScreenUpdate();
+			}
+		}
+	};
+
+	public TerminalSession(String shellPath, String cwd, String[] args, String[] env, SessionChangedCallback changeCallback) {
+		mChangeCallback = changeCallback;
+
+		int[] processId = new int[1];
+		mTerminalFileDescriptor = JNI.createSubprocess(shellPath, cwd, args, env, processId);
+		mShellPid = processId[0];
+	}
+
+	/** Inform the attached pty of the new size and reflow or initialize the emulator. */
+	public void updateSize(int columns, int rows) {
+		JNI.setPtyWindowSize(mTerminalFileDescriptor, rows, columns);
+		if (mEmulator == null) {
+			initializeEmulator(columns, rows);
+		} else {
+			mEmulator.resize(columns, rows);
+		}
+	}
+
+	/** The terminal title as set through escape sequences or null if none set. */
+	public String getTitle() {
+		return (mEmulator == null) ? null : mEmulator.getTitle();
+	}
+
+	/**
+	 * Set the terminal emulator's window size and start terminal emulation.
+	 * 
+	 * @param columns
+	 *            The number of columns in the terminal window.
+	 * @param rows
+	 *            The number of rows in the terminal window.
+	 */
+	public void initializeEmulator(int columns, int rows) {
+		mEmulator = new TerminalEmulator(this, columns, rows, /* transcript= */5000);
+		final FileDescriptor terminalFileDescriptorWrapped = wrapFileDescriptor(mTerminalFileDescriptor);
+
+		new Thread("TermSessionInputReader[pid=" + mShellPid + "]") {
+			@Override
+			public void run() {
+				try (InputStream termIn = new FileInputStream(terminalFileDescriptorWrapped)) {
+					final byte[] buffer = new byte[4096];
+					while (true) {
+						int read = termIn.read(buffer);
+						if (read == -1) return;
+						if (!mProcessToTerminalIOQueue.write(buffer, 0, read)) return;
+						mMainThreadHandler.sendEmptyMessage(MSG_NEW_INPUT);
+					}
+				} catch (Exception e) {
+					// Ignore, just shutting down.
+				} finally {
+					// Now wait for process exit:
+					int processExitCode = JNI.waitFor(mShellPid);
+					mMainThreadHandler.sendMessage(mMainThreadHandler.obtainMessage(MSG_PROCESS_EXITED, processExitCode));
+				}
+			}
+		}.start();
+
+		new Thread("TermSessionOutputWriter[pid=" + mShellPid + "]") {
+			@Override
+			public void run() {
+				final byte[] buffer = new byte[4096];
+				try (FileOutputStream termOut = new FileOutputStream(terminalFileDescriptorWrapped)) {
+					while (true) {
+						int bytesToWrite = mTerminalToProcessIOQueue.read(buffer, true);
+						if (bytesToWrite == -1) return;
+						termOut.write(buffer, 0, bytesToWrite);
+					}
+				} catch (IOException e) {
+					// Ignore.
+				}
+			}
+		}.start();
+	}
+
+	/** Write data to the shell process. */
+	@Override
+	public void write(byte[] data, int offset, int count) {
+		mTerminalToProcessIOQueue.write(data, offset, count);
+	}
+
+	/** Write the Unicode code point to the terminal encoded in UTF-8. */
+	public void writeCodePoint(boolean prependEscape, int codePoint) {
+		if (codePoint > 1114111 || (codePoint >= 0xD800 && codePoint <= 0xDFFF)) {
+			// 1114111 (= 2**16 + 1024**2 - 1) is the highest code point, [0xD800,0xDFFF] is the surrogate range.
+			throw new IllegalArgumentException("Invalid code point: " + codePoint);
+		}
+
+		int bufferPosition = 0;
+		if (prependEscape) mUtf8InputBuffer[bufferPosition++] = 27;
+
+		if (codePoint <= /* 7 bits */0b1111111) {
+			mUtf8InputBuffer[bufferPosition++] = (byte) codePoint;
+		} else if (codePoint <= /* 11 bits */0b11111111111) {
+			/* 110xxxxx leading byte with leading 5 bits */
+			mUtf8InputBuffer[bufferPosition++] = (byte) (0b11000000 | (codePoint >> 6));
+			/* 10xxxxxx continuation byte with following 6 bits */
+			mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | (codePoint & 0b111111));
+		} else if (codePoint <= /* 16 bits */0b1111111111111111) {
+			/* 1110xxxx leading byte with leading 4 bits */
+			mUtf8InputBuffer[bufferPosition++] = (byte) (0b11100000 | (codePoint >> 12));
+			/* 10xxxxxx continuation byte with following 6 bits */
+			mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | ((codePoint >> 6) & 0b111111));
+			/* 10xxxxxx continuation byte with following 6 bits */
+			mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | (codePoint & 0b111111));
+		} else { /* We have checked codePoint <= 1114111 above, so we have max 21 bits = 0b111111111111111111111 */
+			/* 11110xxx leading byte with leading 3 bits */
+			mUtf8InputBuffer[bufferPosition++] = (byte) (0b11110000 | (codePoint >> 18));
+			/* 10xxxxxx continuation byte with following 6 bits */
+			mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | ((codePoint >> 12) & 0b111111));
+			/* 10xxxxxx continuation byte with following 6 bits */
+			mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | ((codePoint >> 6) & 0b111111));
+			/* 10xxxxxx continuation byte with following 6 bits */
+			mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | (codePoint & 0b111111));
+		}
+		write(mUtf8InputBuffer, 0, bufferPosition);
+	}
+
+	public TerminalEmulator getEmulator() {
+		return mEmulator;
+	}
+
+	/** Notify the {@link #mChangeCallback} that the screen has changed. */
+	protected void notifyScreenUpdate() {
+		mChangeCallback.onTextChanged(this);
+	}
+
+	/** Reset state for terminal emulator state. */
+	public void reset() {
+		mEmulator.reset();
+		notifyScreenUpdate();
+	}
+
+	/**
+	 * Finish this terminal session. Frees resources used by the terminal emulator and closes the attached
+	 * <code>InputStream</code> and <code>OutputStream</code>.
+	 */
+	public void finishIfRunning() {
+		if (isRunning()) {
+			JNI.hangupProcessGroup(mShellPid);
+			// Stop the reader and writer threads, and close the I/O streams. Note that
+			// cleanupResources() will be run later.
+			mTerminalToProcessIOQueue.close();
+			mProcessToTerminalIOQueue.close();
+			JNI.close(mTerminalFileDescriptor);
+		}
+	}
+
+	/** Cleanup resources when the process exits. */
+	void cleanupResources(int exitStatus) {
+		synchronized (this) {
+			mShellPid = -1;
+			mShellExitStatus = exitStatus;
+		}
+
+		// Stop the reader and writer threads, and close the I/O streams
+		mTerminalToProcessIOQueue.close();
+		mProcessToTerminalIOQueue.close();
+		JNI.close(mTerminalFileDescriptor);
+	}
+
+	@Override
+	public void titleChanged(String oldTitle, String newTitle) {
+		mChangeCallback.onTitleChanged(this);
+	}
+
+	public synchronized boolean isRunning() {
+		return mShellPid != -1;
+	}
+
+	/** Only valid if not {@link #isRunning()}. */
+	public synchronized int getExitStatus() {
+		return mShellExitStatus;
+	}
+
+	@Override
+	public void clipboardText(String text) {
+		mChangeCallback.onClipboardText(this, text);
+	}
+
+	@Override
+	public void onBell() {
+		mChangeCallback.onBell(this);
+	}
+
+}

app/src/main/java/com/termux/terminal/TextStyle.java

@@ -0,0 +1,55 @@
+package com.termux.terminal;
+
+/**
+ * Encodes effects, foreground and background colors into a 32 bit integer, which are stored for each cell in a terminal
+ * row in {@link TerminalRow#mStyle}.
+ * 
+ * The foreground and background colors take 9 bits each, leaving (32-9-9)=14 bits for effect flags. Using 9 for now
+ * (the different CHARACTER_ATTRIBUTE_* bits).
+ */
+public final class TextStyle {
+
+	public final static int CHARACTER_ATTRIBUTE_BOLD = 1;
+	public final static int CHARACTER_ATTRIBUTE_ITALIC = 1 << 1;
+	public final static int CHARACTER_ATTRIBUTE_UNDERLINE = 1 << 2;
+	public final static int CHARACTER_ATTRIBUTE_BLINK = 1 << 3;
+	public final static int CHARACTER_ATTRIBUTE_INVERSE = 1 << 4;
+	public final static int CHARACTER_ATTRIBUTE_INVISIBLE = 1 << 5;
+	public final static int CHARACTER_ATTRIBUTE_STRIKETHROUGH = 1 << 6;
+	/**
+	 * The selective erase control functions (DECSED and DECSEL) can only erase characters defined as erasable.
+	 * 
+	 * This bit is set if DECSCA (Select Character Protection Attribute) has been used to define the characters that
+	 * come after it as erasable from the screen.
+	 */
+	public final static int CHARACTER_ATTRIBUTE_PROTECTED = 1 << 7;
+	/** Dim colors. Also known as faint or half intensity. */
+	public final static int CHARACTER_ATTRIBUTE_DIM = 1 << 8;
+
+	public final static int COLOR_INDEX_FOREGROUND = 256;
+	public final static int COLOR_INDEX_BACKGROUND = 257;
+	public final static int COLOR_INDEX_CURSOR = 258;
+
+	/** The 256 standard color entries and the three special (foreground, background and cursor) ones. */
+	public final static int NUM_INDEXED_COLORS = 259;
+
+	/** Normal foreground and background colors and no effects. */
+	final static int NORMAL = encode(COLOR_INDEX_FOREGROUND, COLOR_INDEX_BACKGROUND, 0);
+
+	static int encode(int foreColor, int backColor, int effect) {
+		return ((effect & 0b111111111) << 18) | ((foreColor & 0b111111111) << 9) | (backColor & 0b111111111);
+	}
+
+	public static int decodeForeColor(int encodedColor) {
+		return (encodedColor >> 9) & 0b111111111;
+	}
+
+	public static int decodeBackColor(int encodedColor) {
+		return encodedColor & 0b111111111;
+	}
+
+	public static int decodeEffect(int encodedColor) {
+		return (encodedColor >> 18) & 0b111111111;
+	}
+
+}

app/src/main/java/com/termux/terminal/WcWidth.java

@@ -0,0 +1,108 @@
+package com.termux.terminal;
+
+/**
+ * wcwidth() implementation from http://git.musl-libc.org/cgit/musl/tree/src/ctype
+ * 
+ * Modified to return 0 instead of -1.
+ */
+public final class WcWidth {
+
+	private static final short table[] = { 16, 16, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 16, 16, 32, 16, 16, 16, 33, 34, 35, 36, 37, 38,
+			39, 16, 16, 40, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 41, 42, 16, 16, 43, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 44, 16, 45, 46, 47, 48, 16, 16, 16, 16, 16,
+			16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			49, 16, 16, 50, 51, 16, 52, 16, 16, 16, 16, 16, 16, 16, 16, 53, 16, 16, 16, 16, 16, 54, 55, 16, 16, 16, 16, 56, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			16, 16, 16, 16, 16, 57, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 58, 59, 16, 16, 16, 16, 16, 16,
+			16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			16, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255,
+			255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+			255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			248, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 254, 255, 255, 255, 255, 191, 182, 0, 0, 0,
+			0, 0, 0, 0, 31, 0, 255, 7, 0, 0, 0, 0, 0, 248, 255, 255, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, 191, 159, 61, 0, 0, 0, 128, 2, 0, 0, 0,
+			255, 255, 255, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, 255, 1, 0, 0, 0, 0, 0, 0, 248, 15, 0, 0, 0, 192, 251, 239, 62, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240, 255, 255, 127, 7, 0, 0, 0, 0, 0, 0, 20, 254, 33, 254, 0, 12, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 16, 30, 32, 0,
+			0, 12, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 16, 134, 57, 2, 0, 0, 0, 35, 0, 6, 0, 0, 0, 0, 0, 0, 16, 190, 33, 0, 0, 12, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 144,
+			30, 32, 64, 0, 12, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 1, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, 193, 61, 96, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 144, 64, 48, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 30, 32, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 92, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 242, 7, 128, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 242, 27, 0, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 160, 2, 0, 0, 0, 0, 0, 0, 254,
+			127, 223, 224, 255, 254, 255, 255, 255, 31, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 253, 102, 0, 0, 0, 195, 1, 0, 30, 0, 100, 32, 0, 32, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0,
+			28, 0, 0, 0, 12, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 176, 63, 64, 254, 15, 32, 0, 0, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 135, 1, 4, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			128, 1, 0, 0, 0, 0, 0, 0, 64, 127, 229, 31, 248, 159, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 208, 23, 4, 0, 0, 0, 0,
+			248, 15, 0, 3, 0, 0, 0, 60, 11, 0, 0, 0, 0, 0, 0, 64, 163, 3, 0, 0, 0, 0, 0, 0, 240, 207, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			247, 255, 253, 33, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 127, 0, 0, 240, 0, 248, 0, 0,
+			0, 124, 0, 0, 0, 0, 0, 0, 31, 252, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255,
+			255, 0, 0, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128,
+			247, 63, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 68, 8, 0, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0,
+			255, 255, 3, 0, 0, 0, 0, 0, 192, 63, 0, 0, 128, 255, 3, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 200, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 126, 102,
+			0, 8, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 157, 193, 2, 0, 0, 0, 0, 48, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 32, 33, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0,
+			127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 110, 240, 0,
+			0, 0, 0, 0, 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 255, 127, 0, 0, 0, 0, 0, 0, 0, 3, 0,
+			0, 0, 0, 0, 120, 38, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 128, 239, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 192, 127, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 191, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 128, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 3, 248, 255, 231, 15, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };
+
+	private static final short wtable[] = { 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 18, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			16, 16, 16, 16, 16, 16, 19, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 20, 21, 22, 23, 24, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+			17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 25, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+			17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+			17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 26, 16, 16, 16, 16, 27, 16, 16, 17, 17, 17, 17, 17,
+			17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+			17, 28, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17,
+			16, 16, 16, 29, 30, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 31, 16, 16, 16,
+			16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 32, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+			16, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255,
+			255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+			255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 251, 255, 255, 255, 255, 255, 255,
+			255, 255, 255, 255, 15, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+			255, 255, 63, 0, 0, 0, 255, 15, 255, 255, 255, 255, 255, 255, 255, 127, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 254, 255, 255, 255,
+			255, 255, 255, 255, 255, 255, 255, 255, 255, 224, 255, 255, 255, 255, 63, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 255, 255,
+			255, 255, 255, 7, 255, 255, 255, 255, 15, 0, 255, 255, 255, 255, 255, 127, 255, 255, 255, 255, 255, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+			255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+			255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+			255, 31, 255, 255, 255, 255, 255, 255, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 15, 0, 255, 255, 127, 248,
+			255, 255, 255, 255, 255, 15, 0, 0, 255, 3, 0, 0, 255, 255, 255, 255, 247, 255, 127, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 254,
+			255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 255, 255, 255, 255, 255, 7, 255, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+	/** Return the terminal display width of a code point: 0, 1 or 2. */
+	public static int width(int wc) {
+		if (wc < 0xff) return (wc + 1 & 0x7f) >= 0x21 ? 1 : (wc != 0) ? 0 : 0;
+		if ((wc & 0xfffeffff) < 0xfffe) {
+			if (((table[table[wc >> 8] * 32 + ((wc & 255) >> 3)] >> (wc & 7)) & 1) != 0) return 0;
+			if (((wtable[wtable[wc >> 8] * 32 + ((wc & 255) >> 3)] >> (wc & 7)) & 1) != 0) return 2;
+			return 1;
+		}
+		if ((wc & 0xfffe) == 0xfffe) return 0;
+		if (wc - 0x20000 < 0x20000) return 2;
+		if (wc == 0xe0001 || wc - 0xe0020 < 0x5f || wc - 0xe0100 < 0xef) return 0;
+		return 1;
+	}
+
+	/** The width at an index position in a java char array. */
+	public static int width(char[] chars, int index) {
+		char c = chars[index];
+		return Character.isHighSurrogate(c) ? width(Character.toCodePoint(c, chars[index + 1])) : width(c);
+	}
+
+}

app/src/main/java/com/termux/view/GestureAndScaleRecognizer.java

@@ -0,0 +1,100 @@
+package com.termux.view;
+
+import android.content.Context;
+import android.view.GestureDetector;
+import android.view.MotionEvent;
+import android.view.ScaleGestureDetector;
+
+/** A combination of {@link GestureDetector} and {@link ScaleGestureDetector}. */
+public class GestureAndScaleRecognizer {
+
+	public interface Listener {
+		boolean onSingleTapUp(MotionEvent e);
+
+		boolean onDoubleTap(MotionEvent e);
+
+		boolean onScroll(MotionEvent e2, float dx, float dy);
+
+		boolean onFling(MotionEvent e, float velocityX, float velocityY);
+
+		boolean onScale(float focusX, float focusY, float scale);
+
+		boolean onDown(float x, float y);
+
+		boolean onUp(MotionEvent e);
+
+		void onLongPress(MotionEvent e);
+	}
+
+	private final GestureDetector mGestureDetector;
+	private final ScaleGestureDetector mScaleDetector;
+	final Listener mListener;
+
+	public GestureAndScaleRecognizer(Context context, Listener listener) {
+		mListener = listener;
+
+		mGestureDetector = new GestureDetector(context, new GestureDetector.SimpleOnGestureListener() {
+			@Override
+			public boolean onScroll(MotionEvent e1, MotionEvent e2, float dx, float dy) {
+				return mListener.onScroll(e2, dx, dy);
+			}
+
+			@Override
+			public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
+				return mListener.onFling(e2, velocityX, velocityY);
+			}
+
+			@Override
+			public boolean onDown(MotionEvent e) {
+				return mListener.onDown(e.getX(), e.getY());
+			}
+
+			@Override
+			public void onLongPress(MotionEvent e) {
+				mListener.onLongPress(e);
+			}
+		}, null, true /* ignoreMultitouch */);
+
+		mGestureDetector.setOnDoubleTapListener(new GestureDetector.OnDoubleTapListener() {
+			@Override
+			public boolean onSingleTapConfirmed(MotionEvent e) {
+				return mListener.onSingleTapUp(e);
+			}
+
+			@Override
+			public boolean onDoubleTap(MotionEvent e) {
+				return mListener.onDoubleTap(e);
+			}
+
+			@Override
+			public boolean onDoubleTapEvent(MotionEvent e) {
+				return true;
+			}
+		});
+
+		mScaleDetector = new ScaleGestureDetector(context, new ScaleGestureDetector.SimpleOnScaleGestureListener() {
+			@Override
+			public boolean onScaleBegin(ScaleGestureDetector detector) {
+				return true;
+			}
+
+			@Override
+			public boolean onScale(ScaleGestureDetector detector) {
+				return mListener.onScale(detector.getFocusX(), detector.getFocusY(), detector.getScaleFactor());
+			}
+		});
+	}
+
+	public void onTouchEvent(MotionEvent event) {
+		mGestureDetector.onTouchEvent(event);
+		mScaleDetector.onTouchEvent(event);
+		if (event.getAction() == MotionEvent.ACTION_UP) {
+			mListener.onUp(event);
+		}
+	}
+
+	public boolean isInProgress() {
+		return mScaleDetector.isInProgress();
+	}
+
+}

app/src/main/java/com/termux/view/TerminalKeyListener.java

@@ -0,0 +1,20 @@
+package com.termux.view;
+
+import android.view.MotionEvent;
+import android.view.ScaleGestureDetector;
+
+/**
+ * Input and scale listener which may be set on a {@link TerminalView} through
+ * {@link TerminalView#setOnKeyListener(TerminalKeyListener)}.
+ */
+public interface TerminalKeyListener {
+
+	/** Callback function on scale events according to {@link ScaleGestureDetector#getScaleFactor()}. */
+	float onScale(float scale);
+
+	void onLongPress(MotionEvent e);
+
+	/** On a single tap on the terminal if terminal mouse reporting not enabled. */
+	void onSingleTapUp(MotionEvent e);
+
+}

app/src/main/java/com/termux/view/TerminalRenderer.java

@@ -0,0 +1,232 @@
+package com.termux.view;
+
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.PorterDuff;
+import android.graphics.Typeface;
+
+import com.termux.terminal.TerminalBuffer;
+import com.termux.terminal.TerminalEmulator;
+import com.termux.terminal.TerminalRow;
+import com.termux.terminal.TextStyle;
+import com.termux.terminal.WcWidth;
+
+/**
+ * Renderer of a {@link TerminalEmulator} into a {@link Canvas}.
+ * 
+ * Saves font metrics, so needs to be recreated each time the typeface or font size changes.
+ */
+final class TerminalRenderer {
+
+	final int mTextSize;
+	final Typeface mTypeface;
+	private final Paint mTextPaint = new Paint();
+
+	/** The width of a single mono spaced character obtained by {@link Paint#measureText(String)} on a single 'X'. */
+	final float mFontWidth;
+	/** The {@link Paint#getFontSpacing()}. See http://www.fampennings.nl/maarten/android/08numgrid/font.png */
+	final int mFontLineSpacing;
+	/** The {@link Paint#ascent()}. See http://www.fampennings.nl/maarten/android/08numgrid/font.png */
+	private final int mFontAscent;
+	/** The {@link #mFontLineSpacing} + {@link #mFontAscent}. */
+	final int mFontLineSpacingAndAscent;
+
+	private final float[] asciiMeasures = new float[127];
+
+	public TerminalRenderer(int textSize, Typeface typeface) {
+		mTextSize = textSize;
+		mTypeface = typeface;
+
+		mTextPaint.setTypeface(typeface);
+		mTextPaint.setAntiAlias(true);
+		mTextPaint.setTextSize(textSize);
+
+		mFontLineSpacing = (int) Math.ceil(mTextPaint.getFontSpacing());
+		mFontAscent = (int) Math.ceil(mTextPaint.ascent());
+		mFontLineSpacingAndAscent = mFontLineSpacing + mFontAscent;
+		mFontWidth = mTextPaint.measureText("X");
+
+		StringBuilder sb = new StringBuilder(" ");
+		for (int i = 0; i < asciiMeasures.length; i++) {
+			sb.setCharAt(0, (char) i);
+			asciiMeasures[i] = mTextPaint.measureText(sb, 0, 1);
+		}
+	}
+
+	/** Render the terminal to a canvas with at a specified row scroll, and an optional rectangular selection. */
+	public final void render(TerminalEmulator mEmulator, Canvas canvas, int topRow, int selectionY1, int selectionY2, int selectionX1, int selectionX2) {
+		final boolean reverseVideo = mEmulator.isReverseVideo();
+		final int endRow = topRow + mEmulator.mRows;
+		final int columns = mEmulator.mColumns;
+		final int cursorCol = mEmulator.getCursorCol();
+		final int cursorRow = mEmulator.getCursorRow();
+		final boolean cursorVisible = mEmulator.isShowingCursor();
+		final TerminalBuffer screen = mEmulator.getScreen();
+		final int[] palette = mEmulator.mColors.mCurrentColors;
+
+		int fillColor = palette[reverseVideo ? TextStyle.COLOR_INDEX_FOREGROUND : TextStyle.COLOR_INDEX_BACKGROUND];
+		canvas.drawColor(fillColor, PorterDuff.Mode.SRC);
+
+		float heightOffset = mFontLineSpacingAndAscent;
+		for (int row = topRow; row < endRow; row++) {
+			heightOffset += mFontLineSpacing;
+
+			final int cursorX = (row == cursorRow && cursorVisible) ? cursorCol : -1;
+			int selx1 = -1, selx2 = -1;
+			if (row >= selectionY1 && row <= selectionY2) {
+				if (row == selectionY1) selx1 = selectionX1;
+				selx2 = (row == selectionY2) ? selectionX2 : mEmulator.mColumns;
+			}
+
+			TerminalRow lineObject = screen.allocateFullLineIfNecessary(screen.externalToInternalRow(row));
+			final char[] line = lineObject.mText;
+
+			int lastRunStyle = 0;
+			boolean lastRunInsideCursor = false;
+			int lastRunStartColumn = -1;
+			int lastRunStartIndex = 0;
+			boolean lastRunFontWidthMismatch = false;
+			int currentCharIndex = 0;
+			float measuredWidthForRun = 0.f;
+
+			for (int column = 0; column < columns;) {
+				final char charAtIndex = line[currentCharIndex];
+				final boolean charIsHighsurrogate = Character.isHighSurrogate(charAtIndex);
+				final int charsForCodePoint = charIsHighsurrogate ? 2 : 1;
+				final int codePoint = charIsHighsurrogate ? Character.toCodePoint(charAtIndex, line[currentCharIndex + 1]) : charAtIndex;
+				final int codePointWcWidth = WcWidth.width(codePoint);
+				final boolean insideCursor = (column >= selx1 && column <= selx2) || (cursorX == column || (codePointWcWidth == 2 && cursorX == column + 1));
+				final int style = lineObject.getStyle(column);
+
+				// Check if the measured text width for this code point is not the same as that expected by wcwidth().
+				// This could happen for some fonts which are not truly monospace, or for more exotic characters such as
+				// smileys which android font renders as wide.
+				// If this is detected, we draw this code point scaled to match what wcwidth() expects.
+				final float measuredCodePointWidth = (codePoint < asciiMeasures.length) ? asciiMeasures[codePoint] : mTextPaint.measureText(line,
+						currentCharIndex, charsForCodePoint);
+				final boolean fontWidthMismatch = Math.abs(measuredCodePointWidth / mFontWidth - codePointWcWidth) > 0.01;
+
+				if (style != lastRunStyle || insideCursor != lastRunInsideCursor || fontWidthMismatch || lastRunFontWidthMismatch) {
+					if (column == 0) {
+						// Skip first column as there is nothing to draw, just record the current style.
+					} else {
+						final int columnWidthSinceLastRun = column - lastRunStartColumn;
+						final int charsSinceLastRun = currentCharIndex - lastRunStartIndex;
+						drawTextRun(canvas, line, palette, heightOffset, lastRunStartColumn, columnWidthSinceLastRun, lastRunStartIndex, charsSinceLastRun,
+								measuredWidthForRun, lastRunInsideCursor, lastRunStyle, reverseVideo);
+					}
+					measuredWidthForRun = 0.f;
+					lastRunStyle = style;
+					lastRunInsideCursor = insideCursor;
+					lastRunStartColumn = column;
+					lastRunStartIndex = currentCharIndex;
+					lastRunFontWidthMismatch = fontWidthMismatch;
+				}
+				measuredWidthForRun += measuredCodePointWidth;
+				column += codePointWcWidth;
+				currentCharIndex += charsForCodePoint;
+				while (WcWidth.width(line, currentCharIndex) <= 0) {
+					// Eat combining chars so that they are treated as part of the last non-combining code point,
+					// instead of e.g. being considered inside the cursor in the next run.
+					currentCharIndex += Character.isHighSurrogate(line[currentCharIndex]) ? 2 : 1;
+				}
+			}
+
+			final int columnWidthSinceLastRun = columns - lastRunStartColumn;
+			final int charsSinceLastRun = currentCharIndex - lastRunStartIndex;
+			drawTextRun(canvas, line, palette, heightOffset, lastRunStartColumn, columnWidthSinceLastRun, lastRunStartIndex, charsSinceLastRun,
+					measuredWidthForRun, lastRunInsideCursor, lastRunStyle, reverseVideo);
+		}
+	}
+
+	/**
+	 * @param canvas
+	 *            the canvas to render on
+	 * @param palette
+	 *            the color palette to look up colors from textStyle
+	 * @param y
+	 *            height offset into the canvas where to render the line: line * {@link #mFontLineSpacing}
+	 * @param startColumn
+	 *            the run offset in columns
+	 * @param runWidthColumns
+	 *            the run width in columns - this is computed from wcwidth() and may not be what the font measures to
+	 * @param text
+	 *            the java char array to render text from
+	 * @param startCharIndex
+	 *            index into the text array where to start
+	 * @param runWidthChars
+	 *            number of java characters from the text array to render
+	 * @param cursor
+	 *            true if rendering a cursor or selection
+	 * @param textStyle
+	 *            the background, foreground and effect encoded using {@link TextStyle}
+	 * @param reverseVideo
+	 *            if the screen is rendered with the global reverse video flag set
+	 */
+	private void drawTextRun(Canvas canvas, char[] text, int[] palette, float y, int startColumn, int runWidthColumns, int startCharIndex, int runWidthChars,
+			float mes, boolean cursor, int textStyle, boolean reverseVideo) {
+		int foreColor = TextStyle.decodeForeColor(textStyle);
+		int backColor = TextStyle.decodeBackColor(textStyle);
+		final int effect = TextStyle.decodeEffect(textStyle);
+		float left = startColumn * mFontWidth;
+		float right = left + runWidthColumns * mFontWidth;
+
+		mes = mes / mFontWidth;
+		boolean savedMatrix = false;
+		if (Math.abs(mes - runWidthColumns) > 0.01) {
+			canvas.save();
+			canvas.scale(runWidthColumns / mes, 1.f);
+			left *= mes / runWidthColumns;
+			right *= mes / runWidthColumns;
+			savedMatrix = true;
+		}
+
+		// Reverse video here if _one and only one_ of the reverse flags are set:
+		boolean reverseVideoHere = reverseVideo ^ (effect & (TextStyle.CHARACTER_ATTRIBUTE_INVERSE)) != 0;
+		// Switch if _one and only one_ of reverse video and cursor is set:
+		if (reverseVideoHere ^ cursor) {
+			int tmp = foreColor;
+			foreColor = backColor;
+			backColor = tmp;
+		}
+
+		if (backColor != TextStyle.COLOR_INDEX_BACKGROUND) {
+			// Only draw non-default background.
+			mTextPaint.setColor(palette[backColor]);
+			canvas.drawRect(left, y - mFontLineSpacingAndAscent + mFontAscent, right, y, mTextPaint);
+		}
+
+		if ((effect & TextStyle.CHARACTER_ATTRIBUTE_INVISIBLE) == 0) {
+			// Treat blink as bold:
+			final boolean bold = (effect & (TextStyle.CHARACTER_ATTRIBUTE_BOLD | TextStyle.CHARACTER_ATTRIBUTE_BLINK)) != 0;
+			final boolean underline = (effect & TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE) != 0;
+			final boolean italic = (effect & TextStyle.CHARACTER_ATTRIBUTE_ITALIC) != 0;
+			final boolean strikeThrough = (effect & TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH) != 0;
+			final boolean dim = (effect & TextStyle.CHARACTER_ATTRIBUTE_DIM) != 0;
+
+			int foreColorARGB = palette[foreColor];
+			if (dim) {
+				int red = (0xFF & (foreColorARGB >> 16));
+				int green = (0xFF & (foreColorARGB >> 8));
+				int blue = (0xFF & foreColorARGB);
+				// Dim color handling used by libvte which in turn took it from xterm
+				// (https://bug735245.bugzilla-attachments.gnome.org/attachment.cgi?id=284267):
+				red = red * 2 / 3;
+				green = green * 2 / 3;
+				blue = blue * 2 / 3;
+				foreColorARGB = 0xFF000000 + (red << 16) + (green << 8) + blue;
+			}
+
+			mTextPaint.setFakeBoldText(bold);
+			mTextPaint.setUnderlineText(underline);
+			mTextPaint.setTextSkewX(italic ? -0.35f : 0.f);
+			mTextPaint.setStrikeThruText(strikeThrough);
+			mTextPaint.setColor(foreColorARGB);
+
+			// The text alignment is the default Paint.Align.LEFT.
+			canvas.drawText(text, startCharIndex, runWidthChars, left, y - mFontLineSpacingAndAscent, mTextPaint);
+		}
+
+		if (savedMatrix) canvas.restore();
+	}
+}

app/src/main/java/com/termux/view/TerminalView.java

@@ -0,0 +1,826 @@
+package com.termux.view;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.util.Properties;
+
+import com.termux.terminal.EmulatorDebug;
+import com.termux.terminal.KeyHandler;
+import com.termux.terminal.TerminalColors;
+import com.termux.terminal.TerminalEmulator;
+import com.termux.terminal.TerminalSession;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Typeface;
+import android.text.InputType;
+import android.text.TextUtils;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.HapticFeedbackConstants;
+import android.view.InputDevice;
+import android.view.KeyCharacterMap;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.inputmethod.BaseInputConnection;
+import android.view.inputmethod.EditorInfo;
+import android.view.inputmethod.InputConnection;
+import android.widget.Scroller;
+
+/** View displaying and interacting with a {@link TerminalSession}. */
+public final class TerminalView extends View {
+
+	/** Log view key and IME events. */
+	private static final boolean LOG_KEY_EVENTS = false;
+
+	/** The currently displayed terminal session, whose emulator is {@link #mEmulator}. */
+	TerminalSession mTermSession;
+	/** Our terminal emulator whose session is {@link #mTermSession}. */
+	TerminalEmulator mEmulator;
+
+	TerminalRenderer mRenderer;
+
+	TerminalKeyListener mOnKeyListener;
+
+	/** The top row of text to display. Ranges from -activeTranscriptRows to 0. */
+	int mTopRow;
+
+	/** Keeping track of the special keys acting as Ctrl and Fn for the soft keyboard and other hardware keys. */
+	boolean mVirtualControlKeyDown, mVirtualFnKeyDown;
+
+	boolean mIsSelectingText = false;
+	int mSelXAnchor = -1, mSelYAnchor = -1;
+	int mSelX1 = -1, mSelX2 = -1, mSelY1 = -1, mSelY2 = -1;
+
+	float mScaleFactor = 1.f;
+	final GestureAndScaleRecognizer mGestureRecognizer;
+
+	/** Keep track of where mouse touch event started which we report as mouse scroll. */
+	private int mMouseScrollStartX = -1, mMouseScrollStartY = -1;
+	/** Keep track of the time when a touch event leading to sending mouse scroll events started. */
+	private long mMouseStartDownTime = -1;
+
+	final Scroller mScroller;
+
+	/** What was left in from scrolling movement. */
+	float mScrollRemainder;
+
+	/** If non-zero, this is the last unicode code point received if that was a combining character. */
+	int mCombiningAccent;
+
+	public TerminalView(Context context, AttributeSet attributes) { // NO_UCD (unused code)
+		super(context, attributes);
+		mGestureRecognizer = new GestureAndScaleRecognizer(context, new GestureAndScaleRecognizer.Listener() {
+
+			@Override
+			public boolean onUp(MotionEvent e) {
+				mScrollRemainder = 0.0f;
+				if (mEmulator != null && mEmulator.isMouseTrackingActive()) {
+					// Quick event processing when mouse tracking is active - do not wait for check of double tapping
+					// for zooming.
+					sendMouseEventCode(e, TerminalEmulator.MOUSE_LEFT_BUTTON, true);
+					sendMouseEventCode(e, TerminalEmulator.MOUSE_LEFT_BUTTON, false);
+					return true;
+				}
+				return false;
+			}
+
+			@Override
+			public boolean onSingleTapUp(MotionEvent e) {
+				if (mEmulator == null) return true;
+				requestFocus();
+				if (!mEmulator.isMouseTrackingActive()) {
+					if (!e.isFromSource(InputDevice.SOURCE_MOUSE)) {
+						mOnKeyListener.onSingleTapUp(e);
+						return true;
+					}
+				}
+				return false;
+			}
+
+			@Override
+			public boolean onScroll(MotionEvent e2, float distanceX, float distanceY) {
+				if (mEmulator == null) return true;
+				if (mEmulator.isMouseTrackingActive() && e2.isFromSource(InputDevice.SOURCE_MOUSE)) {
+					// If moving with mouse pointer while pressing button, report that instead of scroll.
+					// This means that we never report moving with button press-events for touch input,
+					// since we cannot just start sending these events without a starting press event,
+					// which we do not do for touch input, only mouse in onTouchEvent().
+					sendMouseEventCode(e2, TerminalEmulator.MOUSE_LEFT_BUTTON_MOVED, true);
+				} else {
+					distanceY += mScrollRemainder;
+					int deltaRows = (int) (distanceY / mRenderer.mFontLineSpacing);
+					mScrollRemainder = distanceY - deltaRows * mRenderer.mFontLineSpacing;
+					doScroll(e2, deltaRows);
+				}
+				return true;
+			}
+
+			@Override
+			public boolean onScale(float focusX, float focusY, float scale) {
+				mScaleFactor *= scale;
+				mScaleFactor = mOnKeyListener.onScale(mScaleFactor);
+				return true;
+			}
+
+			@Override
+			public boolean onFling(final MotionEvent e2, float velocityX, float velocityY) {
+				if (mEmulator == null) return true;
+				// Do not start scrolling until last fling has been taken care of:
+				if (!mScroller.isFinished()) return true;
+
+				final boolean mouseTrackingAtStartOfFling = mEmulator.isMouseTrackingActive();
+				float SCALE = 0.25f;
+				if (mouseTrackingAtStartOfFling) {
+					mScroller.fling(0, 0, 0, -(int) (velocityY * SCALE), 0, 0, -mEmulator.mRows / 2, mEmulator.mRows / 2);
+				} else {
+					mScroller.fling(0, mTopRow, 0, -(int) (velocityY * SCALE), 0, 0, -mEmulator.getScreen().getActiveTranscriptRows(), 0);
+				}
+
+				post(new Runnable() {
+					private int mLastY = 0;
+
+					@Override
+					public void run() {
+						if (mouseTrackingAtStartOfFling != mEmulator.isMouseTrackingActive()) {
+							mScroller.abortAnimation();
+							return;
+						}
+						if (mScroller.isFinished()) return;
+						boolean more = mScroller.computeScrollOffset();
+						int newY = mScroller.getCurrY();
+						int diff = mouseTrackingAtStartOfFling ? (newY - mLastY) : (newY - mTopRow);
+						doScroll(e2, diff);
+						mLastY = newY;
+						if (more) post(this);
+					}
+				});
+
+				return true;
+			}
+
+			@Override
+			public boolean onDown(float x, float y) {
+				return false;
+			}
+
+			@Override
+			public boolean onDoubleTap(MotionEvent e) {
+				// Do not treat is as a single confirmed tap - it may be followed by zoom.
+				return false;
+			}
+
+			@Override
+			public void onLongPress(MotionEvent e) {
+				if (mEmulator != null && !mGestureRecognizer.isInProgress()) {
+					performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
+					mOnKeyListener.onLongPress(e);
+				}
+			}
+		});
+		mScroller = new Scroller(context);
+	}
+
+	/**
+	 * @param onKeyListener
+	 *            Listener for all kinds of key events, both hardware and IME (which makes it different from that
+	 *            available with {@link View#setOnKeyListener(OnKeyListener)}.
+	 */
+	public void setOnKeyListener(TerminalKeyListener onKeyListener) {
+		this.mOnKeyListener = onKeyListener;
+	}
+
+	/**
+	 * Attach a {@link TerminalSession} to this view.
+	 * 
+	 * @param session
+	 *            The {@link TerminalSession} this view will be displaying.
+	 */
+	public boolean attachSession(TerminalSession session) {
+		if (session == mTermSession) return false;
+		mTopRow = 0;
+
+		mTermSession = session;
+		mEmulator = null;
+		mCombiningAccent = 0;
+
+		updateSize();
+
+		// Wait with enabling the scrollbar until we have a terminal to get scroll position from.
+		setVerticalScrollBarEnabled(true);
+
+		return true;
+	}
+
+	@Override
+	public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
+		// Make the IME run in a limited "generate key events" mode.
+		//
+		// If using just "TYPE_NULL", there is a problem with the "Google Pinyin Input" being in
+		// word mode when used with the "En" tab available when the "Show English keyboard" option
+		// is enabled - see https://github.com/termux/termux-packages/issues/25.
+		//
+		// Adding TYPE_TEXT_FLAG_NO_SUGGESTIONS fixes Pinyin Input, put causes Swype to be put in
+		// word mode... Using TYPE_TEXT_VARIATION_VISIBLE_PASSWORD fixes that.
+		//
+		// So a bit messy. If this gets too messy it's perhaps best resolved by reverting back to just
+		// "TYPE_NULL" and let the Pinyin Input english keyboard be in word mode.
+		outAttrs.inputType = InputType.TYPE_NULL | InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS | InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD;
+
+		// Let part of the application show behind when in landscape:
+		outAttrs.imeOptions |= EditorInfo.IME_FLAG_NO_FULLSCREEN;
+
+		return new BaseInputConnection(this, true) {
+
+			@Override
+			public boolean beginBatchEdit() {
+				if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "IME: beginBatchEdit()");
+				return true;
+			}
+
+			@Override
+			public boolean clearMetaKeyStates(int states) {
+				if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "IME: clearMetaKeyStates(" + states + ")");
+				return true;
+			}
+
+			@Override
+			public boolean endBatchEdit() {
+				if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "IME: endBatchEdit()");
+				return false;
+			}
+
+			@Override
+			public boolean finishComposingText() {
+				if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "IME: finishComposingText()");
+				return true;
+			}
+
+			@Override
+			public int getCursorCapsMode(int reqModes) {
+				if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "IME: getCursorCapsMode(" + reqModes + ")");
+				int mode = 0;
+				if ((reqModes & TextUtils.CAP_MODE_CHARACTERS) != 0) {
+					mode |= TextUtils.CAP_MODE_CHARACTERS;
+				}
+				return mode;
+			}
+
+			@Override
+			public CharSequence getTextAfterCursor(int n, int flags) {
+				return "";
+			}
+
+			@Override
+			public CharSequence getTextBeforeCursor(int n, int flags) {
+				return "";
+			}
+
+			@Override
+			public boolean commitText(CharSequence text, int newCursorPosition) {
+				if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "IME: commitText(\"" + text + "\", " + newCursorPosition + ")");
+				if (mEmulator == null) return true;
+				final int textLengthInChars = text.length();
+				for (int i = 0; i < textLengthInChars; i++) {
+					char firstChar = text.charAt(i);
+					int codePoint;
+					if (Character.isHighSurrogate(firstChar)) {
+						if (++i < textLengthInChars) {
+							codePoint = Character.toCodePoint(firstChar, text.charAt(i));
+						} else {
+							// At end of string, with no low surrogate following the high:
+							codePoint = TerminalEmulator.UNICODE_REPLACEMENT_CHAR;
+						}
+					} else {
+						codePoint = firstChar;
+					}
+					inputCodePoint(codePoint, false, false);
+				}
+				return true;
+			}
+
+			@Override
+			public boolean deleteSurroundingText(int leftLength, int rightLength) {
+				if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "IME: deleteSurroundingText(" + leftLength + ", " + rightLength + ")");
+
+				// Swype keyboard sometimes(?) sends this on backspace:
+				if (leftLength == 0 && rightLength == 0) leftLength = 1;
+
+				for (int i = 0; i < leftLength; i++)
+					sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL));
+				return true;
+			}
+
+		};
+	}
+
+	@Override
+	protected int computeVerticalScrollRange() {
+		return mEmulator == null ? 1 : mEmulator.getScreen().getActiveRows();
+	}
+
+	@Override
+	protected int computeVerticalScrollExtent() {
+		return mEmulator == null ? 1 : mEmulator.mRows;
+	}
+
+	@Override
+	protected int computeVerticalScrollOffset() {
+		return mEmulator == null ? 1 : mEmulator.getScreen().getActiveRows() + mTopRow - mEmulator.mRows;
+	}
+
+	public void onScreenUpdated() {
+		if (mEmulator == null) return;
+
+		if (mIsSelectingText) {
+			int rowShift = mEmulator.getScrollCounter();
+			mSelY1 -= rowShift;
+			mSelY2 -= rowShift;
+			mSelYAnchor -= rowShift;
+		}
+		mEmulator.clearScrollCounter();
+
+		if (mTopRow != 0) {
+			// Scroll down if not already there.
+			mTopRow = 0;
+			scrollTo(0, 0);
+		}
+
+		invalidate();
+	}
+
+	/**
+	 * Sets the text size, which in turn sets the number of rows and columns.
+	 * 
+	 * @param textSize
+	 *            the new font size, in density-independent pixels.
+	 */
+	public void setTextSize(int textSize) {
+		mRenderer = new TerminalRenderer(textSize, mRenderer == null ? Typeface.MONOSPACE : mRenderer.mTypeface);
+		updateSize();
+	}
+
+	@Override
+	public boolean onCheckIsTextEditor() {
+		return true;
+	}
+
+	@Override
+	public boolean isOpaque() {
+		return true;
+	}
+
+	/** Send a single mouse event code to the terminal. */
+	void sendMouseEventCode(MotionEvent e, int button, boolean pressed) {
+		int x = (int) (e.getX() / mRenderer.mFontWidth) + 1;
+		int y = (int) ((e.getY() - mRenderer.mFontLineSpacingAndAscent) / mRenderer.mFontLineSpacing) + 1;
+		if (pressed && (button == TerminalEmulator.MOUSE_WHEELDOWN_BUTTON || button == TerminalEmulator.MOUSE_WHEELUP_BUTTON)) {
+			if (mMouseStartDownTime == e.getDownTime()) {
+				x = mMouseScrollStartX;
+				y = mMouseScrollStartY;
+			} else {
+				mMouseStartDownTime = e.getDownTime();
+				mMouseScrollStartX = x;
+				mMouseScrollStartY = y;
+			}
+		}
+		mEmulator.sendMouseEvent(button, x, y, pressed);
+	}
+
+	/** Perform a scroll, either from dragging the screen or by scrolling a mouse wheel. */
+	void doScroll(MotionEvent event, int rowsDown) {
+		boolean up = rowsDown < 0;
+		int amount = Math.abs(rowsDown);
+		for (int i = 0; i < amount; i++) {
+			if (mEmulator.isMouseTrackingActive()) {
+				sendMouseEventCode(event, up ? TerminalEmulator.MOUSE_WHEELUP_BUTTON : TerminalEmulator.MOUSE_WHEELDOWN_BUTTON, true);
+			} else if (mEmulator.isAlternateBufferActive()) {
+				// Send up and down key events for scrolling, which is what some terminals do to make scroll work in
+				// e.g. less, which shifts to the alt screen without mouse handling.
+				handleKeyCode(up ? KeyEvent.KEYCODE_DPAD_UP : KeyEvent.KEYCODE_DPAD_DOWN, 0);
+			} else {
+				mTopRow = Math.min(0, Math.max(-(mEmulator.getScreen().getActiveTranscriptRows()), mTopRow + (up ? -1 : 1)));
+				if (!awakenScrollBars()) invalidate();
+			}
+		}
+	}
+
+	/** Overriding {@link View#onGenericMotionEvent(MotionEvent)}. */
+	@Override
+	public boolean onGenericMotionEvent(MotionEvent event) {
+		if (mEmulator != null && event.isFromSource(InputDevice.SOURCE_MOUSE) && event.getAction() == MotionEvent.ACTION_SCROLL) {
+			// Handle mouse wheel scrolling.
+			boolean up = event.getAxisValue(MotionEvent.AXIS_VSCROLL) > 0.0f;
+			doScroll(event, up ? -3 : 3);
+			return true;
+		}
+		return false;
+	}
+
+	@SuppressLint("ClickableViewAccessibility")
+	@Override
+	public boolean onTouchEvent(MotionEvent ev) {
+		if (mEmulator == null) return true;
+		final boolean eventFromMouse = ev.isFromSource(InputDevice.SOURCE_MOUSE);
+		final int action = ev.getAction();
+
+		if (eventFromMouse) {
+			if ((ev.getButtonState() & MotionEvent.BUTTON_SECONDARY) != 0) {
+				if (action == MotionEvent.ACTION_DOWN) showContextMenu();
+				return true;
+			} else if (mEmulator.isMouseTrackingActive() && (ev.getAction() == MotionEvent.ACTION_DOWN || ev.getAction() == MotionEvent.ACTION_UP)) {
+				sendMouseEventCode(ev, TerminalEmulator.MOUSE_LEFT_BUTTON, ev.getAction() == MotionEvent.ACTION_DOWN);
+				return true;
+			} else if (!mEmulator.isMouseTrackingActive() && action == MotionEvent.ACTION_DOWN) {
+				// Start text selection with mouse. Note that the check against MotionEvent.ACTION_DOWN is
+				// important, since we otherwise would pick up secondary mouse button up actions.
+				mIsSelectingText = true;
+			}
+		} else if (!mIsSelectingText) {
+			mGestureRecognizer.onTouchEvent(ev);
+			return true;
+		}
+
+		if (mIsSelectingText) {
+			int cx = (int) (ev.getX() / mRenderer.mFontWidth);
+			// Offset for finger:
+			final int SELECT_TEXT_OFFSET_Y = eventFromMouse ? 0 : -40;
+			int cy = (int) ((ev.getY() + SELECT_TEXT_OFFSET_Y) / mRenderer.mFontLineSpacing) + mTopRow;
+			switch (action) {
+			case MotionEvent.ACTION_DOWN:
+				mSelXAnchor = cx;
+				mSelYAnchor = cy;
+				mSelX1 = cx;
+				mSelY1 = cy;
+				mSelX2 = mSelX1;
+				mSelY2 = mSelY1;
+				invalidate();
+				break;
+			case MotionEvent.ACTION_MOVE:
+			case MotionEvent.ACTION_UP:
+				boolean touchBeforeAnchor = (cy < mSelYAnchor || (cy == mSelYAnchor && cx < mSelXAnchor));
+				int minx = touchBeforeAnchor ? cx : mSelXAnchor;
+				int maxx = !touchBeforeAnchor ? cx : mSelXAnchor;
+				int miny = touchBeforeAnchor ? cy : mSelYAnchor;
+				int maxy = !touchBeforeAnchor ? cy : mSelYAnchor;
+				mSelX1 = minx;
+				mSelY1 = miny;
+				mSelX2 = maxx;
+				mSelY2 = maxy;
+				if (action == MotionEvent.ACTION_UP) {
+					String selectedText = mEmulator.getSelectedText(mSelX1, mSelY1, mSelX2, mSelY2).trim();
+					mTermSession.clipboardText(selectedText);
+					toggleSelectingText();
+				}
+				invalidate();
+				break;
+			default:
+				toggleSelectingText();
+				invalidate();
+				break;
+			}
+			return true;
+		}
+
+		return false;
+	}
+
+	@Override
+	public boolean onKeyPreIme(int keyCode, KeyEvent event) {
+		if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "onKeyPreIme(keyCode=" + keyCode + ", event=" + event + ")");
+		if (keyCode == KeyEvent.KEYCODE_ESCAPE || keyCode == KeyEvent.KEYCODE_BACK) {
+			// Handle the escape key ourselves to avoid the system from treating it as back key
+			// and e.g. close keyboard.
+			switch (event.getAction()) {
+			case KeyEvent.ACTION_DOWN:
+				return onKeyDown(keyCode, event);
+			case KeyEvent.ACTION_UP:
+				return onKeyUp(keyCode, event);
+			}
+		}
+		return super.onKeyPreIme(keyCode, event);
+	}
+
+	@Override
+	public boolean onKeyDown(int keyCode, KeyEvent event) {
+		if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "onKeyDown(keyCode=" + keyCode + ", isSystem()=" + event.isSystem() + ", event=" + event + ")");
+		if (mEmulator == null) return true;
+
+		int metaState = event.getMetaState();
+		boolean controlDownFromEvent = event.isCtrlPressed();
+		boolean leftAltDownFromEvent = (metaState & KeyEvent.META_ALT_LEFT_ON) != 0;
+		boolean rightAltDownFromEvent = (metaState & KeyEvent.META_ALT_RIGHT_ON) != 0;
+
+		if (handleVirtualKeys(keyCode, event, true)) {
+			invalidate();
+			return true;
+		} else if (event.isSystem() && keyCode != KeyEvent.KEYCODE_BACK) {
+			return super.onKeyDown(keyCode, event);
+		}
+
+		int keyMod = 0;
+		if (controlDownFromEvent) keyMod |= KeyHandler.KEYMOD_CTRL;
+		if (event.isAltPressed()) keyMod |= KeyHandler.KEYMOD_ALT;
+		if (event.isShiftPressed()) keyMod |= KeyHandler.KEYMOD_SHIFT;
+		if (handleKeyCode(keyCode, keyMod)) {
+			if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "handleKeyCode() took key event");
+			return true;
+		}
+
+		// Clear Ctrl since we handle that ourselves:
+		int bitsToClear = KeyEvent.META_CTRL_MASK;
+		if (rightAltDownFromEvent) {
+			// Let right Alt/Alt Gr be used to compose characters.
+		} else {
+			// Use left alt to send to terminal (e.g. Left Alt+B to jump back a word), so remove:
+			bitsToClear |= KeyEvent.META_ALT_ON | KeyEvent.META_ALT_LEFT_ON;
+		}
+		int effectiveMetaState = event.getMetaState() & ~bitsToClear;
+
+		int result = event.getUnicodeChar(effectiveMetaState);
+		if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "KeyEvent#getUnicodeChar(" + effectiveMetaState + ") returned: " + result);
+		if (result == 0) {
+			return true;
+		}
+
+		int oldCombiningAccent = mCombiningAccent;
+		if ((result & KeyCharacterMap.COMBINING_ACCENT) != 0) {
+			// If entered combining accent previously, write it out:
+			if (mCombiningAccent != 0) inputCodePoint(mCombiningAccent, controlDownFromEvent, leftAltDownFromEvent);
+			mCombiningAccent = result & KeyCharacterMap.COMBINING_ACCENT_MASK;
+		} else {
+			if (mCombiningAccent != 0) {
+				int combinedChar = KeyCharacterMap.getDeadChar(mCombiningAccent, result);
+				if (combinedChar > 0) result = combinedChar;
+				mCombiningAccent = 0;
+			}
+			inputCodePoint(result, controlDownFromEvent, leftAltDownFromEvent);
+		}
+
+		if (mCombiningAccent != oldCombiningAccent) invalidate();
+
+		return true;
+	}
+
+	void inputCodePoint(int codePoint, boolean controlDownFromEvent, boolean leftAltDownFromEvent) {
+		if (LOG_KEY_EVENTS) {
+			Log.i(EmulatorDebug.LOG_TAG, "inputCodePoint(codePoint=" + codePoint + ", controlDownFromEvent=" + controlDownFromEvent + ", leftAltDownFromEvent="
+					+ leftAltDownFromEvent + ")");
+		}
+
+		int resultingKeyCode = -1; // Set if virtual key causes this to be translated to key event.
+		if (controlDownFromEvent || mVirtualControlKeyDown) {
+			if (codePoint >= 'a' && codePoint <= 'z') {
+				codePoint = codePoint - 'a' + 1;
+			} else if (codePoint >= 'A' && codePoint <= 'Z') {
+				codePoint = codePoint - 'A' + 1;
+			} else if (codePoint == ' ' || codePoint == '2') {
+				codePoint = 0;
+			} else if (codePoint == '[' || codePoint == '3') {
+				codePoint = 27; // ^[ (Esc)
+			} else if (codePoint == '\\' || codePoint == '4') {
+				codePoint = 28;
+			} else if (codePoint == ']' || codePoint == '5') {
+				codePoint = 29;
+			} else if (codePoint == '^' || codePoint == '6') {
+				codePoint = 30; // control-^
+			} else if (codePoint == '_' || codePoint == '7') {
+				codePoint = 31;
+			} else if (codePoint == '8') {
+				codePoint = 127; // DEL
+			} else if (codePoint == '9') {
+				resultingKeyCode = KeyEvent.KEYCODE_F11;
+			} else if (codePoint == '0') {
+				resultingKeyCode = KeyEvent.KEYCODE_F12;
+			}
+		} else if (mVirtualFnKeyDown) {
+			if (codePoint == 'w' || codePoint == 'W') {
+				resultingKeyCode = KeyEvent.KEYCODE_DPAD_UP;
+			} else if (codePoint == 'a' || codePoint == 'A') {
+				resultingKeyCode = KeyEvent.KEYCODE_DPAD_LEFT;
+			} else if (codePoint == 's' || codePoint == 'S') {
+				resultingKeyCode = KeyEvent.KEYCODE_DPAD_DOWN;
+			} else if (codePoint == 'd' || codePoint == 'D') {
+				resultingKeyCode = KeyEvent.KEYCODE_DPAD_RIGHT;
+			} else if (codePoint == 'p' || codePoint == 'P') {
+				resultingKeyCode = KeyEvent.KEYCODE_PAGE_UP;
+			} else if (codePoint == 'n' || codePoint == 'N') {
+				resultingKeyCode = KeyEvent.KEYCODE_PAGE_DOWN;
+			} else if (codePoint == 't' || codePoint == 'T') {
+				resultingKeyCode = KeyEvent.KEYCODE_TAB;
+			} else if (codePoint == 'l' || codePoint == 'L') {
+				codePoint = '|';
+			} else if (codePoint == 'u' || codePoint == 'U') {
+				codePoint = '_';
+			} else if (codePoint == 'e' || codePoint == 'E') {
+				codePoint = 27; // ^[ (Esc)
+			} else if (codePoint == '.') {
+				codePoint = 28; // ^\
+			} else if (codePoint > '0' && codePoint <= '9') {
+				// F1-F9
+				resultingKeyCode = (codePoint - '1') + KeyEvent.KEYCODE_F1;
+			} else if (codePoint == '0') {
+				resultingKeyCode = KeyEvent.KEYCODE_F10;
+			} else if (codePoint == 'i' || codePoint == 'I') {
+				resultingKeyCode = KeyEvent.KEYCODE_INSERT;
+			} else if (codePoint == 'x' || codePoint == 'X') {
+				resultingKeyCode = KeyEvent.KEYCODE_FORWARD_DEL;
+			} else if (codePoint == 'h' || codePoint == 'H') {
+				resultingKeyCode = KeyEvent.KEYCODE_MOVE_HOME;
+			} else if (codePoint == 'f' || codePoint == 'F') {
+				// As left alt+f, jumping forward in readline:
+				codePoint = 'f';
+				leftAltDownFromEvent = true;
+			} else if (codePoint == 'b' || codePoint == 'B') {
+				// As left alt+b, jumping forward in readline:
+				codePoint = 'b';
+				leftAltDownFromEvent = true;
+			}
+		}
+
+		if (codePoint > -1) {
+			if (resultingKeyCode > -1) {
+				handleKeyCode(resultingKeyCode, 0);
+			} else {
+				// The below two workarounds are needed on at least Logitech Keyboard k810 on Samsung Galaxy Tab Pro
+				// (Android 4.4) with the stock Samsung Keyboard. They should be harmless when not used since the need
+				// to input the original characters instead of the new ones using the keyboard should be low.
+				// Rewrite U+02DC 'SMALL TILDE' to U+007E 'TILDE' for ~ to work in shells:
+				if (codePoint == 0x02DC) codePoint = 0x07E;
+				// Rewrite U+02CB 'MODIFIER LETTER GRAVE ACCENT' to U+0060 'GRAVE ACCENT' for ` (backticks) to work:
+				if (codePoint == 0x02CB) codePoint = 0x60;
+
+				// If left alt, send escape before the code point to make e.g. Alt+B and Alt+F work in readline:
+				mTermSession.writeCodePoint(leftAltDownFromEvent, codePoint);
+			}
+		}
+	}
+
+	/** Input the specified keyCode if applicable and return if the input was consumed. */
+	public boolean handleKeyCode(int keyCode, int keyMod) {
+		TerminalEmulator term = mTermSession.getEmulator();
+		String code = KeyHandler.getCode(keyCode, keyMod, term.isCursorKeysApplicationMode(), term.isKeypadApplicationMode());
+		if (code == null) return false;
+		mTermSession.write(code);
+		return true;
+	}
+
+	/**
+	 * Called when a key is released in the view.
+	 * 
+	 * @param keyCode
+	 *            The keycode of the key which was released.
+	 * @param event
+	 *            A {@link KeyEvent} describing the event.
+	 * @return Whether the event was handled.
+	 */
+	@Override
+	public boolean onKeyUp(int keyCode, KeyEvent event) {
+		if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "onKeyUp(keyCode=" + keyCode + ", event=" + event + ")");
+		if (mEmulator == null) return true;
+
+		if (handleVirtualKeys(keyCode, event, false)) {
+			invalidate();
+			return true;
+		} else if (event.isSystem()) {
+			// Let system key events through.
+			return super.onKeyUp(keyCode, event);
+		}
+
+		return true;
+	}
+
+	/** Handle dedicated volume buttons as virtual keys if applicable. */
+	private boolean handleVirtualKeys(int keyCode, KeyEvent event, boolean down) {
+		InputDevice inputDevice = event.getDevice();
+		if (inputDevice != null && inputDevice.getKeyboardType() == InputDevice.KEYBOARD_TYPE_ALPHABETIC) {
+			// Do not steal dedicated buttons from a full external keyboard.
+			return false;
+		} else if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
+			if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "handleVirtualKeys(down=" + down + ") taking ctrl event");
+			mVirtualControlKeyDown = down;
+			return true;
+		} else if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
+			if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "handleVirtualKeys(down=" + down + ") taking Fn event");
+			mVirtualFnKeyDown = down;
+			return true;
+		}
+		return false;
+	}
+
+	public void checkForTypeface() {
+		new Thread() {
+			@Override
+			public void run() {
+				try {
+					File fontFile = new File(getContext().getFilesDir().getPath() + "/home/.termux/font.ttf");
+					final Typeface newTypeface = fontFile.exists() ? Typeface.createFromFile(fontFile) : Typeface.MONOSPACE;
+					if (newTypeface != mRenderer.mTypeface) {
+						((Activity) getContext()).runOnUiThread(new Runnable() {
+							@Override
+							public void run() {
+								try {
+									mRenderer = new TerminalRenderer(mRenderer.mTextSize, newTypeface);
+									updateSize();
+									invalidate();
+								} catch (Exception e) {
+									Log.e(EmulatorDebug.LOG_TAG, "Error loading font", e);
+								}
+							}
+						});
+					}
+				} catch (Exception e) {
+					Log.e(EmulatorDebug.LOG_TAG, "Error loading font", e);
+				}
+			}
+		}.start();
+	}
+
+	public void checkForColors() {
+		new Thread() {
+			@Override
+			public void run() {
+				try {
+					File colorsFile = new File(getContext().getFilesDir().getPath() + "/home/.termux/colors.properties");
+					final Properties props = colorsFile.isFile() ? new Properties() : null;
+					if (props != null) {
+						try (InputStream in = new FileInputStream(colorsFile)) {
+							props.load(in);
+						}
+					}
+					((Activity) getContext()).runOnUiThread(new Runnable() {
+						@Override
+						public void run() {
+							try {
+								if (props == null) {
+									TerminalColors.COLOR_SCHEME.reset();
+								} else {
+									TerminalColors.COLOR_SCHEME.updateWith(props);
+								}
+								if (mEmulator != null) mEmulator.mColors.reset();
+								invalidate();
+							} catch (Exception e) {
+								Log.e(EmulatorDebug.LOG_TAG, "Setting colors failed: " + e.getMessage());
+							}
+						}
+					});
+				} catch (Exception e) {
+					Log.e(EmulatorDebug.LOG_TAG, "Failed colors handling", e);
+				}
+			}
+		}.start();
+	}
+
+	/**
+	 * This is called during layout when the size of this view has changed. If you were just added to the view
+	 * hierarchy, you're called with the old values of 0.
+	 */
+	@Override
+	protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+		updateSize();
+	}
+
+	/** Check if the terminal size in rows and columns should be updated. */
+	public void updateSize() {
+		int viewWidth = getWidth();
+		int viewHeight = getHeight();
+		if (viewWidth == 0 || viewHeight == 0 || mTermSession == null) return;
+
+		// Set to 80 and 24 if you want to enable vttest.
+		int newColumns = Math.max(8, (int) (viewWidth / mRenderer.mFontWidth));
+		int newRows = Math.max(8, (viewHeight - mRenderer.mFontLineSpacingAndAscent) / mRenderer.mFontLineSpacing);
+
+		if (mEmulator == null || (newColumns != mEmulator.mColumns || newRows != mEmulator.mRows)) {
+			mTermSession.updateSize(newColumns, newRows);
+			mEmulator = mTermSession.getEmulator();
+
+			mTopRow = 0;
+			scrollTo(0, 0);
+			invalidate();
+		}
+	}
+
+	@Override
+	protected void onDraw(Canvas canvas) {
+		if (mEmulator == null) {
+			canvas.drawColor(0XFF000000);
+		} else {
+			mRenderer.render(mEmulator, canvas, mTopRow, mSelY1, mSelY2, mSelX1, mSelX2);
+		}
+	}
+
+	/** Toggle text selection mode in the view. */
+	public void toggleSelectingText() {
+		mIsSelectingText = !mIsSelectingText;
+		if (!mIsSelectingText) mSelX1 = mSelY1 = mSelX2 = mSelY2 = -1;
+	}
+
+	public TerminalSession getCurrentSession() {
+		return mTermSession;
+	}
+
+}