Termux is a terminal emulator for Android combined with a collection of packages for command line software. This help
+ explains both the terminal interface and the packaging tool available from inside the terminal.
+
Want to ask a question, report a bug or have an idea for a new package or feature?
+ Visit the Google+ Termux Community!
+
+
User interface
+
At launch Termux shows a terminal interface, whose text size can be adjusted by pinch zooming or double tapping
+ and pulling the content towards or from you.
+
Besides the terminal (with keyboard shortcuts explained below) there are three additional interface elements available:
+ A context menu, navigation drawer
+ and notification.
+
The context menu can be shown by long pressing anywhere on the terminal. It provides menu entries for:
+
+
Selecting and pasting text.
+
Sharing text from the terminal to other apps (e.g. email or SMS)
+
Resetting the terminal if it gets stuck.
+
Switching the terminal to full-screen.
+
Hangup (exiting the current terminal session).
+
Styling the terminal by selecting a font and a color scheme.
+
Showing this help page.
+
+
The navigation drawer is revealed by swiping from the left part of the screen. It has three
+ elements:
+
+
A list of sessions. Clicking on a session shows it in the terminal while long pressing allows you to specify a session title.
+
A button to toggle visibility of the touch keyboard.
+
A button to create new terminal sessions (long press for creating a named session or a fail-safe one).
+
+
The notification, available when a terminal session is running, is available by pulling down the notification menu.
+ Pressing the notification leads to the most current terminal session. The notification may also be expanded
+ (by pinch-zooming or performing a single-finger glide) to expose three actions:
+
+
Exiting all running terminal sessions.
+
Use a wake lock to avoid entering sleep mode.
+
Use a high performance wifi lock to maximize wifi performance.
+
+
With a wake or wifi lock held the notification and Termux background processes will be available even if no terminal
+ session is running, which allows server and other background processes to run more reliably.
+
+
Using a touch keyboard
+
Using the Ctrl key is necessary for working with a terminal - but most touch keyboards
+ does not include one. For that purpose Termux uses the Volume down button to emulate
+ the Ctrl key. For example, pressing Volume down+L on a touch keyboard sends the same input as
+ pressing Ctrl+L on a hardware keyboard. The result of using Ctrl in combination
+ with a key depends on which program is used, but for many command line tools the following
+ shortcuts works:
+
+
Ctrl+A → Move cursor to the beginning of line.
+
Ctrl+C → Abort (send SIGINT to) current process.
+
Ctrl+D → Logout of a terminal session.
+
Ctrl+E → Move cursor to the end of line.
+
Ctrl+K → Delete from cursor to the end of line.
+
Ctrl+L → Clear the terminal.
+
Ctrl+Z → Suspend (send SIGTSTP to) current process.
+
+
The Volume up key also serves as a special key to produce certain input:
+
+
Volume Up+L → | (the pipe character).
+
Volume Up+E → Escape key.
+
Volume Up+T → Tab key.
+
Volume Up+1 → F1 (and Volume Up+2 → F2, etc).
+
Volume Up+B → Alt+B, back a word when using readline.
+
Volume Up+F → Alt+F, forward a word when using readline.
+
Volume Up+W → Up arrow key.
+
Volume Up+A → Left arrow key.
+
Volume Up+S → Down arrow key.
+
Volume Up+D → Right arrow key.
+
+
+
Using a hardware keyboard
+
The following shortcuts are available when using Termux with a hardware (e.g. bluetooth) keyboard by combining them with Ctrl+Shift:
+
+
'C' → Create new session
+
'R' → Rename current session
+
Down arrow (or 'N') → Next session
+
Up arrow (or 'P') → Previous session
+
Right arrow → Open drawer
+
Left arrow → Close drawer
+
'F' → Toggle full screen
+
'M' → Show menu
+
'V' → Paste
+
+/- → Adjust text size
+
1-9 → Go to numbered session
+
+
+
Package management
+
A minimal base system consisting of the Apt package manager and the busybox collection of system utilities
+ is installed when first starting Termux. Additional packages are available using the apt command:
+
+
apt update
Updates the list of available packages. This commands needs to be run initially directly after installation
+ and regularly afterwards to receive updates.
+
apt search <query>
Search among available packages.
+
apt install <package>
Install a new package.
+
apt upgrade
Upgrade outdated packages. For Apt to know about newer packages you will need to update the package index, so you will normally want to run apt update before upgrading.
+
apt show <package>
Show information about a package.
+
apt list
List all available packages.
+
apt list --installed
List all installed packages.
+
apt remove <package>
Remove an installed package.
+
+
+
Apt as a package manager uses a package format named dpkg. Normally direct use of dpkg is not necessary, but the
+ following two commands may be of use:
+
+
dpkg -L <package>
+
List installed files of a package.
+
dpkg --verify
+
Verify the integrity of installed packages.
+
+
View the apt manual page (execute apt install man to install a man page viewer first) for more information.
+
+
Text editing
+
By default the busybox version of vi is available. This is a barebone and somewhat unfriendly editor -
+ install nano for a more straight-forward editor and
+ vim for a more powerful one.
+
+
Using SSH
+
By installing the openssh package (by executing apt install openssh) you may SSH into remote systems,
+ optionally putting private keys or configuration under $HOME/.ssh/.
+
If you wish to use an SSH agent to avoid entering passwords, the Termux openssh package provides
+ a wrapper script named ssha (note the 'a' at the end) for ssh which:
+
+
Starts the ssh agent if necessary (or connect to it if already running).
+
Runs ssh-add if necessary.
+
Runs ssh with the provided arguments.
+
+
This means that the agent will prompt for a key password at first run, but remember the authorization for subsequent ones.
+
+
Interactive shells
+
The base system that is installed when first starting Termux uses the bash shell while zsh is available as
+ an installable alternative:
zsh - a powerful shell with information available at
+ A User's Guide to the Z-Shell, the
+ Z Shell Manual or
+ ZSH Tips by ZZapper.
+ After installing zsh through apt install zsh, execute chsh -s zsh to set it as the default login shell when starting Termux
+ (and change back with chsh -s bash if necessary).
+
+
+
Termux and Android
+
Termux is designed to cope with the restrictions of running as an ordinary Android app without requiring root, which
+ leads to several differences between Termux and a traditional desktop system. The file system layout is drastically different:
+
+
Common folders such as /bin, /usr/, /var and /etc does not exist.
+
The Android system provides a basic non-standard file system hierarchy, where e.g. /system/bin contains some system binaries.
+
The user folder $HOME is inside the private file area exposed to Termux as an ordinary Android app.
+ Uninstalling Termux will cause this file area to be wiped - so save important files outside this area such as in /sdcard
+ or use a version control system such as git.
+
Termux installs its packages in a folder exposed through the $PREFIX environment variable (with e.g. binaries in $PREFIX/bin,
+ and configuration in $PREFIX/etc).
+
Shared libraries are installed in $PREFIX/lib, which are available from binaries due to Termux setting the $LD_LIBRARY_PATH
+ environment variable. These may clash with Android system binaries in /system/bin, which may force LD_LIBRARY_PATH to be
+ cleared before running system binaries.
+
+
Besides the file system being different, Termux is running as a single-user system without root - each Android app is running as
+ its own Linux user, so running commands inside Termux may not interfere with other installed applications.
+
Running as non-root implies that ports below 1024 cannot be bound to. Many packages have been configured to have compatible
+ default values - the ftpd, httpd, and sshd servers default to 8021, 8080 and 8022, respectively.
+
+
Add-on: API
+
The API add-on exposes Android system functionality such as SMS messages, GPS location or the Text-to-speech functionality through command line tools.
+ * 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 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(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 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();
+ }
+
+}
diff --git a/app/src/main/java/com/termux/app/TermuxHelpActivity.java b/app/src/main/java/com/termux/app/TermuxHelpActivity.java
new file mode 100644
index 0000000000..a072b443d9
--- /dev/null
+++ b/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();
+ }
+ }
+
+}
diff --git a/app/src/main/java/com/termux/app/TermuxInstaller.java b/app/src/main/java/com/termux/app/TermuxInstaller.java
new file mode 100644
index 0000000000..714df09e8a
--- /dev/null
+++ b/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> 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 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());
+ }
+ }
+
+}
diff --git a/app/src/main/java/com/termux/app/TermuxPreferences.java b/app/src/main/java/com/termux/app/TermuxPreferences.java
new file mode 100644
index 0000000000..562b853a1b
--- /dev/null
+++ b/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();
+ }
+
+}
diff --git a/app/src/main/java/com/termux/app/TermuxService.java b/app/src/main/java/com/termux/app/TermuxService.java
new file mode 100644
index 0000000000..c6941f4b8f
--- /dev/null
+++ b/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 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 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);
+ }
+
+}
diff --git a/app/src/main/java/com/termux/drawer/DrawerLayout.java b/app/src/main/java/com/termux/drawer/DrawerLayout.java
new file mode 100644
index 0000000000..9523c917c3
--- /dev/null
+++ b/app/src/main/java/com/termux/drawer/DrawerLayout.java
@@ -0,0 +1,1799 @@
+package com.termux.drawer;
+
+/*
+ * Copyright (C) 2013 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 java.util.List;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.PixelFormat;
+import android.graphics.drawable.ColorDrawable;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.os.SystemClock;
+import android.util.AttributeSet;
+import android.view.Gravity;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.accessibility.AccessibilityNodeInfo;
+
+/**
+ * DrawerLayout acts as a top-level container for window content that allows for interactive "drawer" views to be pulled
+ * out from the edge of the window.
+ *
+ *
+ * Drawer positioning and layout is controlled using the android:layout_gravity attribute on child views
+ * corresponding to which side of the view you want the drawer to emerge from: left or right. (Or start/end on platform
+ * versions that support layout direction.)
+ *
+ *
+ *
+ * To use a DrawerLayout, position your primary content view as the first child with a width and height of
+ * match_parent. Add drawers as child views after the main content view and set the
+ * layout_gravity appropriately. Drawers commonly use match_parent for height with a fixed
+ * width.
+ *
+ *
+ *
+ * {@link DrawerListener} can be used to monitor the state and motion of drawer views. Avoid performing expensive
+ * operations such as layout during animation as it can cause stuttering; try to perform expensive operations during the
+ * {@link #STATE_IDLE} state. {@link SimpleDrawerListener} offers default/no-op implementations of each callback method.
+ *
+ *
+ *
+ * As per the Android Design guide, any drawers
+ * positioned to the left/start should always contain content for navigating around the application, whereas any drawers
+ * positioned to the right/end should always contain actions to take on the current content. This preserves the same
+ * navigation left, actions right structure present in the Action Bar and elsewhere.
+ *
+ */
+@SuppressLint("RtlHardcoded")
+public class DrawerLayout extends ViewGroup {
+ private static final String TAG = "DrawerLayout";
+
+ /**
+ * Indicates that any drawers are in an idle, settled state. No animation is in progress.
+ */
+ public static final int STATE_IDLE = ViewDragHelper.STATE_IDLE;
+
+ /**
+ * Indicates that a drawer is currently being dragged by the user.
+ */
+ public static final int STATE_DRAGGING = ViewDragHelper.STATE_DRAGGING;
+
+ /**
+ * Indicates that a drawer is in the process of settling to a final position.
+ */
+ public static final int STATE_SETTLING = ViewDragHelper.STATE_SETTLING;
+
+ /**
+ * The drawer is unlocked.
+ */
+ public static final int LOCK_MODE_UNLOCKED = 0;
+
+ /**
+ * The drawer is locked closed. The user may not open it, though the app may open it programmatically.
+ */
+ public static final int LOCK_MODE_LOCKED_CLOSED = 1;
+
+ /**
+ * The drawer is locked open. The user may not close it, though the app may close it programmatically.
+ */
+ public static final int LOCK_MODE_LOCKED_OPEN = 2;
+
+ private static final int MIN_DRAWER_MARGIN = 64; // dp
+
+ private static final int DEFAULT_SCRIM_COLOR = 0x99000000;
+
+ /**
+ * Length of time to delay before peeking the drawer.
+ */
+ private static final int PEEK_DELAY = 160; // ms
+
+ /**
+ * Minimum velocity that will be detected as a fling
+ */
+ private static final int MIN_FLING_VELOCITY = 400; // dips per second
+
+ /**
+ * Experimental feature.
+ */
+ private static final boolean ALLOW_EDGE_LOCK = false;
+
+ private static final boolean CHILDREN_DISALLOW_INTERCEPT = true;
+
+ private static final float TOUCH_SLOP_SENSITIVITY = 1.f;
+
+ static final int[] LAYOUT_ATTRS = new int[] { android.R.attr.layout_gravity };
+
+ /** Whether we can use NO_HIDE_DESCENDANTS accessibility importance. */
+ static final boolean CAN_HIDE_DESCENDANTS = Build.VERSION.SDK_INT >= 19;
+
+ private final ChildAccessibilityDelegate mChildAccessibilityDelegate = new ChildAccessibilityDelegate();
+
+ private int mMinDrawerMargin;
+
+ private int mScrimColor = DEFAULT_SCRIM_COLOR;
+ private float mScrimOpacity;
+ private Paint mScrimPaint = new Paint();
+
+ private final ViewDragHelper mLeftDragger;
+ private final ViewDragHelper mRightDragger;
+ private final ViewDragCallback mLeftCallback;
+ private final ViewDragCallback mRightCallback;
+ private int mDrawerState;
+ private boolean mInLayout;
+ private boolean mFirstLayout = true;
+ private int mLockModeLeft;
+ private int mLockModeRight;
+ private boolean mChildrenCanceledTouch;
+
+ private DrawerListener mListener;
+
+ private float mInitialMotionX;
+ private float mInitialMotionY;
+
+ private Drawable mShadowLeft;
+ private Drawable mShadowRight;
+ private Drawable mStatusBarBackground;
+
+ private CharSequence mTitleLeft;
+ private CharSequence mTitleRight;
+
+ private Object mLastInsets;
+ private boolean mDrawStatusBarBackground;
+
+ /**
+ * Listener for monitoring events about drawers.
+ */
+ public interface DrawerListener {
+ /**
+ * Called when a drawer's position changes.
+ *
+ * @param drawerView
+ * The child view that was moved
+ * @param slideOffset
+ * The new offset of this drawer within its range, from 0-1
+ */
+ void onDrawerSlide(View drawerView, float slideOffset);
+
+ /**
+ * Called when a drawer has settled in a completely open state. The drawer is interactive at this point.
+ *
+ * @param drawerView
+ * Drawer view that is now open
+ */
+ void onDrawerOpened(View drawerView);
+
+ /**
+ * Called when a drawer has settled in a completely closed state.
+ *
+ * @param drawerView
+ * Drawer view that is now closed
+ */
+ void onDrawerClosed(View drawerView);
+
+ /**
+ * Called when the drawer motion state changes. The new state will be one of {@link #STATE_IDLE},
+ * {@link #STATE_DRAGGING} or {@link #STATE_SETTLING}.
+ *
+ * @param newState
+ * The new drawer motion state
+ */
+ void onDrawerStateChanged(int newState);
+ }
+
+ /**
+ * Stub/no-op implementations of all methods of {@link DrawerListener}. Override this if you only care about a few
+ * of the available callback methods.
+ */
+ public static abstract class SimpleDrawerListener implements DrawerListener {
+ @Override
+ public void onDrawerSlide(View drawerView, float slideOffset) {
+ // Empty.
+ }
+
+ @Override
+ public void onDrawerOpened(View drawerView) {
+ // Empty.
+ }
+
+ @Override
+ public void onDrawerClosed(View drawerView) {
+ // Empty.
+ }
+
+ @Override
+ public void onDrawerStateChanged(int newState) {
+ // Empty.
+ }
+ }
+
+ interface DrawerLayoutCompatImpl {
+ void configureApplyInsets(View drawerLayout);
+
+ void dispatchChildInsets(View child, Object insets, int drawerGravity);
+
+ void applyMarginInsets(MarginLayoutParams lp, Object insets, int drawerGravity);
+
+ int getTopInset(Object lastInsets);
+
+ Drawable getDefaultStatusBarBackground(Context context);
+ }
+
+ static class DrawerLayoutCompatImplBase implements DrawerLayoutCompatImpl {
+ @Override
+ public void configureApplyInsets(View drawerLayout) {
+ // This space for rent
+ }
+
+ @Override
+ public void dispatchChildInsets(View child, Object insets, int drawerGravity) {
+ // This space for rent
+ }
+
+ @Override
+ public void applyMarginInsets(MarginLayoutParams lp, Object insets, int drawerGravity) {
+ // This space for rent
+ }
+
+ @Override
+ public int getTopInset(Object insets) {
+ return 0;
+ }
+
+ @Override
+ public Drawable getDefaultStatusBarBackground(Context context) {
+ return null;
+ }
+ }
+
+ public DrawerLayout(Context context) {
+ this(context, null);
+ }
+
+ public DrawerLayout(Context context, AttributeSet attrs) {
+ this(context, attrs, 0);
+ }
+
+ public DrawerLayout(Context context, AttributeSet attrs, int defStyle) {
+ super(context, attrs, defStyle);
+ setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
+ final float density = getResources().getDisplayMetrics().density;
+ mMinDrawerMargin = (int) (MIN_DRAWER_MARGIN * density + 0.5f);
+ final float minVel = MIN_FLING_VELOCITY * density;
+
+ mLeftCallback = new ViewDragCallback(Gravity.LEFT);
+ mRightCallback = new ViewDragCallback(Gravity.RIGHT);
+
+ mLeftDragger = ViewDragHelper.create(this, TOUCH_SLOP_SENSITIVITY, mLeftCallback);
+ mLeftDragger.setEdgeTrackingEnabled(ViewDragHelper.EDGE_LEFT);
+ mLeftDragger.setMinVelocity(minVel);
+ mLeftCallback.setDragger(mLeftDragger);
+
+ mRightDragger = ViewDragHelper.create(this, TOUCH_SLOP_SENSITIVITY, mRightCallback);
+ mRightDragger.setEdgeTrackingEnabled(ViewDragHelper.EDGE_RIGHT);
+ mRightDragger.setMinVelocity(minVel);
+ mRightCallback.setDragger(mRightDragger);
+
+ // So that we can catch the back button
+ setFocusableInTouchMode(true);
+
+ this.setImportantForAccessibility(View.IMPORTANT_FOR_ACCESSIBILITY_YES);
+
+ this.setAccessibilityDelegate(new AccessibilityDelegate());
+ this.setMotionEventSplittingEnabled(false);
+ if (this.getFitsSystemWindows()) {
+ DrawerLayoutCompatApi21.configureApplyInsets(this);
+ mStatusBarBackground = DrawerLayoutCompatApi21.getDefaultStatusBarBackground(context);
+ }
+ }
+
+ /**
+ * Internal use only; called to apply window insets when configured with fitsSystemWindows="true"
+ */
+ public void setChildInsets(Object insets, boolean draw) {
+ mLastInsets = insets;
+ mDrawStatusBarBackground = draw;
+ setWillNotDraw(!draw && getBackground() == null);
+ requestLayout();
+ }
+
+ /**
+ * Set a simple drawable used for the left or right shadow. The drawable provided must have a nonzero intrinsic
+ * width.
+ *
+ * @param shadowDrawable
+ * Shadow drawable to use at the edge of a drawer
+ * @param gravity
+ * Which drawer the shadow should apply to
+ */
+ public void setDrawerShadow(Drawable shadowDrawable, int gravity) {
+ /*
+ * TODO Someone someday might want to set more complex drawables here. They're probably nuts, but we might want
+ * to consider registering callbacks, setting states, etc. properly.
+ */
+
+ final int absGravity = Gravity.getAbsoluteGravity(gravity, this.getLayoutDirection());
+ if ((absGravity & Gravity.LEFT) == Gravity.LEFT) {
+ mShadowLeft = shadowDrawable;
+ invalidate();
+ }
+ if ((absGravity & Gravity.RIGHT) == Gravity.RIGHT) {
+ mShadowRight = shadowDrawable;
+ invalidate();
+ }
+ }
+
+ /**
+ * Set a simple drawable used for the left or right shadow. The drawable provided must have a nonzero intrinsic
+ * width.
+ *
+ * @param resId
+ * Resource id of a shadow drawable to use at the edge of a drawer
+ * @param gravity
+ * Which drawer the shadow should apply to
+ */
+ public void setDrawerShadow(int resId, int gravity) {
+ setDrawerShadow(getResources().getDrawable(resId), gravity);
+ }
+
+ /**
+ * Set a color to use for the scrim that obscures primary content while a drawer is open.
+ *
+ * @param color
+ * Color to use in 0xAARRGGBB format.
+ */
+ public void setScrimColor(int color) {
+ mScrimColor = color;
+ invalidate();
+ }
+
+ /**
+ * Set a listener to be notified of drawer events.
+ *
+ * @param listener
+ * Listener to notify when drawer events occur
+ * @see DrawerListener
+ */
+ public void setDrawerListener(DrawerListener listener) {
+ mListener = listener;
+ }
+
+ /**
+ * Enable or disable interaction with all drawers.
+ *
+ *
+ * This allows the application to restrict the user's ability to open or close any drawer within this layout.
+ * DrawerLayout will still respond to calls to {@link #openDrawer(int)}, {@link #closeDrawer(int)} and friends if a
+ * drawer is locked.
+ *
+ *
+ *
+ * Locking drawers open or closed will implicitly open or close any drawers as appropriate.
+ *
+ *
+ * @param lockMode
+ * The new lock mode for the given drawer. One of {@link #LOCK_MODE_UNLOCKED},
+ * {@link #LOCK_MODE_LOCKED_CLOSED} or {@link #LOCK_MODE_LOCKED_OPEN}.
+ */
+ public void setDrawerLockMode(int lockMode) {
+ setDrawerLockMode(lockMode, Gravity.LEFT);
+ setDrawerLockMode(lockMode, Gravity.RIGHT);
+ }
+
+ /**
+ * Enable or disable interaction with the given drawer.
+ *
+ *
+ * This allows the application to restrict the user's ability to open or close the given drawer. DrawerLayout will
+ * still respond to calls to {@link #openDrawer(int)}, {@link #closeDrawer(int)} and friends if a drawer is locked.
+ *
+ *
+ *
+ * Locking a drawer open or closed will implicitly open or close that drawer as appropriate.
+ *
+ *
+ * @param lockMode
+ * The new lock mode for the given drawer. One of {@link #LOCK_MODE_UNLOCKED},
+ * {@link #LOCK_MODE_LOCKED_CLOSED} or {@link #LOCK_MODE_LOCKED_OPEN}.
+ * @param edgeGravity
+ * Gravity.LEFT, RIGHT, START or END. Expresses which drawer to change the mode for.
+ *
+ * @see #LOCK_MODE_UNLOCKED
+ * @see #LOCK_MODE_LOCKED_CLOSED
+ * @see #LOCK_MODE_LOCKED_OPEN
+ */
+ public void setDrawerLockMode(int lockMode, int edgeGravity) {
+ final int absGravity = Gravity.getAbsoluteGravity(edgeGravity, this.getLayoutDirection());
+ if (absGravity == Gravity.LEFT) {
+ mLockModeLeft = lockMode;
+ } else if (absGravity == Gravity.RIGHT) {
+ mLockModeRight = lockMode;
+ }
+ if (lockMode != LOCK_MODE_UNLOCKED) {
+ // Cancel interaction in progress
+ final ViewDragHelper helper = absGravity == Gravity.LEFT ? mLeftDragger : mRightDragger;
+ helper.cancel();
+ }
+ switch (lockMode) {
+ case LOCK_MODE_LOCKED_OPEN:
+ final View toOpen = findDrawerWithGravity(absGravity);
+ if (toOpen != null) {
+ openDrawer(toOpen);
+ }
+ break;
+ case LOCK_MODE_LOCKED_CLOSED:
+ final View toClose = findDrawerWithGravity(absGravity);
+ if (toClose != null) {
+ closeDrawer(toClose);
+ }
+ break;
+ // default: do nothing
+ }
+ }
+
+ /**
+ * Enable or disable interaction with the given drawer.
+ *
+ *
+ * This allows the application to restrict the user's ability to open or close the given drawer. DrawerLayout will
+ * still respond to calls to {@link #openDrawer(int)}, {@link #closeDrawer(int)} and friends if a drawer is locked.
+ *
+ *
+ *
+ * Locking a drawer open or closed will implicitly open or close that drawer as appropriate.
+ *
+ *
+ * @param lockMode
+ * The new lock mode for the given drawer. One of {@link #LOCK_MODE_UNLOCKED},
+ * {@link #LOCK_MODE_LOCKED_CLOSED} or {@link #LOCK_MODE_LOCKED_OPEN}.
+ * @param drawerView
+ * The drawer view to change the lock mode for
+ *
+ * @see #LOCK_MODE_UNLOCKED
+ * @see #LOCK_MODE_LOCKED_CLOSED
+ * @see #LOCK_MODE_LOCKED_OPEN
+ */
+ public void setDrawerLockMode(int lockMode, View drawerView) {
+ if (!isDrawerView(drawerView)) {
+ throw new IllegalArgumentException("View " + drawerView + " is not a " + "drawer with appropriate layout_gravity");
+ }
+ final int gravity = ((LayoutParams) drawerView.getLayoutParams()).gravity;
+ setDrawerLockMode(lockMode, gravity);
+ }
+
+ /**
+ * Check the lock mode of the drawer with the given gravity.
+ *
+ * @param edgeGravity
+ * Gravity of the drawer to check
+ * @return one of {@link #LOCK_MODE_UNLOCKED}, {@link #LOCK_MODE_LOCKED_CLOSED} or {@link #LOCK_MODE_LOCKED_OPEN}.
+ */
+ public int getDrawerLockMode(int edgeGravity) {
+ final int absGravity = Gravity.getAbsoluteGravity(edgeGravity, this.getLayoutDirection());
+ if (absGravity == Gravity.LEFT) {
+ return mLockModeLeft;
+ } else if (absGravity == Gravity.RIGHT) {
+ return mLockModeRight;
+ }
+ return LOCK_MODE_UNLOCKED;
+ }
+
+ /**
+ * Check the lock mode of the given drawer view.
+ *
+ * @param drawerView
+ * Drawer view to check lock mode
+ * @return one of {@link #LOCK_MODE_UNLOCKED}, {@link #LOCK_MODE_LOCKED_CLOSED} or {@link #LOCK_MODE_LOCKED_OPEN}.
+ */
+ public int getDrawerLockMode(View drawerView) {
+ final int absGravity = getDrawerViewAbsoluteGravity(drawerView);
+ if (absGravity == Gravity.LEFT) {
+ return mLockModeLeft;
+ } else if (absGravity == Gravity.RIGHT) {
+ return mLockModeRight;
+ }
+ return LOCK_MODE_UNLOCKED;
+ }
+
+ /**
+ * Sets the title of the drawer with the given gravity.
+ *
+ * When accessibility is turned on, this is the title that will be used to identify the drawer to the active
+ * accessibility service.
+ *
+ * @param edgeGravity
+ * Gravity.LEFT, RIGHT, START or END. Expresses which drawer to set the title for.
+ * @param title
+ * The title for the drawer.
+ */
+ public void setDrawerTitle(int edgeGravity, CharSequence title) {
+ final int absGravity = Gravity.getAbsoluteGravity(edgeGravity, this.getLayoutDirection());
+ if (absGravity == Gravity.LEFT) {
+ mTitleLeft = title;
+ } else if (absGravity == Gravity.RIGHT) {
+ mTitleRight = title;
+ }
+ }
+
+ /**
+ * Returns the title of the drawer with the given gravity.
+ *
+ * @param edgeGravity
+ * Gravity.LEFT, RIGHT, START or END. Expresses which drawer to return the title for.
+ * @return The title of the drawer, or null if none set.
+ * @see #setDrawerTitle(int, CharSequence)
+ */
+ public CharSequence getDrawerTitle(int edgeGravity) {
+ final int absGravity = Gravity.getAbsoluteGravity(edgeGravity, this.getLayoutDirection());
+ if (absGravity == Gravity.LEFT) {
+ return mTitleLeft;
+ } else if (absGravity == Gravity.RIGHT) {
+ return mTitleRight;
+ }
+ return null;
+ }
+
+ /**
+ * Resolve the shared state of all drawers from the component ViewDragHelpers. Should be called whenever a
+ * ViewDragHelper's state changes.
+ */
+ void updateDrawerState(int activeState, View activeDrawer) {
+ final int leftState = mLeftDragger.getViewDragState();
+ final int rightState = mRightDragger.getViewDragState();
+
+ final int state;
+ if (leftState == STATE_DRAGGING || rightState == STATE_DRAGGING) {
+ state = STATE_DRAGGING;
+ } else if (leftState == STATE_SETTLING || rightState == STATE_SETTLING) {
+ state = STATE_SETTLING;
+ } else {
+ state = STATE_IDLE;
+ }
+
+ if (activeDrawer != null && activeState == STATE_IDLE) {
+ final LayoutParams lp = (LayoutParams) activeDrawer.getLayoutParams();
+ if (lp.onScreen == 0) {
+ dispatchOnDrawerClosed(activeDrawer);
+ } else if (lp.onScreen == 1) {
+ dispatchOnDrawerOpened(activeDrawer);
+ }
+ }
+
+ if (state != mDrawerState) {
+ mDrawerState = state;
+
+ if (mListener != null) {
+ mListener.onDrawerStateChanged(state);
+ }
+ }
+ }
+
+ void dispatchOnDrawerClosed(View drawerView) {
+ final LayoutParams lp = (LayoutParams) drawerView.getLayoutParams();
+ if (lp.knownOpen) {
+ lp.knownOpen = false;
+ if (mListener != null) {
+ mListener.onDrawerClosed(drawerView);
+ }
+
+ updateChildrenImportantForAccessibility(drawerView, false);
+
+ // Only send WINDOW_STATE_CHANGE if the host has window focus. This
+ // may change if support for multiple foreground windows (e.g. IME)
+ // improves.
+ if (hasWindowFocus()) {
+ final View rootView = getRootView();
+ if (rootView != null) {
+ rootView.sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
+ }
+ }
+ }
+ }
+
+ void dispatchOnDrawerOpened(View drawerView) {
+ final LayoutParams lp = (LayoutParams) drawerView.getLayoutParams();
+ if (!lp.knownOpen) {
+ lp.knownOpen = true;
+ if (mListener != null) {
+ mListener.onDrawerOpened(drawerView);
+ }
+
+ updateChildrenImportantForAccessibility(drawerView, true);
+
+ // Only send WINDOW_STATE_CHANGE if the host has window focus.
+ if (hasWindowFocus()) {
+ sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
+ }
+
+ drawerView.requestFocus();
+ }
+ }
+
+ private void updateChildrenImportantForAccessibility(View drawerView, boolean isDrawerOpen) {
+ final int childCount = getChildCount();
+ for (int i = 0; i < childCount; i++) {
+ final View child = getChildAt(i);
+ if (!isDrawerOpen && !isDrawerView(child) || isDrawerOpen && child == drawerView) {
+ // Drawer is closed and this is a content view or this is an
+ // open drawer view, so it should be visible.
+ child.setImportantForAccessibility(View.IMPORTANT_FOR_ACCESSIBILITY_YES);
+ } else {
+ child.setImportantForAccessibility(View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS);
+ }
+ }
+ }
+
+ void dispatchOnDrawerSlide(View drawerView, float slideOffset) {
+ if (mListener != null) {
+ mListener.onDrawerSlide(drawerView, slideOffset);
+ }
+ }
+
+ void setDrawerViewOffset(View drawerView, float slideOffset) {
+ final LayoutParams lp = (LayoutParams) drawerView.getLayoutParams();
+ if (slideOffset == lp.onScreen) {
+ return;
+ }
+
+ lp.onScreen = slideOffset;
+ dispatchOnDrawerSlide(drawerView, slideOffset);
+ }
+
+ float getDrawerViewOffset(View drawerView) {
+ return ((LayoutParams) drawerView.getLayoutParams()).onScreen;
+ }
+
+ /**
+ * @return the absolute gravity of the child drawerView, resolved according to the current layout direction
+ */
+ int getDrawerViewAbsoluteGravity(View drawerView) {
+ final int gravity = ((LayoutParams) drawerView.getLayoutParams()).gravity;
+ return Gravity.getAbsoluteGravity(gravity, this.getLayoutDirection());
+ }
+
+ boolean checkDrawerViewAbsoluteGravity(View drawerView, int checkFor) {
+ final int absGravity = getDrawerViewAbsoluteGravity(drawerView);
+ return (absGravity & checkFor) == checkFor;
+ }
+
+ View findOpenDrawer() {
+ final int childCount = getChildCount();
+ for (int i = 0; i < childCount; i++) {
+ final View child = getChildAt(i);
+ if (((LayoutParams) child.getLayoutParams()).knownOpen) {
+ return child;
+ }
+ }
+ return null;
+ }
+
+ void moveDrawerToOffset(View drawerView, float slideOffset) {
+ final float oldOffset = getDrawerViewOffset(drawerView);
+ final int width = drawerView.getWidth();
+ final int oldPos = (int) (width * oldOffset);
+ final int newPos = (int) (width * slideOffset);
+ final int dx = newPos - oldPos;
+
+ drawerView.offsetLeftAndRight(checkDrawerViewAbsoluteGravity(drawerView, Gravity.LEFT) ? dx : -dx);
+ setDrawerViewOffset(drawerView, slideOffset);
+ }
+
+ /**
+ * @param gravity
+ * the gravity of the child to return. If specified as a relative value, it will be resolved according to
+ * the current layout direction.
+ * @return the drawer with the specified gravity
+ */
+ View findDrawerWithGravity(int gravity) {
+ final int absHorizGravity = Gravity.getAbsoluteGravity(gravity, this.getLayoutDirection()) & Gravity.HORIZONTAL_GRAVITY_MASK;
+ final int childCount = getChildCount();
+ for (int i = 0; i < childCount; i++) {
+ final View child = getChildAt(i);
+ final int childAbsGravity = getDrawerViewAbsoluteGravity(child);
+ if ((childAbsGravity & Gravity.HORIZONTAL_GRAVITY_MASK) == absHorizGravity) {
+ return child;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Simple gravity to string - only supports LEFT and RIGHT for debugging output.
+ *
+ * @param gravity
+ * Absolute gravity value
+ * @return LEFT or RIGHT as appropriate, or a hex string
+ */
+ static String gravityToString(int gravity) {
+ if ((gravity & Gravity.LEFT) == Gravity.LEFT) {
+ return "LEFT";
+ }
+ if ((gravity & Gravity.RIGHT) == Gravity.RIGHT) {
+ return "RIGHT";
+ }
+ return Integer.toHexString(gravity);
+ }
+
+ @Override
+ protected void onDetachedFromWindow() {
+ super.onDetachedFromWindow();
+ mFirstLayout = true;
+ }
+
+ @Override
+ protected void onAttachedToWindow() {
+ super.onAttachedToWindow();
+ mFirstLayout = true;
+ }
+
+ @Override
+ protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+ int widthMode = MeasureSpec.getMode(widthMeasureSpec);
+ int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+ int widthSize = MeasureSpec.getSize(widthMeasureSpec);
+ int heightSize = MeasureSpec.getSize(heightMeasureSpec);
+
+ if (widthMode != MeasureSpec.EXACTLY || heightMode != MeasureSpec.EXACTLY) {
+ if (isInEditMode()) {
+ // Don't crash the layout editor. Consume all of the space if specified
+ // or pick a magic number from thin air otherwise.
+ // TODO Better communication with tools of this bogus state.
+ // It will crash on a real device.
+ if (widthMode == MeasureSpec.AT_MOST) {
+ widthMode = MeasureSpec.EXACTLY;
+ } else if (widthMode == MeasureSpec.UNSPECIFIED) {
+ widthMode = MeasureSpec.EXACTLY;
+ widthSize = 300;
+ }
+ if (heightMode == MeasureSpec.AT_MOST) {
+ heightMode = MeasureSpec.EXACTLY;
+ } else if (heightMode == MeasureSpec.UNSPECIFIED) {
+ heightMode = MeasureSpec.EXACTLY;
+ heightSize = 300;
+ }
+ } else {
+ throw new IllegalArgumentException("DrawerLayout must be measured with MeasureSpec.EXACTLY.");
+ }
+ }
+
+ setMeasuredDimension(widthSize, heightSize);
+
+ final boolean applyInsets = mLastInsets != null && this.getFitsSystemWindows();
+ final int layoutDirection = this.getLayoutDirection();
+
+ // Gravity value for each drawer we've seen. Only one of each permitted.
+ int foundDrawers = 0;
+ final int childCount = getChildCount();
+ for (int i = 0; i < childCount; i++) {
+ final View child = getChildAt(i);
+
+ if (child.getVisibility() == GONE) {
+ continue;
+ }
+
+ final LayoutParams lp = (LayoutParams) child.getLayoutParams();
+
+ if (applyInsets) {
+ final int cgrav = Gravity.getAbsoluteGravity(lp.gravity, layoutDirection);
+ if (child.getFitsSystemWindows()) {
+ DrawerLayoutCompatApi21.dispatchChildInsets(child, mLastInsets, cgrav);
+ } else {
+ DrawerLayoutCompatApi21.applyMarginInsets(lp, mLastInsets, cgrav);
+ }
+ }
+
+ if (isContentView(child)) {
+ // Content views get measured at exactly the layout's size.
+ final int contentWidthSpec = MeasureSpec.makeMeasureSpec(widthSize - lp.leftMargin - lp.rightMargin, MeasureSpec.EXACTLY);
+ final int contentHeightSpec = MeasureSpec.makeMeasureSpec(heightSize - lp.topMargin - lp.bottomMargin, MeasureSpec.EXACTLY);
+ child.measure(contentWidthSpec, contentHeightSpec);
+ } else if (isDrawerView(child)) {
+ final int childGravity = getDrawerViewAbsoluteGravity(child) & Gravity.HORIZONTAL_GRAVITY_MASK;
+ if ((foundDrawers & childGravity) != 0) {
+ throw new IllegalStateException("Child drawer has absolute gravity " + gravityToString(childGravity) + " but this " + TAG
+ + " already has a " + "drawer view along that edge");
+ }
+ final int drawerWidthSpec = getChildMeasureSpec(widthMeasureSpec, mMinDrawerMargin + lp.leftMargin + lp.rightMargin, lp.width);
+ final int drawerHeightSpec = getChildMeasureSpec(heightMeasureSpec, lp.topMargin + lp.bottomMargin, lp.height);
+ child.measure(drawerWidthSpec, drawerHeightSpec);
+ } else {
+ throw new IllegalStateException("Child " + child + " at index " + i + " does not have a valid layout_gravity - must be Gravity.LEFT, "
+ + "Gravity.RIGHT or Gravity.NO_GRAVITY");
+ }
+ }
+ }
+
+ @Override
+ protected void onLayout(boolean changed, int l, int t, int r, int b) {
+ mInLayout = true;
+ final int width = r - l;
+ final int childCount = getChildCount();
+ for (int i = 0; i < childCount; i++) {
+ final View child = getChildAt(i);
+
+ if (child.getVisibility() == GONE) {
+ continue;
+ }
+
+ final LayoutParams lp = (LayoutParams) child.getLayoutParams();
+
+ if (isContentView(child)) {
+ child.layout(lp.leftMargin, lp.topMargin, lp.leftMargin + child.getMeasuredWidth(), lp.topMargin + child.getMeasuredHeight());
+ } else { // Drawer, if it wasn't onMeasure would have thrown an exception.
+ final int childWidth = child.getMeasuredWidth();
+ final int childHeight = child.getMeasuredHeight();
+ int childLeft;
+
+ final float newOffset;
+ if (checkDrawerViewAbsoluteGravity(child, Gravity.LEFT)) {
+ childLeft = -childWidth + (int) (childWidth * lp.onScreen);
+ newOffset = (float) (childWidth + childLeft) / childWidth;
+ } else { // Right; onMeasure checked for us.
+ childLeft = width - (int) (childWidth * lp.onScreen);
+ newOffset = (float) (width - childLeft) / childWidth;
+ }
+
+ final boolean changeOffset = newOffset != lp.onScreen;
+
+ final int vgrav = lp.gravity & Gravity.VERTICAL_GRAVITY_MASK;
+
+ switch (vgrav) {
+ default:
+ case Gravity.TOP: {
+ child.layout(childLeft, lp.topMargin, childLeft + childWidth, lp.topMargin + childHeight);
+ break;
+ }
+
+ case Gravity.BOTTOM: {
+ final int height = b - t;
+ child.layout(childLeft, height - lp.bottomMargin - child.getMeasuredHeight(), childLeft + childWidth, height - lp.bottomMargin);
+ break;
+ }
+
+ case Gravity.CENTER_VERTICAL: {
+ final int height = b - t;
+ int childTop = (height - childHeight) / 2;
+
+ // Offset for margins. If things don't fit right because of
+ // bad measurement before, oh well.
+ if (childTop < lp.topMargin) {
+ childTop = lp.topMargin;
+ } else if (childTop + childHeight > height - lp.bottomMargin) {
+ childTop = height - lp.bottomMargin - childHeight;
+ }
+ child.layout(childLeft, childTop, childLeft + childWidth, childTop + childHeight);
+ break;
+ }
+ }
+
+ if (changeOffset) {
+ setDrawerViewOffset(child, newOffset);
+ }
+
+ final int newVisibility = lp.onScreen > 0 ? VISIBLE : INVISIBLE;
+ if (child.getVisibility() != newVisibility) {
+ child.setVisibility(newVisibility);
+ }
+ }
+ }
+ mInLayout = false;
+ mFirstLayout = false;
+ }
+
+ @Override
+ public void requestLayout() {
+ if (!mInLayout) {
+ super.requestLayout();
+ }
+ }
+
+ @Override
+ public void computeScroll() {
+ final int childCount = getChildCount();
+ float scrimOpacity = 0;
+ for (int i = 0; i < childCount; i++) {
+ final float onscreen = ((LayoutParams) getChildAt(i).getLayoutParams()).onScreen;
+ scrimOpacity = Math.max(scrimOpacity, onscreen);
+ }
+ mScrimOpacity = scrimOpacity;
+
+ // "|" used on purpose; both need to run.
+ if (mLeftDragger.continueSettling(true) | mRightDragger.continueSettling(true)) {
+ this.postInvalidateOnAnimation();
+ }
+ }
+
+ private static boolean hasOpaqueBackground(View v) {
+ final Drawable bg = v.getBackground();
+ if (bg != null) {
+ return bg.getOpacity() == PixelFormat.OPAQUE;
+ }
+ return false;
+ }
+
+ /**
+ * Set a drawable to draw in the insets area for the status bar. Note that this will only be activated if this
+ * DrawerLayout fitsSystemWindows.
+ *
+ * @param bg
+ * Background drawable to draw behind the status bar
+ */
+ public void setStatusBarBackground(Drawable bg) {
+ mStatusBarBackground = bg;
+ invalidate();
+ }
+
+ /**
+ * Gets the drawable used to draw in the insets area for the status bar.
+ *
+ * @return The status bar background drawable, or null if none set
+ */
+ public Drawable getStatusBarBackgroundDrawable() {
+ return mStatusBarBackground;
+ }
+
+ /**
+ * Set a drawable to draw in the insets area for the status bar. Note that this will only be activated if this
+ * DrawerLayout fitsSystemWindows.
+ *
+ * @param resId
+ * Resource id of a background drawable to draw behind the status bar
+ */
+ public void setStatusBarBackground(int resId) {
+ mStatusBarBackground = resId != 0 ? getContext().getDrawable(resId) : null;
+ invalidate();
+ }
+
+ /**
+ * Set a drawable to draw in the insets area for the status bar. Note that this will only be activated if this
+ * DrawerLayout fitsSystemWindows.
+ *
+ * @param color
+ * Color to use as a background drawable to draw behind the status bar in 0xAARRGGBB format.
+ */
+ public void setStatusBarBackgroundColor(int color) {
+ mStatusBarBackground = new ColorDrawable(color);
+ invalidate();
+ }
+
+ @Override
+ public void onDraw(Canvas c) {
+ super.onDraw(c);
+ if (mDrawStatusBarBackground && mStatusBarBackground != null) {
+ final int inset = DrawerLayoutCompatApi21.getTopInset(mLastInsets);
+ if (inset > 0) {
+ mStatusBarBackground.setBounds(0, 0, getWidth(), inset);
+ mStatusBarBackground.draw(c);
+ }
+ }
+ }
+
+ @Override
+ protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
+ final int height = getHeight();
+ final boolean drawingContent = isContentView(child);
+ int clipLeft = 0, clipRight = getWidth();
+
+ final int restoreCount = canvas.save();
+ if (drawingContent) {
+ final int childCount = getChildCount();
+ for (int i = 0; i < childCount; i++) {
+ final View v = getChildAt(i);
+ if (v == child || v.getVisibility() != VISIBLE || !hasOpaqueBackground(v) || !isDrawerView(v) || v.getHeight() < height) {
+ continue;
+ }
+
+ if (checkDrawerViewAbsoluteGravity(v, Gravity.LEFT)) {
+ final int vright = v.getRight();
+ if (vright > clipLeft) clipLeft = vright;
+ } else {
+ final int vleft = v.getLeft();
+ if (vleft < clipRight) clipRight = vleft;
+ }
+ }
+ canvas.clipRect(clipLeft, 0, clipRight, getHeight());
+ }
+ final boolean result = super.drawChild(canvas, child, drawingTime);
+ canvas.restoreToCount(restoreCount);
+
+ if (mScrimOpacity > 0 && drawingContent) {
+ final int baseAlpha = (mScrimColor & 0xff000000) >>> 24;
+ final int imag = (int) (baseAlpha * mScrimOpacity);
+ final int color = imag << 24 | (mScrimColor & 0xffffff);
+ mScrimPaint.setColor(color);
+
+ canvas.drawRect(clipLeft, 0, clipRight, getHeight(), mScrimPaint);
+ } else if (mShadowLeft != null && checkDrawerViewAbsoluteGravity(child, Gravity.LEFT)) {
+ final int shadowWidth = mShadowLeft.getIntrinsicWidth();
+ final int childRight = child.getRight();
+ final int drawerPeekDistance = mLeftDragger.getEdgeSize();
+ final float alpha = Math.max(0, Math.min((float) childRight / drawerPeekDistance, 1.f));
+ mShadowLeft.setBounds(childRight, child.getTop(), childRight + shadowWidth, child.getBottom());
+ mShadowLeft.setAlpha((int) (0xff * alpha));
+ mShadowLeft.draw(canvas);
+ } else if (mShadowRight != null && checkDrawerViewAbsoluteGravity(child, Gravity.RIGHT)) {
+ final int shadowWidth = mShadowRight.getIntrinsicWidth();
+ final int childLeft = child.getLeft();
+ final int showing = getWidth() - childLeft;
+ final int drawerPeekDistance = mRightDragger.getEdgeSize();
+ final float alpha = Math.max(0, Math.min((float) showing / drawerPeekDistance, 1.f));
+ mShadowRight.setBounds(childLeft - shadowWidth, child.getTop(), childLeft, child.getBottom());
+ mShadowRight.setAlpha((int) (0xff * alpha));
+ mShadowRight.draw(canvas);
+ }
+ return result;
+ }
+
+ boolean isContentView(View child) {
+ return ((LayoutParams) child.getLayoutParams()).gravity == Gravity.NO_GRAVITY;
+ }
+
+ boolean isDrawerView(View child) {
+ final int gravity = ((LayoutParams) child.getLayoutParams()).gravity;
+ final int absGravity = Gravity.getAbsoluteGravity(gravity, child.getLayoutDirection());
+ return (absGravity & (Gravity.LEFT | Gravity.RIGHT)) != 0;
+ }
+
+ @Override
+ public boolean onInterceptTouchEvent(MotionEvent ev) {
+ final int action = ev.getActionMasked();
+
+ // "|" used deliberately here; both methods should be invoked.
+ final boolean interceptForDrag = mLeftDragger.shouldInterceptTouchEvent(ev) | mRightDragger.shouldInterceptTouchEvent(ev);
+
+ boolean interceptForTap = false;
+
+ switch (action) {
+ case MotionEvent.ACTION_DOWN: {
+ final float x = ev.getX();
+ final float y = ev.getY();
+ mInitialMotionX = x;
+ mInitialMotionY = y;
+ if (mScrimOpacity > 0) {
+ final View child = mLeftDragger.findTopChildUnder((int) x, (int) y);
+ if (child != null && isContentView(child)) {
+ interceptForTap = true;
+ }
+ }
+ mChildrenCanceledTouch = false;
+ break;
+ }
+
+ case MotionEvent.ACTION_MOVE: {
+ // If we cross the touch slop, don't perform the delayed peek for an edge touch.
+ if (mLeftDragger.checkTouchSlop(ViewDragHelper.DIRECTION_ALL)) {
+ mLeftCallback.removeCallbacks();
+ mRightCallback.removeCallbacks();
+ }
+ break;
+ }
+
+ case MotionEvent.ACTION_CANCEL:
+ case MotionEvent.ACTION_UP: {
+ closeDrawers(true);
+ mChildrenCanceledTouch = false;
+ }
+ }
+
+ return interceptForDrag || interceptForTap || hasPeekingDrawer() || mChildrenCanceledTouch;
+ }
+
+ @SuppressLint("ClickableViewAccessibility")
+ @Override
+ public boolean onTouchEvent(MotionEvent ev) {
+ mLeftDragger.processTouchEvent(ev);
+ mRightDragger.processTouchEvent(ev);
+
+ final int action = ev.getAction();
+ boolean wantTouchEvents = true;
+
+ switch (action & MotionEvent.ACTION_MASK) {
+ case MotionEvent.ACTION_DOWN: {
+ final float x = ev.getX();
+ final float y = ev.getY();
+ mInitialMotionX = x;
+ mInitialMotionY = y;
+ mChildrenCanceledTouch = false;
+ break;
+ }
+
+ case MotionEvent.ACTION_UP: {
+ final float x = ev.getX();
+ final float y = ev.getY();
+ boolean peekingOnly = true;
+ final View touchedView = mLeftDragger.findTopChildUnder((int) x, (int) y);
+ if (touchedView != null && isContentView(touchedView)) {
+ final float dx = x - mInitialMotionX;
+ final float dy = y - mInitialMotionY;
+ final int slop = mLeftDragger.getTouchSlop();
+ if (dx * dx + dy * dy < slop * slop) {
+ // Taps close a dimmed open drawer but only if it isn't locked open.
+ final View openDrawer = findOpenDrawer();
+ if (openDrawer != null) {
+ peekingOnly = getDrawerLockMode(openDrawer) == LOCK_MODE_LOCKED_OPEN;
+ }
+ }
+ }
+ closeDrawers(peekingOnly);
+ break;
+ }
+
+ case MotionEvent.ACTION_CANCEL: {
+ closeDrawers(true);
+ mChildrenCanceledTouch = false;
+ break;
+ }
+ }
+
+ return wantTouchEvents;
+ }
+
+ @Override
+ public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
+ if (CHILDREN_DISALLOW_INTERCEPT/*
+ * || (!mLeftDragger.isEdgeTouched(ViewDragHelper.EDGE_LEFT) &&
+ * !mRightDragger.isEdgeTouched(ViewDragHelper.EDGE_RIGHT))
+ */) {
+ // If we have an edge touch we want to skip this and track it for later instead.
+ super.requestDisallowInterceptTouchEvent(disallowIntercept);
+ }
+ if (disallowIntercept) {
+ closeDrawers(true);
+ }
+ }
+
+ /**
+ * Close all currently open drawer views by animating them out of view.
+ */
+ public void closeDrawers() {
+ closeDrawers(false);
+ }
+
+ void closeDrawers(boolean peekingOnly) {
+ boolean needsInvalidate = false;
+ final int childCount = getChildCount();
+ for (int i = 0; i < childCount; i++) {
+ final View child = getChildAt(i);
+ final LayoutParams lp = (LayoutParams) child.getLayoutParams();
+
+ if (!isDrawerView(child) || (peekingOnly && !lp.isPeeking)) {
+ continue;
+ }
+
+ final int childWidth = child.getWidth();
+
+ if (checkDrawerViewAbsoluteGravity(child, Gravity.LEFT)) {
+ needsInvalidate |= mLeftDragger.smoothSlideViewTo(child, -childWidth, child.getTop());
+ } else {
+ needsInvalidate |= mRightDragger.smoothSlideViewTo(child, getWidth(), child.getTop());
+ }
+
+ lp.isPeeking = false;
+ }
+
+ mLeftCallback.removeCallbacks();
+ mRightCallback.removeCallbacks();
+
+ if (needsInvalidate) {
+ invalidate();
+ }
+ }
+
+ /**
+ * Open the specified drawer view by animating it into view.
+ *
+ * @param drawerView
+ * Drawer view to open
+ */
+ public void openDrawer(View drawerView) {
+ if (!isDrawerView(drawerView)) {
+ throw new IllegalArgumentException("View " + drawerView + " is not a sliding drawer");
+ }
+
+ if (mFirstLayout) {
+ final LayoutParams lp = (LayoutParams) drawerView.getLayoutParams();
+ lp.onScreen = 1.f;
+ lp.knownOpen = true;
+
+ updateChildrenImportantForAccessibility(drawerView, true);
+ } else {
+ if (checkDrawerViewAbsoluteGravity(drawerView, Gravity.LEFT)) {
+ mLeftDragger.smoothSlideViewTo(drawerView, 0, drawerView.getTop());
+ } else {
+ mRightDragger.smoothSlideViewTo(drawerView, getWidth() - drawerView.getWidth(), drawerView.getTop());
+ }
+ }
+ invalidate();
+ }
+
+ /**
+ * Open the specified drawer by animating it out of view.
+ *
+ * @param gravity
+ * Gravity.LEFT to move the left drawer or Gravity.RIGHT for the right. Gravity.START or Gravity.END may
+ * also be used.
+ */
+ public void openDrawer(int gravity) {
+ final View drawerView = findDrawerWithGravity(gravity);
+ if (drawerView == null) {
+ throw new IllegalArgumentException("No drawer view found with gravity " + gravityToString(gravity));
+ }
+ openDrawer(drawerView);
+ }
+
+ /**
+ * Close the specified drawer view by animating it into view.
+ *
+ * @param drawerView
+ * Drawer view to close
+ */
+ public void closeDrawer(View drawerView) {
+ if (!isDrawerView(drawerView)) {
+ throw new IllegalArgumentException("View " + drawerView + " is not a sliding drawer");
+ }
+
+ if (mFirstLayout) {
+ final LayoutParams lp = (LayoutParams) drawerView.getLayoutParams();
+ lp.onScreen = 0.f;
+ lp.knownOpen = false;
+ } else {
+ if (checkDrawerViewAbsoluteGravity(drawerView, Gravity.LEFT)) {
+ mLeftDragger.smoothSlideViewTo(drawerView, -drawerView.getWidth(), drawerView.getTop());
+ } else {
+ mRightDragger.smoothSlideViewTo(drawerView, getWidth(), drawerView.getTop());
+ }
+ }
+ invalidate();
+ }
+
+ /**
+ * Close the specified drawer by animating it out of view.
+ *
+ * @param gravity
+ * Gravity.LEFT to move the left drawer or Gravity.RIGHT for the right. Gravity.START or Gravity.END may
+ * also be used.
+ */
+ public void closeDrawer(int gravity) {
+ final View drawerView = findDrawerWithGravity(gravity);
+ if (drawerView == null) {
+ throw new IllegalArgumentException("No drawer view found with gravity " + gravityToString(gravity));
+ }
+ closeDrawer(drawerView);
+ }
+
+ /**
+ * Check if the given drawer view is currently in an open state. To be considered "open" the drawer must have
+ * settled into its fully visible state. To check for partial visibility use
+ * {@link #isDrawerVisible(android.view.View)}.
+ *
+ * @param drawer
+ * Drawer view to check
+ * @return true if the given drawer view is in an open state
+ * @see #isDrawerVisible(android.view.View)
+ */
+ public boolean isDrawerOpen(View drawer) {
+ if (!isDrawerView(drawer)) {
+ throw new IllegalArgumentException("View " + drawer + " is not a drawer");
+ }
+ return ((LayoutParams) drawer.getLayoutParams()).knownOpen;
+ }
+
+ /**
+ * Check if the given drawer view is currently in an open state. To be considered "open" the drawer must have
+ * settled into its fully visible state. If there is no drawer with the given gravity this method will return false.
+ *
+ * @param drawerGravity
+ * Gravity of the drawer to check
+ * @return true if the given drawer view is in an open state
+ */
+ public boolean isDrawerOpen(int drawerGravity) {
+ final View drawerView = findDrawerWithGravity(drawerGravity);
+ if (drawerView != null) {
+ return isDrawerOpen(drawerView);
+ }
+ return false;
+ }
+
+ /**
+ * Check if a given drawer view is currently visible on-screen. The drawer may be only peeking onto the screen,
+ * fully extended, or anywhere inbetween.
+ *
+ * @param drawer
+ * Drawer view to check
+ * @return true if the given drawer is visible on-screen
+ * @see #isDrawerOpen(android.view.View)
+ */
+ public boolean isDrawerVisible(View drawer) {
+ if (!isDrawerView(drawer)) {
+ throw new IllegalArgumentException("View " + drawer + " is not a drawer");
+ }
+ return ((LayoutParams) drawer.getLayoutParams()).onScreen > 0;
+ }
+
+ /**
+ * Check if a given drawer view is currently visible on-screen. The drawer may be only peeking onto the screen,
+ * fully extended, or anywhere in between. If there is no drawer with the given gravity this method will return
+ * false.
+ *
+ * @param drawerGravity
+ * Gravity of the drawer to check
+ * @return true if the given drawer is visible on-screen
+ */
+ public boolean isDrawerVisible(int drawerGravity) {
+ final View drawerView = findDrawerWithGravity(drawerGravity);
+ if (drawerView != null) {
+ return isDrawerVisible(drawerView);
+ }
+ return false;
+ }
+
+ private boolean hasPeekingDrawer() {
+ final int childCount = getChildCount();
+ for (int i = 0; i < childCount; i++) {
+ final LayoutParams lp = (LayoutParams) getChildAt(i).getLayoutParams();
+ if (lp.isPeeking) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
+ return new LayoutParams(android.view.ViewGroup.LayoutParams.MATCH_PARENT, android.view.ViewGroup.LayoutParams.MATCH_PARENT);
+ }
+
+ @Override
+ protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
+ return p instanceof LayoutParams ? new LayoutParams((LayoutParams) p) : p instanceof ViewGroup.MarginLayoutParams ? new LayoutParams(
+ (MarginLayoutParams) p) : new LayoutParams(p);
+ }
+
+ @Override
+ protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
+ return p instanceof LayoutParams && super.checkLayoutParams(p);
+ }
+
+ @Override
+ public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
+ return new LayoutParams(getContext(), attrs);
+ }
+
+ private boolean hasVisibleDrawer() {
+ return findVisibleDrawer() != null;
+ }
+
+ View findVisibleDrawer() {
+ final int childCount = getChildCount();
+ for (int i = 0; i < childCount; i++) {
+ final View child = getChildAt(i);
+ if (isDrawerView(child) && isDrawerVisible(child)) {
+ return child;
+ }
+ }
+ return null;
+ }
+
+ void cancelChildViewTouch() {
+ // Cancel child touches
+ if (!mChildrenCanceledTouch) {
+ final long now = SystemClock.uptimeMillis();
+ final MotionEvent cancelEvent = MotionEvent.obtain(now, now, MotionEvent.ACTION_CANCEL, 0.0f, 0.0f, 0);
+ final int childCount = getChildCount();
+ for (int i = 0; i < childCount; i++) {
+ getChildAt(i).dispatchTouchEvent(cancelEvent);
+ }
+ cancelEvent.recycle();
+ mChildrenCanceledTouch = true;
+ }
+ }
+
+ @Override
+ public boolean onKeyDown(int keyCode, KeyEvent event) {
+ if (keyCode == KeyEvent.KEYCODE_BACK && hasVisibleDrawer()) {
+ event.startTracking();
+ return true;
+ }
+ return super.onKeyDown(keyCode, event);
+ }
+
+ @Override
+ public boolean onKeyUp(int keyCode, KeyEvent event) {
+ if (keyCode == KeyEvent.KEYCODE_BACK) {
+ final View visibleDrawer = findVisibleDrawer();
+ if (visibleDrawer != null && getDrawerLockMode(visibleDrawer) == LOCK_MODE_UNLOCKED) {
+ closeDrawers();
+ }
+ return visibleDrawer != null;
+ }
+ return super.onKeyUp(keyCode, event);
+ }
+
+ @Override
+ protected void onRestoreInstanceState(Parcelable state) {
+ final SavedState ss = (SavedState) state;
+ super.onRestoreInstanceState(ss.getSuperState());
+
+ if (ss.openDrawerGravity != Gravity.NO_GRAVITY) {
+ final View toOpen = findDrawerWithGravity(ss.openDrawerGravity);
+ if (toOpen != null) {
+ openDrawer(toOpen);
+ }
+ }
+
+ setDrawerLockMode(ss.lockModeLeft, Gravity.LEFT);
+ setDrawerLockMode(ss.lockModeRight, Gravity.RIGHT);
+ }
+
+ @Override
+ protected Parcelable onSaveInstanceState() {
+ final Parcelable superState = super.onSaveInstanceState();
+ final SavedState ss = new SavedState(superState);
+
+ final View openDrawer = findOpenDrawer();
+ if (openDrawer != null) {
+ ss.openDrawerGravity = ((LayoutParams) openDrawer.getLayoutParams()).gravity;
+ }
+
+ ss.lockModeLeft = mLockModeLeft;
+ ss.lockModeRight = mLockModeRight;
+
+ return ss;
+ }
+
+ @Override
+ public void addView(View child, int index, ViewGroup.LayoutParams params) {
+ super.addView(child, index, params);
+
+ final View openDrawer = findOpenDrawer();
+ if (openDrawer != null || isDrawerView(child)) {
+ // A drawer is already open or the new view is a drawer, so the
+ // new view should start out hidden.
+ child.setImportantForAccessibility(View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS);
+ } else {
+ // Otherwise this is a content view and no drawer is open, so the
+ // new view should start out visible.
+ child.setImportantForAccessibility(View.IMPORTANT_FOR_ACCESSIBILITY_YES);
+ }
+
+ // We only need a delegate here if the framework doesn't understand
+ // NO_HIDE_DESCENDANTS importance.
+ if (!CAN_HIDE_DESCENDANTS) {
+ child.setAccessibilityDelegate(mChildAccessibilityDelegate);
+ }
+ }
+
+ static boolean includeChildForAccessibility(View child) {
+ // If the child is not important for accessibility we make
+ // sure this hides the entire subtree rooted at it as the
+ // IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDATS is not
+ // supported on older platforms but we want to hide the entire
+ // content and not opened drawers if a drawer is opened.
+ return child.getImportantForAccessibility() != View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
+ && child.getImportantForAccessibility() != View.IMPORTANT_FOR_ACCESSIBILITY_NO;
+ }
+
+ /**
+ * State persisted across instances
+ */
+ protected static class SavedState extends BaseSavedState {
+ int openDrawerGravity = Gravity.NO_GRAVITY;
+ int lockModeLeft = LOCK_MODE_UNLOCKED;
+ int lockModeRight = LOCK_MODE_UNLOCKED;
+
+ public SavedState(Parcel in) {
+ super(in);
+ openDrawerGravity = in.readInt();
+ }
+
+ public SavedState(Parcelable superState) {
+ super(superState);
+ }
+
+ @Override
+ public void writeToParcel(Parcel dest, int flags) {
+ super.writeToParcel(dest, flags);
+ dest.writeInt(openDrawerGravity);
+ }
+ }
+
+ private class ViewDragCallback extends ViewDragHelper.Callback {
+ private final int mAbsGravity;
+ private ViewDragHelper mDragger;
+
+ private final Runnable mPeekRunnable = new Runnable() {
+ @Override
+ public void run() {
+ peekDrawer();
+ }
+ };
+
+ public ViewDragCallback(int gravity) {
+ mAbsGravity = gravity;
+ }
+
+ public void setDragger(ViewDragHelper dragger) {
+ mDragger = dragger;
+ }
+
+ public void removeCallbacks() {
+ DrawerLayout.this.removeCallbacks(mPeekRunnable);
+ }
+
+ @Override
+ public boolean tryCaptureView(View child, int pointerId) {
+ // Only capture views where the gravity matches what we're looking for.
+ // This lets us use two ViewDragHelpers, one for each side drawer.
+ return isDrawerView(child) && checkDrawerViewAbsoluteGravity(child, mAbsGravity) && getDrawerLockMode(child) == LOCK_MODE_UNLOCKED;
+ }
+
+ @Override
+ public void onViewDragStateChanged(int state) {
+ updateDrawerState(state, mDragger.getCapturedView());
+ }
+
+ @Override
+ public void onViewPositionChanged(View changedView, int left, int top, int dx, int dy) {
+ float offset;
+ final int childWidth = changedView.getWidth();
+
+ // This reverses the positioning shown in onLayout.
+ if (checkDrawerViewAbsoluteGravity(changedView, Gravity.LEFT)) {
+ offset = (float) (childWidth + left) / childWidth;
+ } else {
+ final int width = getWidth();
+ offset = (float) (width - left) / childWidth;
+ }
+ setDrawerViewOffset(changedView, offset);
+ changedView.setVisibility(offset == 0 ? INVISIBLE : VISIBLE);
+ invalidate();
+ }
+
+ @Override
+ public void onViewCaptured(View capturedChild, int activePointerId) {
+ final LayoutParams lp = (LayoutParams) capturedChild.getLayoutParams();
+ lp.isPeeking = false;
+
+ closeOtherDrawer();
+ }
+
+ private void closeOtherDrawer() {
+ final int otherGrav = mAbsGravity == Gravity.LEFT ? Gravity.RIGHT : Gravity.LEFT;
+ final View toClose = findDrawerWithGravity(otherGrav);
+ if (toClose != null) {
+ closeDrawer(toClose);
+ }
+ }
+
+ @Override
+ public void onViewReleased(View releasedChild, float xvel, float yvel) {
+ // Offset is how open the drawer is, therefore left/right values
+ // are reversed from one another.
+ final float offset = getDrawerViewOffset(releasedChild);
+ final int childWidth = releasedChild.getWidth();
+
+ int left;
+ if (checkDrawerViewAbsoluteGravity(releasedChild, Gravity.LEFT)) {
+ left = xvel > 0 || xvel == 0 && offset > 0.5f ? 0 : -childWidth;
+ } else {
+ final int width = getWidth();
+ left = xvel < 0 || xvel == 0 && offset > 0.5f ? width - childWidth : width;
+ }
+
+ mDragger.settleCapturedViewAt(left, releasedChild.getTop());
+ invalidate();
+ }
+
+ @Override
+ public void onEdgeTouched(int edgeFlags, int pointerId) {
+ postDelayed(mPeekRunnable, PEEK_DELAY);
+ }
+
+ void peekDrawer() {
+ final View toCapture;
+ final int childLeft;
+ final int peekDistance = mDragger.getEdgeSize();
+ final boolean leftEdge = mAbsGravity == Gravity.LEFT;
+ if (leftEdge) {
+ toCapture = findDrawerWithGravity(Gravity.LEFT);
+ childLeft = (toCapture != null ? -toCapture.getWidth() : 0) + peekDistance;
+ } else {
+ toCapture = findDrawerWithGravity(Gravity.RIGHT);
+ childLeft = getWidth() - peekDistance;
+ }
+ // Only peek if it would mean making the drawer more visible and the drawer isn't locked
+ if (toCapture != null && ((leftEdge && toCapture.getLeft() < childLeft) || (!leftEdge && toCapture.getLeft() > childLeft))
+ && getDrawerLockMode(toCapture) == LOCK_MODE_UNLOCKED) {
+ final LayoutParams lp = (LayoutParams) toCapture.getLayoutParams();
+ mDragger.smoothSlideViewTo(toCapture, childLeft, toCapture.getTop());
+ lp.isPeeking = true;
+ invalidate();
+
+ closeOtherDrawer();
+
+ cancelChildViewTouch();
+ }
+ }
+
+ @Override
+ public boolean onEdgeLock(int edgeFlags) {
+ if (ALLOW_EDGE_LOCK) {
+ final View drawer = findDrawerWithGravity(mAbsGravity);
+ if (drawer != null && !isDrawerOpen(drawer)) {
+ closeDrawer(drawer);
+ }
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public void onEdgeDragStarted(int edgeFlags, int pointerId) {
+ final View toCapture;
+ if ((edgeFlags & ViewDragHelper.EDGE_LEFT) == ViewDragHelper.EDGE_LEFT) {
+ toCapture = findDrawerWithGravity(Gravity.LEFT);
+ } else {
+ toCapture = findDrawerWithGravity(Gravity.RIGHT);
+ }
+
+ if (toCapture != null && getDrawerLockMode(toCapture) == LOCK_MODE_UNLOCKED) {
+ mDragger.captureChildView(toCapture, pointerId);
+ }
+ }
+
+ @Override
+ public int getViewHorizontalDragRange(View child) {
+ return isDrawerView(child) ? child.getWidth() : 0;
+ }
+
+ @Override
+ public int clampViewPositionHorizontal(View child, int left, int dx) {
+ if (checkDrawerViewAbsoluteGravity(child, Gravity.LEFT)) {
+ return Math.max(-child.getWidth(), Math.min(left, 0));
+ } else {
+ final int width = getWidth();
+ return Math.max(width - child.getWidth(), Math.min(left, width));
+ }
+ }
+
+ @Override
+ public int clampViewPositionVertical(View child, int top, int dy) {
+ return child.getTop();
+ }
+ }
+
+ public static class LayoutParams extends ViewGroup.MarginLayoutParams {
+
+ public int gravity = Gravity.NO_GRAVITY;
+ float onScreen;
+ boolean isPeeking;
+ boolean knownOpen;
+
+ public LayoutParams(Context c, AttributeSet attrs) {
+ super(c, attrs);
+
+ final TypedArray a = c.obtainStyledAttributes(attrs, LAYOUT_ATTRS);
+ this.gravity = a.getInt(0, Gravity.NO_GRAVITY);
+ a.recycle();
+ }
+
+ public LayoutParams(int width, int height) {
+ super(width, height);
+ }
+
+ public LayoutParams(int width, int height, int gravity) {
+ this(width, height);
+ this.gravity = gravity;
+ }
+
+ public LayoutParams(LayoutParams source) {
+ super(source);
+ this.gravity = source.gravity;
+ }
+
+ public LayoutParams(ViewGroup.LayoutParams source) {
+ super(source);
+ }
+
+ public LayoutParams(ViewGroup.MarginLayoutParams source) {
+ super(source);
+ }
+ }
+
+ class AccessibilityDelegate extends android.view.View.AccessibilityDelegate {
+ @Override
+ public void onInitializeAccessibilityNodeInfo(View host, AccessibilityNodeInfo info) {
+ super.onInitializeAccessibilityNodeInfo(host, info);
+
+ info.setClassName(DrawerLayout.class.getName());
+
+ // This view reports itself as focusable so that it can intercept
+ // the back button, but we should prevent this view from reporting
+ // itself as focusable to accessibility services.
+ info.setFocusable(false);
+ info.setFocused(false);
+ }
+
+ @Override
+ public void onInitializeAccessibilityEvent(View host, AccessibilityEvent event) {
+ super.onInitializeAccessibilityEvent(host, event);
+
+ event.setClassName(DrawerLayout.class.getName());
+ }
+
+ @Override
+ public boolean dispatchPopulateAccessibilityEvent(View host, AccessibilityEvent event) {
+ // Special case to handle window state change events. As far as
+ // accessibility services are concerned, state changes from
+ // DrawerLayout invalidate the entire contents of the screen (like
+ // an Activity or Dialog) and they should announce the title of the
+ // new content.
+ if (event.getEventType() == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED) {
+ final List eventText = event.getText();
+ final View visibleDrawer = findVisibleDrawer();
+ if (visibleDrawer != null) {
+ final int edgeGravity = getDrawerViewAbsoluteGravity(visibleDrawer);
+ final CharSequence title = getDrawerTitle(edgeGravity);
+ if (title != null) {
+ eventText.add(title);
+ }
+ }
+
+ return true;
+ }
+
+ return super.dispatchPopulateAccessibilityEvent(host, event);
+ }
+
+ @Override
+ public boolean onRequestSendAccessibilityEvent(ViewGroup host, View child, AccessibilityEvent event) {
+ if (CAN_HIDE_DESCENDANTS || includeChildForAccessibility(child)) {
+ return super.onRequestSendAccessibilityEvent(host, child, event);
+ }
+ return false;
+ }
+ }
+
+ final class ChildAccessibilityDelegate extends AccessibilityDelegate {
+ @Override
+ public void onInitializeAccessibilityNodeInfo(View child, AccessibilityNodeInfo info) {
+ super.onInitializeAccessibilityNodeInfo(child, info);
+
+ if (!includeChildForAccessibility(child)) {
+ // If we are ignoring the sub-tree rooted at the child,
+ // break the connection to the rest of the node tree.
+ // For details refer to includeChildForAccessibility.
+ info.setParent(null);
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/termux/drawer/DrawerLayoutCompatApi21.java b/app/src/main/java/com/termux/drawer/DrawerLayoutCompatApi21.java
new file mode 100644
index 0000000000..f3fe02774b
--- /dev/null
+++ b/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();
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/termux/drawer/ViewDragHelper.java b/app/src/main/java/com/termux/drawer/ViewDragHelper.java
new file mode 100644
index 0000000000..4b519fdad4
--- /dev/null
+++ b/app/src/main/java/com/termux/drawer/ViewDragHelper.java
@@ -0,0 +1,1525 @@
+package com.termux.drawer;
+
+/*
+ * Copyright (C) 2013 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.content.Context;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.view.ViewGroup;
+import android.view.animation.Interpolator;
+import android.widget.Scroller;
+
+import java.util.Arrays;
+
+/**
+ * ViewDragHelper is a utility class for writing custom ViewGroups. It offers a number of useful operations and state
+ * tracking for allowing a user to drag and reposition views within their parent ViewGroup.
+ */
+public class ViewDragHelper {
+
+ /**
+ * A null/invalid pointer ID.
+ */
+ public static final int INVALID_POINTER = -1;
+
+ /**
+ * A view is not currently being dragged or animating as a result of a fling/snap.
+ */
+ public static final int STATE_IDLE = 0;
+
+ /**
+ * A view is currently being dragged. The position is currently changing as a result of user input or simulated user
+ * input.
+ */
+ public static final int STATE_DRAGGING = 1;
+
+ /**
+ * A view is currently settling into place as a result of a fling or predefined non-interactive motion.
+ */
+ public static final int STATE_SETTLING = 2;
+
+ /**
+ * Edge flag indicating that the left edge should be affected.
+ */
+ public static final int EDGE_LEFT = 1 << 0;
+
+ /**
+ * Edge flag indicating that the right edge should be affected.
+ */
+ public static final int EDGE_RIGHT = 1 << 1;
+
+ /**
+ * Edge flag indicating that the top edge should be affected.
+ */
+ public static final int EDGE_TOP = 1 << 2;
+
+ /**
+ * Edge flag indicating that the bottom edge should be affected.
+ */
+ public static final int EDGE_BOTTOM = 1 << 3;
+
+ /**
+ * Edge flag set indicating all edges should be affected.
+ */
+ public static final int EDGE_ALL = EDGE_LEFT | EDGE_TOP | EDGE_RIGHT | EDGE_BOTTOM;
+
+ /**
+ * Indicates that a check should occur along the horizontal axis
+ */
+ public static final int DIRECTION_HORIZONTAL = 1 << 0;
+
+ /**
+ * Indicates that a check should occur along the vertical axis
+ */
+ public static final int DIRECTION_VERTICAL = 1 << 1;
+
+ /**
+ * Indicates that a check should occur along all axes
+ */
+ public static final int DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;
+
+ private static final int EDGE_SIZE = 20; // dp
+
+ private static final int BASE_SETTLE_DURATION = 256; // ms
+ private static final int MAX_SETTLE_DURATION = 600; // ms
+
+ // Current drag state; idle, dragging or settling
+ private int mDragState;
+
+ // Distance to travel before a drag may begin
+ private int mTouchSlop;
+
+ // Last known position/pointer tracking
+ private int mActivePointerId = INVALID_POINTER;
+ private float[] mInitialMotionX;
+ private float[] mInitialMotionY;
+ private float[] mLastMotionX;
+ private float[] mLastMotionY;
+ private int[] mInitialEdgesTouched;
+ private int[] mEdgeDragsInProgress;
+ private int[] mEdgeDragsLocked;
+ private int mPointersDown;
+
+ private VelocityTracker mVelocityTracker;
+ private float mMaxVelocity;
+ private float mMinVelocity;
+
+ private int mEdgeSize;
+ private int mTrackingEdges;
+
+ private Scroller mScroller;
+
+ private final Callback mCallback;
+
+ private View mCapturedView;
+ private boolean mReleaseInProgress;
+
+ private final ViewGroup mParentView;
+
+ /**
+ * A Callback is used as a communication channel with the ViewDragHelper back to the parent view using it.
+ * on*methods are invoked on siginficant events and several accessor methods are expected to provide
+ * the ViewDragHelper with more information about the state of the parent view upon request. The callback also makes
+ * decisions governing the range and draggability of child views.
+ */
+ public static abstract class Callback {
+ /**
+ * Called when the drag state changes. See the STATE_* constants for more information.
+ *
+ * @param state
+ * The new drag state
+ *
+ * @see #STATE_IDLE
+ * @see #STATE_DRAGGING
+ * @see #STATE_SETTLING
+ */
+ public void onViewDragStateChanged(int state) {
+ // Abstract.
+ }
+
+ /**
+ * Called when the captured view's position changes as the result of a drag or settle.
+ *
+ * @param changedView
+ * View whose position changed
+ * @param left
+ * New X coordinate of the left edge of the view
+ * @param top
+ * New Y coordinate of the top edge of the view
+ * @param dx
+ * Change in X position from the last call
+ * @param dy
+ * Change in Y position from the last call
+ */
+ public void onViewPositionChanged(View changedView, int left, int top, int dx, int dy) {
+ // Abstract.
+ }
+
+ /**
+ * Called when a child view is captured for dragging or settling. The ID of the pointer currently dragging the
+ * captured view is supplied. If activePointerId is identified as {@link #INVALID_POINTER} the capture is
+ * programmatic instead of pointer-initiated.
+ *
+ * @param capturedChild
+ * Child view that was captured
+ * @param activePointerId
+ * Pointer id tracking the child capture
+ */
+ public void onViewCaptured(View capturedChild, int activePointerId) {
+ // Abstract.
+ }
+
+ /**
+ * Called when the child view is no longer being actively dragged. The fling velocity is also supplied, if
+ * relevant. The velocity values may be clamped to system minimums or maximums.
+ *
+ *
+ * Calling code may decide to fling or otherwise release the view to let it settle into place. It should do so
+ * using {@link #settleCapturedViewAt(int, int)} or {@link #flingCapturedView(int, int, int, int)}. If the
+ * Callback invokes one of these methods, the ViewDragHelper will enter {@link #STATE_SETTLING} and the view
+ * capture will not fully end until it comes to a complete stop. If neither of these methods is invoked before
+ * onViewReleased returns, the view will stop in place and the ViewDragHelper will return to
+ * {@link #STATE_IDLE}.
+ *
+ *
+ * @param releasedChild
+ * The captured child view now being released
+ * @param xvel
+ * X velocity of the pointer as it left the screen in pixels per second.
+ * @param yvel
+ * Y velocity of the pointer as it left the screen in pixels per second.
+ */
+ public void onViewReleased(View releasedChild, float xvel, float yvel) {
+ // Abstract.
+ }
+
+ /**
+ * Called when one of the subscribed edges in the parent view has been touched by the user while no child view
+ * is currently captured.
+ *
+ * @param edgeFlags
+ * A combination of edge flags describing the edge(s) currently touched
+ * @param pointerId
+ * ID of the pointer touching the described edge(s)
+ * @see #EDGE_LEFT
+ * @see #EDGE_TOP
+ * @see #EDGE_RIGHT
+ * @see #EDGE_BOTTOM
+ */
+ public void onEdgeTouched(int edgeFlags, int pointerId) {
+ // Abstract.
+ }
+
+ /**
+ * Called when the given edge may become locked. This can happen if an edge drag was preliminarily rejected
+ * before beginning, but after {@link #onEdgeTouched(int, int)} was called. This method should return true to
+ * lock this edge or false to leave it unlocked. The default behavior is to leave edges unlocked.
+ *
+ * @param edgeFlags
+ * A combination of edge flags describing the edge(s) locked
+ * @return true to lock the edge, false to leave it unlocked
+ */
+ public boolean onEdgeLock(int edgeFlags) {
+ return false;
+ }
+
+ /**
+ * Called when the user has started a deliberate drag away from one of the subscribed edges in the parent view
+ * while no child view is currently captured.
+ *
+ * @param edgeFlags
+ * A combination of edge flags describing the edge(s) dragged
+ * @param pointerId
+ * ID of the pointer touching the described edge(s)
+ * @see #EDGE_LEFT
+ * @see #EDGE_TOP
+ * @see #EDGE_RIGHT
+ * @see #EDGE_BOTTOM
+ */
+ public void onEdgeDragStarted(int edgeFlags, int pointerId) {
+ // Abstract.
+ }
+
+ /**
+ * Called to determine the Z-order of child views.
+ *
+ * @param index
+ * the ordered position to query for
+ * @return index of the view that should be ordered at position index
+ */
+ public int getOrderedChildIndex(int index) {
+ return index;
+ }
+
+ /**
+ * Return the magnitude of a draggable child view's horizontal range of motion in pixels. This method should
+ * return 0 for views that cannot move horizontally.
+ *
+ * @param child
+ * Child view to check
+ * @return range of horizontal motion in pixels
+ */
+ public int getViewHorizontalDragRange(View child) {
+ return 0;
+ }
+
+ /**
+ * Return the magnitude of a draggable child view's vertical range of motion in pixels. This method should
+ * return 0 for views that cannot move vertically.
+ *
+ * @param child
+ * Child view to check
+ * @return range of vertical motion in pixels
+ */
+ public int getViewVerticalDragRange(View child) {
+ return 0;
+ }
+
+ /**
+ * Called when the user's input indicates that they want to capture the given child view with the pointer
+ * indicated by pointerId. The callback should return true if the user is permitted to drag the given view with
+ * the indicated pointer.
+ *
+ *
+ * ViewDragHelper may call this method multiple times for the same view even if the view is already captured;
+ * this indicates that a new pointer is trying to take control of the view.
+ *
+ *
+ *
+ * If this method returns true, a call to {@link #onViewCaptured(android.view.View, int)} will follow if the
+ * capture is successful.
+ *
+ *
+ * @param child
+ * Child the user is attempting to capture
+ * @param pointerId
+ * ID of the pointer attempting the capture
+ * @return true if capture should be allowed, false otherwise
+ */
+ public abstract boolean tryCaptureView(View child, int pointerId);
+
+ /**
+ * Restrict the motion of the dragged child view along the horizontal axis. The default implementation does not
+ * allow horizontal motion; the extending class must override this method and provide the desired clamping.
+ *
+ *
+ * @param child
+ * Child view being dragged
+ * @param left
+ * Attempted motion along the X axis
+ * @param dx
+ * Proposed change in position for left
+ * @return The new clamped position for left
+ */
+ public int clampViewPositionHorizontal(View child, int left, int dx) {
+ return 0;
+ }
+
+ /**
+ * Restrict the motion of the dragged child view along the vertical axis. The default implementation does not
+ * allow vertical motion; the extending class must override this method and provide the desired clamping.
+ *
+ *
+ * @param child
+ * Child view being dragged
+ * @param top
+ * Attempted motion along the Y axis
+ * @param dy
+ * Proposed change in position for top
+ * @return The new clamped position for top
+ */
+ public int clampViewPositionVertical(View child, int top, int dy) {
+ return 0;
+ }
+ }
+
+ /**
+ * Interpolator defining the animation curve for mScroller
+ */
+ private static final Interpolator sInterpolator = new Interpolator() {
+ @Override
+ public float getInterpolation(float t) {
+ t -= 1.0f;
+ return t * t * t * t * t + 1.0f;
+ }
+ };
+
+ private final Runnable mSetIdleRunnable = new Runnable() {
+ @Override
+ public void run() {
+ setDragState(STATE_IDLE);
+ }
+ };
+
+ /**
+ * Factory method to create a new ViewDragHelper.
+ *
+ * @param forParent
+ * Parent view to monitor
+ * @param cb
+ * Callback to provide information and receive events
+ * @return a new ViewDragHelper instance
+ */
+ public static ViewDragHelper create(ViewGroup forParent, Callback cb) {
+ return new ViewDragHelper(forParent.getContext(), forParent, cb);
+ }
+
+ /**
+ * Factory method to create a new ViewDragHelper.
+ *
+ * @param forParent
+ * Parent view to monitor
+ * @param sensitivity
+ * Multiplier for how sensitive the helper should be about detecting the start of a drag. Larger values
+ * are more sensitive. 1.0f is normal.
+ * @param cb
+ * Callback to provide information and receive events
+ * @return a new ViewDragHelper instance
+ */
+ public static ViewDragHelper create(ViewGroup forParent, float sensitivity, Callback cb) {
+ final ViewDragHelper helper = create(forParent, cb);
+ helper.mTouchSlop = (int) (helper.mTouchSlop * (1 / sensitivity));
+ return helper;
+ }
+
+ /**
+ * Apps should use ViewDragHelper.create() to get a new instance. This will allow VDH to use internal compatibility
+ * implementations for different platform versions.
+ *
+ * @param context
+ * Context to initialize config-dependent params from
+ * @param forParent
+ * Parent view to monitor
+ */
+ private ViewDragHelper(Context context, ViewGroup forParent, Callback cb) {
+ if (forParent == null) {
+ throw new IllegalArgumentException("Parent view may not be null");
+ }
+ if (cb == null) {
+ throw new IllegalArgumentException("Callback may not be null");
+ }
+
+ mParentView = forParent;
+ mCallback = cb;
+
+ final ViewConfiguration vc = ViewConfiguration.get(context);
+ final float density = context.getResources().getDisplayMetrics().density;
+ mEdgeSize = (int) (EDGE_SIZE * density + 0.5f);
+
+ mTouchSlop = vc.getScaledTouchSlop();
+ mMaxVelocity = vc.getScaledMaximumFlingVelocity();
+ mMinVelocity = vc.getScaledMinimumFlingVelocity();
+ mScroller = new Scroller(context, sInterpolator);
+ }
+
+ /**
+ * Set the minimum velocity that will be detected as having a magnitude greater than zero in pixels per second.
+ * Callback methods accepting a velocity will be clamped appropriately.
+ *
+ * @param minVel
+ * Minimum velocity to detect
+ */
+ public void setMinVelocity(float minVel) {
+ mMinVelocity = minVel;
+ }
+
+ /**
+ * Return the currently configured minimum velocity. Any flings with a magnitude less than this value in pixels per
+ * second. Callback methods accepting a velocity will receive zero as a velocity value if the real detected velocity
+ * was below this threshold.
+ *
+ * @return the minimum velocity that will be detected
+ */
+ public float getMinVelocity() {
+ return mMinVelocity;
+ }
+
+ /**
+ * Retrieve the current drag state of this helper. This will return one of {@link #STATE_IDLE},
+ * {@link #STATE_DRAGGING} or {@link #STATE_SETTLING}.
+ *
+ * @return The current drag state
+ */
+ public int getViewDragState() {
+ return mDragState;
+ }
+
+ /**
+ * Enable edge tracking for the selected edges of the parent view. The callback's
+ * {@link Callback#onEdgeTouched(int, int)} and {@link Callback#onEdgeDragStarted(int, int)} methods will only be
+ * invoked for edges for which edge tracking has been enabled.
+ *
+ * @param edgeFlags
+ * Combination of edge flags describing the edges to watch
+ * @see #EDGE_LEFT
+ * @see #EDGE_TOP
+ * @see #EDGE_RIGHT
+ * @see #EDGE_BOTTOM
+ */
+ public void setEdgeTrackingEnabled(int edgeFlags) {
+ mTrackingEdges = edgeFlags;
+ }
+
+ /**
+ * Return the size of an edge. This is the range in pixels along the edges of this view that will actively detect
+ * edge touches or drags if edge tracking is enabled.
+ *
+ * @return The size of an edge in pixels
+ * @see #setEdgeTrackingEnabled(int)
+ */
+ public int getEdgeSize() {
+ return mEdgeSize;
+ }
+
+ /**
+ * Capture a specific child view for dragging within the parent. The callback will be notified but
+ * {@link Callback#tryCaptureView(android.view.View, int)} will not be asked permission to capture this view.
+ *
+ * @param childView
+ * Child view to capture
+ * @param activePointerId
+ * ID of the pointer that is dragging the captured child view
+ */
+ public void captureChildView(View childView, int activePointerId) {
+ if (childView.getParent() != mParentView) {
+ throw new IllegalArgumentException("captureChildView: parameter must be a descendant " + "of the ViewDragHelper's tracked parent view ("
+ + mParentView + ")");
+ }
+
+ mCapturedView = childView;
+ mActivePointerId = activePointerId;
+ mCallback.onViewCaptured(childView, activePointerId);
+ setDragState(STATE_DRAGGING);
+ }
+
+ /**
+ * @return The currently captured view, or null if no view has been captured.
+ */
+ public View getCapturedView() {
+ return mCapturedView;
+ }
+
+ /**
+ * @return The ID of the pointer currently dragging the captured view, or {@link #INVALID_POINTER}.
+ */
+ public int getActivePointerId() {
+ return mActivePointerId;
+ }
+
+ /**
+ * @return The minimum distance in pixels that the user must travel to initiate a drag
+ */
+ public int getTouchSlop() {
+ return mTouchSlop;
+ }
+
+ /**
+ * The result of a call to this method is equivalent to {@link #processTouchEvent(android.view.MotionEvent)}
+ * receiving an ACTION_CANCEL event.
+ */
+ public void cancel() {
+ mActivePointerId = INVALID_POINTER;
+ clearMotionHistory();
+
+ if (mVelocityTracker != null) {
+ mVelocityTracker.recycle();
+ mVelocityTracker = null;
+ }
+ }
+
+ /**
+ * {@link #cancel()}, but also abort all motion in progress and snap to the end of any animation.
+ */
+ public void abort() {
+ cancel();
+ if (mDragState == STATE_SETTLING) {
+ final int oldX = mScroller.getCurrX();
+ final int oldY = mScroller.getCurrY();
+ mScroller.abortAnimation();
+ final int newX = mScroller.getCurrX();
+ final int newY = mScroller.getCurrY();
+ mCallback.onViewPositionChanged(mCapturedView, newX, newY, newX - oldX, newY - oldY);
+ }
+ setDragState(STATE_IDLE);
+ }
+
+ /**
+ * Animate the view child to the given (left, top) position. If this method returns true, the caller
+ * should invoke {@link #continueSettling(boolean)} on each subsequent frame to continue the motion until it returns
+ * false. If this method returns false there is no further work to do to complete the movement.
+ *
+ *
+ * This operation does not count as a capture event, though {@link #getCapturedView()} will still report the sliding
+ * view while the slide is in progress.
+ *
+ *
+ * @param child
+ * Child view to capture and animate
+ * @param finalLeft
+ * Final left position of child
+ * @param finalTop
+ * Final top position of child
+ * @return true if animation should continue through {@link #continueSettling(boolean)} calls
+ */
+ public boolean smoothSlideViewTo(View child, int finalLeft, int finalTop) {
+ mCapturedView = child;
+ mActivePointerId = INVALID_POINTER;
+
+ boolean continueSliding = forceSettleCapturedViewAt(finalLeft, finalTop, 0, 0);
+ if (!continueSliding && mDragState == STATE_IDLE && mCapturedView != null) {
+ // If we're in an IDLE state to begin with and aren't moving anywhere, we
+ // end up having a non-null capturedView with an IDLE dragState
+ mCapturedView = null;
+ }
+
+ return continueSliding;
+ }
+
+ /**
+ * Settle the captured view at the given (left, top) position. The appropriate velocity from prior motion will be
+ * taken into account. If this method returns true, the caller should invoke {@link #continueSettling(boolean)} on
+ * each subsequent frame to continue the motion until it returns false. If this method returns false there is no
+ * further work to do to complete the movement.
+ *
+ * @param finalLeft
+ * Settled left edge position for the captured view
+ * @param finalTop
+ * Settled top edge position for the captured view
+ * @return true if animation should continue through {@link #continueSettling(boolean)} calls
+ */
+ public boolean settleCapturedViewAt(int finalLeft, int finalTop) {
+ if (!mReleaseInProgress) {
+ throw new IllegalStateException("Cannot settleCapturedViewAt outside of a call to " + "Callback#onViewReleased");
+ }
+
+ return forceSettleCapturedViewAt(finalLeft, finalTop, (int) mVelocityTracker.getXVelocity(mActivePointerId),
+ (int) mVelocityTracker.getYVelocity(mActivePointerId));
+ }
+
+ /**
+ * Settle the captured view at the given (left, top) position.
+ *
+ * @param finalLeft
+ * Target left position for the captured view
+ * @param finalTop
+ * Target top position for the captured view
+ * @param xvel
+ * Horizontal velocity
+ * @param yvel
+ * Vertical velocity
+ * @return true if animation should continue through {@link #continueSettling(boolean)} calls
+ */
+ private boolean forceSettleCapturedViewAt(int finalLeft, int finalTop, int xvel, int yvel) {
+ final int startLeft = mCapturedView.getLeft();
+ final int startTop = mCapturedView.getTop();
+ final int dx = finalLeft - startLeft;
+ final int dy = finalTop - startTop;
+
+ if (dx == 0 && dy == 0) {
+ // Nothing to do. Send callbacks, be done.
+ mScroller.abortAnimation();
+ setDragState(STATE_IDLE);
+ return false;
+ }
+
+ final int duration = computeSettleDuration(mCapturedView, dx, dy, xvel, yvel);
+ mScroller.startScroll(startLeft, startTop, dx, dy, duration);
+
+ setDragState(STATE_SETTLING);
+ return true;
+ }
+
+ private int computeSettleDuration(View child, int dx, int dy, int xvel, int yvel) {
+ xvel = clampMag(xvel, (int) mMinVelocity, (int) mMaxVelocity);
+ yvel = clampMag(yvel, (int) mMinVelocity, (int) mMaxVelocity);
+ final int absDx = Math.abs(dx);
+ final int absDy = Math.abs(dy);
+ final int absXVel = Math.abs(xvel);
+ final int absYVel = Math.abs(yvel);
+ final int addedVel = absXVel + absYVel;
+ final int addedDistance = absDx + absDy;
+
+ final float xweight = xvel != 0 ? (float) absXVel / addedVel : (float) absDx / addedDistance;
+ final float yweight = yvel != 0 ? (float) absYVel / addedVel : (float) absDy / addedDistance;
+
+ int xduration = computeAxisDuration(dx, xvel, mCallback.getViewHorizontalDragRange(child));
+ int yduration = computeAxisDuration(dy, yvel, mCallback.getViewVerticalDragRange(child));
+
+ return (int) (xduration * xweight + yduration * yweight);
+ }
+
+ private int computeAxisDuration(int delta, int velocity, int motionRange) {
+ if (delta == 0) {
+ return 0;
+ }
+
+ final int width = mParentView.getWidth();
+ final int halfWidth = width / 2;
+ final float distanceRatio = Math.min(1f, (float) Math.abs(delta) / width);
+ final float distance = halfWidth + halfWidth * distanceInfluenceForSnapDuration(distanceRatio);
+
+ int duration;
+ velocity = Math.abs(velocity);
+ if (velocity > 0) {
+ duration = 4 * Math.round(1000 * Math.abs(distance / velocity));
+ } else {
+ final float range = (float) Math.abs(delta) / motionRange;
+ duration = (int) ((range + 1) * BASE_SETTLE_DURATION);
+ }
+ return Math.min(duration, MAX_SETTLE_DURATION);
+ }
+
+ /**
+ * Clamp the magnitude of value for absMin and absMax. If the value is below the minimum, it will be clamped to
+ * zero. If the value is above the maximum, it will be clamped to the maximum.
+ *
+ * @param value
+ * Value to clamp
+ * @param absMin
+ * Absolute value of the minimum significant value to return
+ * @param absMax
+ * Absolute value of the maximum value to return
+ * @return The clamped value with the same sign as value
+ */
+ private static int clampMag(int value, int absMin, int absMax) {
+ final int absValue = Math.abs(value);
+ if (absValue < absMin) return 0;
+ if (absValue > absMax) return value > 0 ? absMax : -absMax;
+ return value;
+ }
+
+ /**
+ * Clamp the magnitude of value for absMin and absMax. If the value is below the minimum, it will be clamped to
+ * zero. If the value is above the maximum, it will be clamped to the maximum.
+ *
+ * @param value
+ * Value to clamp
+ * @param absMin
+ * Absolute value of the minimum significant value to return
+ * @param absMax
+ * Absolute value of the maximum value to return
+ * @return The clamped value with the same sign as value
+ */
+ private static float clampMag(float value, float absMin, float absMax) {
+ final float absValue = Math.abs(value);
+ if (absValue < absMin) return 0;
+ if (absValue > absMax) return value > 0 ? absMax : -absMax;
+ return value;
+ }
+
+ private static float distanceInfluenceForSnapDuration(float f) {
+ f -= 0.5f; // center the values about 0.
+ f *= 0.3f * Math.PI / 2.0f;
+ return (float) Math.sin(f);
+ }
+
+ /**
+ * Settle the captured view based on standard free-moving fling behavior. The caller should invoke
+ * {@link #continueSettling(boolean)} on each subsequent frame to continue the motion until it returns false.
+ *
+ * @param minLeft
+ * Minimum X position for the view's left edge
+ * @param minTop
+ * Minimum Y position for the view's top edge
+ * @param maxLeft
+ * Maximum X position for the view's left edge
+ * @param maxTop
+ * Maximum Y position for the view's top edge
+ */
+ public void flingCapturedView(int minLeft, int minTop, int maxLeft, int maxTop) {
+ if (!mReleaseInProgress) {
+ throw new IllegalStateException("Cannot flingCapturedView outside of a call to " + "Callback#onViewReleased");
+ }
+
+ mScroller.fling(mCapturedView.getLeft(), mCapturedView.getTop(), (int) mVelocityTracker.getXVelocity(mActivePointerId),
+ (int) mVelocityTracker.getYVelocity(mActivePointerId), minLeft, maxLeft, minTop, maxTop);
+
+ setDragState(STATE_SETTLING);
+ }
+
+ /**
+ * Move the captured settling view by the appropriate amount for the current time. If continueSettling
+ * returns true, the caller should call it again on the next frame to continue.
+ *
+ * @param deferCallbacks
+ * true if state callbacks should be deferred via posted message. Set this to true if you are calling
+ * this method from {@link android.view.View#computeScroll()} or similar methods invoked as part of
+ * layout or drawing.
+ * @return true if settle is still in progress
+ */
+ public boolean continueSettling(boolean deferCallbacks) {
+ if (mDragState == STATE_SETTLING) {
+ boolean keepGoing = mScroller.computeScrollOffset();
+ final int x = mScroller.getCurrX();
+ final int y = mScroller.getCurrY();
+ final int dx = x - mCapturedView.getLeft();
+ final int dy = y - mCapturedView.getTop();
+
+ if (dx != 0) {
+ mCapturedView.offsetLeftAndRight(dx);
+ }
+ if (dy != 0) {
+ mCapturedView.offsetTopAndBottom(dy);
+ }
+
+ if (dx != 0 || dy != 0) {
+ mCallback.onViewPositionChanged(mCapturedView, x, y, dx, dy);
+ }
+
+ if (keepGoing && x == mScroller.getFinalX() && y == mScroller.getFinalY()) {
+ // Close enough. The interpolator/scroller might think we're still moving
+ // but the user sure doesn't.
+ mScroller.abortAnimation();
+ keepGoing = false;
+ }
+
+ if (!keepGoing) {
+ if (deferCallbacks) {
+ mParentView.post(mSetIdleRunnable);
+ } else {
+ setDragState(STATE_IDLE);
+ }
+ }
+ }
+
+ return mDragState == STATE_SETTLING;
+ }
+
+ /**
+ * Like all callback events this must happen on the UI thread, but release involves some extra semantics. During a
+ * release (mReleaseInProgress) is the only time it is valid to call {@link #settleCapturedViewAt(int, int)} or
+ * {@link #flingCapturedView(int, int, int, int)}.
+ */
+ private void dispatchViewReleased(float xvel, float yvel) {
+ mReleaseInProgress = true;
+ mCallback.onViewReleased(mCapturedView, xvel, yvel);
+ mReleaseInProgress = false;
+
+ if (mDragState == STATE_DRAGGING) {
+ // onViewReleased didn't call a method that would have changed this. Go idle.
+ setDragState(STATE_IDLE);
+ }
+ }
+
+ private void clearMotionHistory() {
+ if (mInitialMotionX == null) {
+ return;
+ }
+ Arrays.fill(mInitialMotionX, 0);
+ Arrays.fill(mInitialMotionY, 0);
+ Arrays.fill(mLastMotionX, 0);
+ Arrays.fill(mLastMotionY, 0);
+ Arrays.fill(mInitialEdgesTouched, 0);
+ Arrays.fill(mEdgeDragsInProgress, 0);
+ Arrays.fill(mEdgeDragsLocked, 0);
+ mPointersDown = 0;
+ }
+
+ private void clearMotionHistory(int pointerId) {
+ if (mInitialMotionX == null) {
+ return;
+ }
+ mInitialMotionX[pointerId] = 0;
+ mInitialMotionY[pointerId] = 0;
+ mLastMotionX[pointerId] = 0;
+ mLastMotionY[pointerId] = 0;
+ mInitialEdgesTouched[pointerId] = 0;
+ mEdgeDragsInProgress[pointerId] = 0;
+ mEdgeDragsLocked[pointerId] = 0;
+ mPointersDown &= ~(1 << pointerId);
+ }
+
+ private void ensureMotionHistorySizeForId(int pointerId) {
+ if (mInitialMotionX == null || mInitialMotionX.length <= pointerId) {
+ float[] imx = new float[pointerId + 1];
+ float[] imy = new float[pointerId + 1];
+ float[] lmx = new float[pointerId + 1];
+ float[] lmy = new float[pointerId + 1];
+ int[] iit = new int[pointerId + 1];
+ int[] edip = new int[pointerId + 1];
+ int[] edl = new int[pointerId + 1];
+
+ if (mInitialMotionX != null) {
+ System.arraycopy(mInitialMotionX, 0, imx, 0, mInitialMotionX.length);
+ System.arraycopy(mInitialMotionY, 0, imy, 0, mInitialMotionY.length);
+ System.arraycopy(mLastMotionX, 0, lmx, 0, mLastMotionX.length);
+ System.arraycopy(mLastMotionY, 0, lmy, 0, mLastMotionY.length);
+ System.arraycopy(mInitialEdgesTouched, 0, iit, 0, mInitialEdgesTouched.length);
+ System.arraycopy(mEdgeDragsInProgress, 0, edip, 0, mEdgeDragsInProgress.length);
+ System.arraycopy(mEdgeDragsLocked, 0, edl, 0, mEdgeDragsLocked.length);
+ }
+
+ mInitialMotionX = imx;
+ mInitialMotionY = imy;
+ mLastMotionX = lmx;
+ mLastMotionY = lmy;
+ mInitialEdgesTouched = iit;
+ mEdgeDragsInProgress = edip;
+ mEdgeDragsLocked = edl;
+ }
+ }
+
+ private void saveInitialMotion(float x, float y, int pointerId) {
+ ensureMotionHistorySizeForId(pointerId);
+ mInitialMotionX[pointerId] = mLastMotionX[pointerId] = x;
+ mInitialMotionY[pointerId] = mLastMotionY[pointerId] = y;
+ mInitialEdgesTouched[pointerId] = getEdgesTouched((int) x, (int) y);
+ mPointersDown |= 1 << pointerId;
+ }
+
+ private void saveLastMotion(MotionEvent ev) {
+ final int pointerCount = ev.getPointerCount();
+ for (int i = 0; i < pointerCount; i++) {
+ final int pointerId = ev.getPointerId(i);
+ final float x = ev.getX(i);
+ final float y = ev.getY(i);
+ mLastMotionX[pointerId] = x;
+ mLastMotionY[pointerId] = y;
+ }
+ }
+
+ /**
+ * Check if the given pointer ID represents a pointer that is currently down (to the best of the ViewDragHelper's
+ * knowledge).
+ *
+ *
+ * The state used to report this information is populated by the methods
+ * {@link #shouldInterceptTouchEvent(android.view.MotionEvent)} or
+ * {@link #processTouchEvent(android.view.MotionEvent)}. If one of these methods has not been called for all
+ * relevant MotionEvents to track, the information reported by this method may be stale or incorrect.
+ *
+ *
+ * @param pointerId
+ * pointer ID to check; corresponds to IDs provided by MotionEvent
+ * @return true if the pointer with the given ID is still down
+ */
+ public boolean isPointerDown(int pointerId) {
+ return (mPointersDown & 1 << pointerId) != 0;
+ }
+
+ void setDragState(int state) {
+ mParentView.removeCallbacks(mSetIdleRunnable);
+ if (mDragState != state) {
+ mDragState = state;
+ mCallback.onViewDragStateChanged(state);
+ if (mDragState == STATE_IDLE) {
+ mCapturedView = null;
+ }
+ }
+ }
+
+ /**
+ * Attempt to capture the view with the given pointer ID. The callback will be involved. This will put us into the
+ * "dragging" state. If we've already captured this view with this pointer this method will immediately return true
+ * without consulting the callback.
+ *
+ * @param toCapture
+ * View to capture
+ * @param pointerId
+ * Pointer to capture with
+ * @return true if capture was successful
+ */
+ boolean tryCaptureViewForDrag(View toCapture, int pointerId) {
+ if (toCapture == mCapturedView && mActivePointerId == pointerId) {
+ // Already done!
+ return true;
+ }
+ if (toCapture != null && mCallback.tryCaptureView(toCapture, pointerId)) {
+ mActivePointerId = pointerId;
+ captureChildView(toCapture, pointerId);
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Tests scrollability within child views of v given a delta of dx.
+ *
+ * @param v
+ * View to test for horizontal scrollability
+ * @param checkV
+ * Whether the view v passed should itself be checked for scrollability (true), or just its children
+ * (false).
+ * @param dx
+ * Delta scrolled in pixels along the X axis
+ * @param dy
+ * Delta scrolled in pixels along the Y axis
+ * @param x
+ * X coordinate of the active touch point
+ * @param y
+ * Y coordinate of the active touch point
+ * @return true if child views of v can be scrolled by delta of dx.
+ */
+ protected boolean canScroll(View v, boolean checkV, int dx, int dy, int x, int y) {
+ if (v instanceof ViewGroup) {
+ final ViewGroup group = (ViewGroup) v;
+ final int scrollX = v.getScrollX();
+ final int scrollY = v.getScrollY();
+ final int count = group.getChildCount();
+ // Count backwards - let topmost views consume scroll distance first.
+ for (int i = count - 1; i >= 0; i--) {
+ // TODO: Add versioned support here for transformed views.
+ // This will not work for transformed views in Honeycomb+
+ final View child = group.getChildAt(i);
+ if (x + scrollX >= child.getLeft() && x + scrollX < child.getRight() && y + scrollY >= child.getTop() && y + scrollY < child.getBottom()
+ && canScroll(child, true, dx, dy, x + scrollX - child.getLeft(), y + scrollY - child.getTop())) {
+ return true;
+ }
+ }
+ }
+
+ return checkV && (v.canScrollHorizontally(-dx) || v.canScrollVertically(-dy));
+ }
+
+ /**
+ * Check if this event as provided to the parent view's onInterceptTouchEvent should cause the parent to intercept
+ * the touch event stream.
+ *
+ * @param ev
+ * MotionEvent provided to onInterceptTouchEvent
+ * @return true if the parent view should return true from onInterceptTouchEvent
+ */
+ public boolean shouldInterceptTouchEvent(MotionEvent ev) {
+ final int action = ev.getActionMasked();
+ final int actionIndex = ev.getActionIndex();
+
+ if (action == MotionEvent.ACTION_DOWN) {
+ // Reset things for a new event stream, just in case we didn't get
+ // the whole previous stream.
+ cancel();
+ }
+
+ if (mVelocityTracker == null) {
+ mVelocityTracker = VelocityTracker.obtain();
+ }
+ mVelocityTracker.addMovement(ev);
+
+ switch (action) {
+ case MotionEvent.ACTION_DOWN: {
+ final float x = ev.getX();
+ final float y = ev.getY();
+ final int pointerId = ev.getPointerId(0);
+ saveInitialMotion(x, y, pointerId);
+
+ final View toCapture = findTopChildUnder((int) x, (int) y);
+
+ // Catch a settling view if possible.
+ if (toCapture == mCapturedView && mDragState == STATE_SETTLING) {
+ tryCaptureViewForDrag(toCapture, pointerId);
+ }
+
+ final int edgesTouched = mInitialEdgesTouched[pointerId];
+ if ((edgesTouched & mTrackingEdges) != 0) {
+ mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
+ }
+ break;
+ }
+
+ case MotionEvent.ACTION_POINTER_DOWN: {
+ final int pointerId = ev.getPointerId(actionIndex);
+ final float x = ev.getX(actionIndex);
+ final float y = ev.getY(actionIndex);
+
+ saveInitialMotion(x, y, pointerId);
+
+ // A ViewDragHelper can only manipulate one view at a time.
+ if (mDragState == STATE_IDLE) {
+ final int edgesTouched = mInitialEdgesTouched[pointerId];
+ if ((edgesTouched & mTrackingEdges) != 0) {
+ mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
+ }
+ } else if (mDragState == STATE_SETTLING) {
+ // Catch a settling view if possible.
+ final View toCapture = findTopChildUnder((int) x, (int) y);
+ if (toCapture == mCapturedView) {
+ tryCaptureViewForDrag(toCapture, pointerId);
+ }
+ }
+ break;
+ }
+
+ case MotionEvent.ACTION_MOVE: {
+ // First to cross a touch slop over a draggable view wins. Also report edge drags.
+ final int pointerCount = ev.getPointerCount();
+ for (int i = 0; i < pointerCount; i++) {
+ final int pointerId = ev.getPointerId(i);
+ final float x = ev.getX(i);
+ final float y = ev.getY(i);
+ final float dx = x - mInitialMotionX[pointerId];
+ final float dy = y - mInitialMotionY[pointerId];
+
+ final View toCapture = findTopChildUnder((int) x, (int) y);
+ final boolean pastSlop = toCapture != null && checkTouchSlop(toCapture, dx, dy);
+ if (pastSlop) {
+ // check the callback's
+ // getView[Horizontal|Vertical]DragRange methods to know
+ // if you can move at all along an axis, then see if it
+ // would clamp to the same value. If you can't move at
+ // all in every dimension with a nonzero range, bail.
+ @SuppressWarnings("null") /* We only enter here if "toCapture != null" */
+ final int oldLeft = toCapture.getLeft();
+ final int targetLeft = oldLeft + (int) dx;
+ final int newLeft = mCallback.clampViewPositionHorizontal(toCapture, targetLeft, (int) dx);
+ final int oldTop = toCapture.getTop();
+ final int targetTop = oldTop + (int) dy;
+ final int newTop = mCallback.clampViewPositionVertical(toCapture, targetTop, (int) dy);
+ final int horizontalDragRange = mCallback.getViewHorizontalDragRange(toCapture);
+ final int verticalDragRange = mCallback.getViewVerticalDragRange(toCapture);
+ if ((horizontalDragRange == 0 || horizontalDragRange > 0 && newLeft == oldLeft)
+ && (verticalDragRange == 0 || verticalDragRange > 0 && newTop == oldTop)) {
+ break;
+ }
+ }
+ reportNewEdgeDrags(dx, dy, pointerId);
+ if (mDragState == STATE_DRAGGING) {
+ // Callback might have started an edge drag
+ break;
+ }
+
+ if (pastSlop && tryCaptureViewForDrag(toCapture, pointerId)) {
+ break;
+ }
+ }
+ saveLastMotion(ev);
+ break;
+ }
+
+ case MotionEvent.ACTION_POINTER_UP: {
+ final int pointerId = ev.getPointerId(actionIndex);
+ clearMotionHistory(pointerId);
+ break;
+ }
+
+ case MotionEvent.ACTION_UP:
+ case MotionEvent.ACTION_CANCEL: {
+ cancel();
+ break;
+ }
+ }
+
+ return mDragState == STATE_DRAGGING;
+ }
+
+ /**
+ * Process a touch event received by the parent view. This method will dispatch callback events as needed before
+ * returning. The parent view's onTouchEvent implementation should call this.
+ *
+ * @param ev
+ * The touch event received by the parent view
+ */
+ public void processTouchEvent(MotionEvent ev) {
+ final int action = ev.getActionMasked();
+ final int actionIndex = ev.getActionIndex();
+
+ if (action == MotionEvent.ACTION_DOWN) {
+ // Reset things for a new event stream, just in case we didn't get
+ // the whole previous stream.
+ cancel();
+ }
+
+ if (mVelocityTracker == null) {
+ mVelocityTracker = VelocityTracker.obtain();
+ }
+ mVelocityTracker.addMovement(ev);
+
+ switch (action) {
+ case MotionEvent.ACTION_DOWN: {
+ final float x = ev.getX();
+ final float y = ev.getY();
+ final int pointerId = ev.getPointerId(0);
+ final View toCapture = findTopChildUnder((int) x, (int) y);
+
+ saveInitialMotion(x, y, pointerId);
+
+ // Since the parent is already directly processing this touch event,
+ // there is no reason to delay for a slop before dragging.
+ // Start immediately if possible.
+ tryCaptureViewForDrag(toCapture, pointerId);
+
+ final int edgesTouched = mInitialEdgesTouched[pointerId];
+ if ((edgesTouched & mTrackingEdges) != 0) {
+ mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
+ }
+ break;
+ }
+
+ case MotionEvent.ACTION_POINTER_DOWN: {
+ final int pointerId = ev.getPointerId(actionIndex);
+ final float x = ev.getX(actionIndex);
+ final float y = ev.getY(actionIndex);
+
+ saveInitialMotion(x, y, pointerId);
+
+ // A ViewDragHelper can only manipulate one view at a time.
+ if (mDragState == STATE_IDLE) {
+ // If we're idle we can do anything! Treat it like a normal down event.
+
+ final View toCapture = findTopChildUnder((int) x, (int) y);
+ tryCaptureViewForDrag(toCapture, pointerId);
+
+ final int edgesTouched = mInitialEdgesTouched[pointerId];
+ if ((edgesTouched & mTrackingEdges) != 0) {
+ mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
+ }
+ } else if (isCapturedViewUnder((int) x, (int) y)) {
+ // We're still tracking a captured view. If the same view is under this
+ // point, we'll swap to controlling it with this pointer instead.
+ // (This will still work if we're "catching" a settling view.)
+
+ tryCaptureViewForDrag(mCapturedView, pointerId);
+ }
+ break;
+ }
+
+ case MotionEvent.ACTION_MOVE: {
+ if (mDragState == STATE_DRAGGING) {
+ final int index = ev.findPointerIndex(mActivePointerId);
+ final float x = ev.getX(index);
+ final float y = ev.getY(index);
+ final int idx = (int) (x - mLastMotionX[mActivePointerId]);
+ final int idy = (int) (y - mLastMotionY[mActivePointerId]);
+
+ dragTo(mCapturedView.getLeft() + idx, mCapturedView.getTop() + idy, idx, idy);
+
+ saveLastMotion(ev);
+ } else {
+ // Check to see if any pointer is now over a draggable view.
+ final int pointerCount = ev.getPointerCount();
+ for (int i = 0; i < pointerCount; i++) {
+ final int pointerId = ev.getPointerId(i);
+ final float x = ev.getX(i);
+ final float y = ev.getY(i);
+ final float dx = x - mInitialMotionX[pointerId];
+ final float dy = y - mInitialMotionY[pointerId];
+
+ reportNewEdgeDrags(dx, dy, pointerId);
+ if (mDragState == STATE_DRAGGING) {
+ // Callback might have started an edge drag.
+ break;
+ }
+
+ final View toCapture = findTopChildUnder((int) x, (int) y);
+ if (checkTouchSlop(toCapture, dx, dy) && tryCaptureViewForDrag(toCapture, pointerId)) {
+ break;
+ }
+ }
+ saveLastMotion(ev);
+ }
+ break;
+ }
+
+ case MotionEvent.ACTION_POINTER_UP: {
+ final int pointerId = ev.getPointerId(actionIndex);
+ if (mDragState == STATE_DRAGGING && pointerId == mActivePointerId) {
+ // Try to find another pointer that's still holding on to the captured view.
+ int newActivePointer = INVALID_POINTER;
+ final int pointerCount = ev.getPointerCount();
+ for (int i = 0; i < pointerCount; i++) {
+ final int id = ev.getPointerId(i);
+ if (id == mActivePointerId) {
+ // This one's going away, skip.
+ continue;
+ }
+
+ final float x = ev.getX(i);
+ final float y = ev.getY(i);
+ if (findTopChildUnder((int) x, (int) y) == mCapturedView && tryCaptureViewForDrag(mCapturedView, id)) {
+ newActivePointer = mActivePointerId;
+ break;
+ }
+ }
+
+ if (newActivePointer == INVALID_POINTER) {
+ // We didn't find another pointer still touching the view, release it.
+ releaseViewForPointerUp();
+ }
+ }
+ clearMotionHistory(pointerId);
+ break;
+ }
+
+ case MotionEvent.ACTION_UP: {
+ if (mDragState == STATE_DRAGGING) {
+ releaseViewForPointerUp();
+ }
+ cancel();
+ break;
+ }
+
+ case MotionEvent.ACTION_CANCEL: {
+ if (mDragState == STATE_DRAGGING) {
+ dispatchViewReleased(0, 0);
+ }
+ cancel();
+ break;
+ }
+ }
+ }
+
+ private void reportNewEdgeDrags(float dx, float dy, int pointerId) {
+ int dragsStarted = 0;
+ if (checkNewEdgeDrag(dx, dy, pointerId, EDGE_LEFT)) {
+ dragsStarted |= EDGE_LEFT;
+ }
+ if (checkNewEdgeDrag(dy, dx, pointerId, EDGE_TOP)) {
+ dragsStarted |= EDGE_TOP;
+ }
+ if (checkNewEdgeDrag(dx, dy, pointerId, EDGE_RIGHT)) {
+ dragsStarted |= EDGE_RIGHT;
+ }
+ if (checkNewEdgeDrag(dy, dx, pointerId, EDGE_BOTTOM)) {
+ dragsStarted |= EDGE_BOTTOM;
+ }
+
+ if (dragsStarted != 0) {
+ mEdgeDragsInProgress[pointerId] |= dragsStarted;
+ mCallback.onEdgeDragStarted(dragsStarted, pointerId);
+ }
+ }
+
+ private boolean checkNewEdgeDrag(float delta, float odelta, int pointerId, int edge) {
+ final float absDelta = Math.abs(delta);
+ final float absODelta = Math.abs(odelta);
+
+ if ((mInitialEdgesTouched[pointerId] & edge) != edge || (mTrackingEdges & edge) == 0 || (mEdgeDragsLocked[pointerId] & edge) == edge
+ || (mEdgeDragsInProgress[pointerId] & edge) == edge || (absDelta <= mTouchSlop && absODelta <= mTouchSlop)) {
+ return false;
+ }
+ if (absDelta < absODelta * 0.5f && mCallback.onEdgeLock(edge)) {
+ mEdgeDragsLocked[pointerId] |= edge;
+ return false;
+ }
+ return (mEdgeDragsInProgress[pointerId] & edge) == 0 && absDelta > mTouchSlop;
+ }
+
+ /**
+ * Check if we've crossed a reasonable touch slop for the given child view. If the child cannot be dragged along the
+ * horizontal or vertical axis, motion along that axis will not count toward the slop check.
+ *
+ * @param child
+ * Child to check
+ * @param dx
+ * Motion since initial position along X axis
+ * @param dy
+ * Motion since initial position along Y axis
+ * @return true if the touch slop has been crossed
+ */
+ private boolean checkTouchSlop(View child, float dx, float dy) {
+ if (child == null) {
+ return false;
+ }
+ final boolean checkHorizontal = mCallback.getViewHorizontalDragRange(child) > 0;
+ final boolean checkVertical = mCallback.getViewVerticalDragRange(child) > 0;
+
+ if (checkHorizontal && checkVertical) {
+ return dx * dx + dy * dy > mTouchSlop * mTouchSlop;
+ } else if (checkHorizontal) {
+ return Math.abs(dx) > mTouchSlop;
+ } else if (checkVertical) {
+ return Math.abs(dy) > mTouchSlop;
+ }
+ return false;
+ }
+
+ /**
+ * Check if any pointer tracked in the current gesture has crossed the required slop threshold.
+ *
+ *
+ * This depends on internal state populated by {@link #shouldInterceptTouchEvent(android.view.MotionEvent)} or
+ * {@link #processTouchEvent(android.view.MotionEvent)}. You should only rely on the results of this method after
+ * all currently available touch data has been provided to one of these two methods.
+ *
+ *
+ * @param directions
+ * Combination of direction flags, see {@link #DIRECTION_HORIZONTAL}, {@link #DIRECTION_VERTICAL},
+ * {@link #DIRECTION_ALL}
+ * @return true if the slop threshold has been crossed, false otherwise
+ */
+ public boolean checkTouchSlop(int directions) {
+ final int count = mInitialMotionX.length;
+ for (int i = 0; i < count; i++) {
+ if (checkTouchSlop(directions, i)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Check if the specified pointer tracked in the current gesture has crossed the required slop threshold.
+ *
+ *
+ * This depends on internal state populated by {@link #shouldInterceptTouchEvent(android.view.MotionEvent)} or
+ * {@link #processTouchEvent(android.view.MotionEvent)}. You should only rely on the results of this method after
+ * all currently available touch data has been provided to one of these two methods.
+ *
+ *
+ * @param directions
+ * Combination of direction flags, see {@link #DIRECTION_HORIZONTAL}, {@link #DIRECTION_VERTICAL},
+ * {@link #DIRECTION_ALL}
+ * @param pointerId
+ * ID of the pointer to slop check as specified by MotionEvent
+ * @return true if the slop threshold has been crossed, false otherwise
+ */
+ public boolean checkTouchSlop(int directions, int pointerId) {
+ if (!isPointerDown(pointerId)) {
+ return false;
+ }
+
+ final boolean checkHorizontal = (directions & DIRECTION_HORIZONTAL) == DIRECTION_HORIZONTAL;
+ final boolean checkVertical = (directions & DIRECTION_VERTICAL) == DIRECTION_VERTICAL;
+
+ final float dx = mLastMotionX[pointerId] - mInitialMotionX[pointerId];
+ final float dy = mLastMotionY[pointerId] - mInitialMotionY[pointerId];
+
+ if (checkHorizontal && checkVertical) {
+ return dx * dx + dy * dy > mTouchSlop * mTouchSlop;
+ } else if (checkHorizontal) {
+ return Math.abs(dx) > mTouchSlop;
+ } else if (checkVertical) {
+ return Math.abs(dy) > mTouchSlop;
+ }
+ return false;
+ }
+
+ /**
+ * Check if any of the edges specified were initially touched in the currently active gesture. If there is no
+ * currently active gesture this method will return false.
+ *
+ * @param edges
+ * Edges to check for an initial edge touch. See {@link #EDGE_LEFT}, {@link #EDGE_TOP},
+ * {@link #EDGE_RIGHT}, {@link #EDGE_BOTTOM} and {@link #EDGE_ALL}
+ * @return true if any of the edges specified were initially touched in the current gesture
+ */
+ public boolean isEdgeTouched(int edges) {
+ final int count = mInitialEdgesTouched.length;
+ for (int i = 0; i < count; i++) {
+ if (isEdgeTouched(edges, i)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Check if any of the edges specified were initially touched by the pointer with the specified ID. If there is no
+ * currently active gesture or if there is no pointer with the given ID currently down this method will return
+ * false.
+ *
+ * @param edges
+ * Edges to check for an initial edge touch. See {@link #EDGE_LEFT}, {@link #EDGE_TOP},
+ * {@link #EDGE_RIGHT}, {@link #EDGE_BOTTOM} and {@link #EDGE_ALL}
+ * @return true if any of the edges specified were initially touched in the current gesture
+ */
+ public boolean isEdgeTouched(int edges, int pointerId) {
+ return isPointerDown(pointerId) && (mInitialEdgesTouched[pointerId] & edges) != 0;
+ }
+
+ private void releaseViewForPointerUp() {
+ mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
+ final float xvel = clampMag(mVelocityTracker.getXVelocity(mActivePointerId), mMinVelocity, mMaxVelocity);
+ final float yvel = clampMag(mVelocityTracker.getYVelocity(mActivePointerId), mMinVelocity, mMaxVelocity);
+ dispatchViewReleased(xvel, yvel);
+ }
+
+ private void dragTo(int left, int top, int dx, int dy) {
+ int clampedX = left;
+ int clampedY = top;
+ final int oldLeft = mCapturedView.getLeft();
+ final int oldTop = mCapturedView.getTop();
+ if (dx != 0) {
+ clampedX = mCallback.clampViewPositionHorizontal(mCapturedView, left, dx);
+ mCapturedView.offsetLeftAndRight(clampedX - oldLeft);
+ }
+ if (dy != 0) {
+ clampedY = mCallback.clampViewPositionVertical(mCapturedView, top, dy);
+ mCapturedView.offsetTopAndBottom(clampedY - oldTop);
+ }
+
+ if (dx != 0 || dy != 0) {
+ final int clampedDx = clampedX - oldLeft;
+ final int clampedDy = clampedY - oldTop;
+ mCallback.onViewPositionChanged(mCapturedView, clampedX, clampedY, clampedDx, clampedDy);
+ }
+ }
+
+ /**
+ * Determine if the currently captured view is under the given point in the parent view's coordinate system. If
+ * there is no captured view this method will return false.
+ *
+ * @param x
+ * X position to test in the parent's coordinate system
+ * @param y
+ * Y position to test in the parent's coordinate system
+ * @return true if the captured view is under the given point, false otherwise
+ */
+ public boolean isCapturedViewUnder(int x, int y) {
+ return isViewUnder(mCapturedView, x, y);
+ }
+
+ /**
+ * Determine if the supplied view is under the given point in the parent view's coordinate system.
+ *
+ * @param view
+ * Child view of the parent to hit test
+ * @param x
+ * X position to test in the parent's coordinate system
+ * @param y
+ * Y position to test in the parent's coordinate system
+ * @return true if the supplied view is under the given point, false otherwise
+ */
+ public boolean isViewUnder(View view, int x, int y) {
+ if (view == null) {
+ return false;
+ }
+ return x >= view.getLeft() && x < view.getRight() && y >= view.getTop() && y < view.getBottom();
+ }
+
+ /**
+ * Find the topmost child under the given point within the parent view's coordinate system. The child order is
+ * determined using {@link Callback#getOrderedChildIndex(int)}.
+ *
+ * @param x
+ * X position to test in the parent's coordinate system
+ * @param y
+ * Y position to test in the parent's coordinate system
+ * @return The topmost child view under (x, y) or null if none found.
+ */
+ public View findTopChildUnder(int x, int y) {
+ final int childCount = mParentView.getChildCount();
+ for (int i = childCount - 1; i >= 0; i--) {
+ final View child = mParentView.getChildAt(mCallback.getOrderedChildIndex(i));
+ if (x >= child.getLeft() && x < child.getRight() && y >= child.getTop() && y < child.getBottom()) {
+ return child;
+ }
+ }
+ return null;
+ }
+
+ private int getEdgesTouched(int x, int y) {
+ int result = 0;
+
+ if (x < mParentView.getLeft() + mEdgeSize) result |= EDGE_LEFT;
+ if (y < mParentView.getTop() + mEdgeSize) result |= EDGE_TOP;
+ if (x > mParentView.getRight() - mEdgeSize) result |= EDGE_RIGHT;
+ if (y > mParentView.getBottom() - mEdgeSize) result |= EDGE_BOTTOM;
+
+ return result;
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/termux/drawer/package-info.java b/app/src/main/java/com/termux/drawer/package-info.java
new file mode 100644
index 0000000000..84bf92f77c
--- /dev/null
+++ b/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
+ * Android Support Library.
+ *
+ * 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;
+
diff --git a/app/src/main/java/com/termux/terminal/ByteQueue.java b/app/src/main/java/com/termux/terminal/ByteQueue.java
new file mode 100644
index 0000000000..1eb3e59def
--- /dev/null
+++ b/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;
+ }
+}
diff --git a/app/src/main/java/com/termux/terminal/EmulatorDebug.java b/app/src/main/java/com/termux/terminal/EmulatorDebug.java
new file mode 100644
index 0000000000..213657a92c
--- /dev/null
+++ b/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";
+
+}
diff --git a/app/src/main/java/com/termux/terminal/JNI.java b/app/src/main/java/com/termux/terminal/JNI.java
new file mode 100644
index 0000000000..423541a6a7
--- /dev/null
+++ b/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);
+
+}
diff --git a/app/src/main/java/com/termux/terminal/KeyHandler.java b/app/src/main/java/com/termux/terminal/KeyHandler.java
new file mode 100644
index 0000000000..0145137652
--- /dev/null
+++ b/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 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 keypad home key
+ // t_K3 keypad page-up key
+ // t_K4 keypad end key
+ // t_K5 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 and keys.
+ // normal vt100 ~
+ // t_k1 [11~ OP *-xterm*
+ // t_k2 [12~ OQ *-xterm*
+ // t_k3 [13~ OR *-xterm*
+ // t_k4 [14~ OS *-xterm*
+ // t_kh [7~ OH *-xterm*
+ // t_@7 [4~ OF *-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;
+ }
+}
diff --git a/app/src/main/java/com/termux/terminal/TerminalBuffer.java b/app/src/main/java/com/termux/terminal/TerminalBuffer.java
new file mode 100644
index 0000000000..2305f0e36b
--- /dev/null
+++ b/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.
+ *
+ *
+ *
External coordinate system: -mActiveTranscriptRows to mScreenRows-1, with the screen being 0..mScreenRows-1.
+ *
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).
+ *
+ *
+ * @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);
+ }
+ }
+ }
+
+}
diff --git a/app/src/main/java/com/termux/terminal/TerminalColorScheme.java b/app/src/main/java/com/termux/terminal/TerminalColorScheme.java
new file mode 100644
index 0000000000..1721dc1978
--- /dev/null
+++ b/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 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;
+ }
+ }
+
+}
diff --git a/app/src/main/java/com/termux/terminal/TerminalColors.java b/app/src/main/java/com/termux/terminal/TerminalColors.java
new file mode 100644
index 0000000000..3c9f10cd22
--- /dev/null
+++ b/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:// where , , := 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;
+ }
+
+}
diff --git a/app/src/main/java/com/termux/terminal/TerminalEmulator.java b/app/src/main/java/com/termux/terminal/TerminalEmulator.java
new file mode 100644
index 0000000000..96e2e89d81
--- /dev/null
+++ b/app/src/main/java/com/termux/terminal/TerminalEmulator.java
@@ -0,0 +1,2290 @@
+package com.termux.terminal;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.Stack;
+
+import android.util.Base64;
+import android.util.Log;
+
+/**
+ * Renders text into a screen. Contains all the terminal-specific knowledge and state. Emulates a subset of the X Window
+ * System xterm terminal, which in turn is an emulator for a subset of the Digital Equipment Corporation vt100 terminal.
+ *
+ * References:
+ *
http://woldlab.caltech.edu/~diane/kde4.10/workingdir/kubuntu/konsole/doc/developer/old-documents/VT100/techref.
+ * html - document for konsole - accessible!
+ *
+ */
+public final class TerminalEmulator {
+
+ /** Log unknown or unimplemented escape sequences received from the shell process. */
+ private static final boolean LOG_ESCAPE_SEQUENCES = false;
+
+ public static final int MOUSE_LEFT_BUTTON = 0;
+ public static final int MOUSE_MIDDLE_BUTTON = 1;
+ public static final int MOUSE_RIGHT_BUTTON = 2;
+ /** Mouse moving while having left mouse button pressed. */
+ public static final int MOUSE_LEFT_BUTTON_MOVED = 32;
+ public static final int MOUSE_WHEELUP_BUTTON = 64;
+ public static final int MOUSE_WHEELDOWN_BUTTON = 65;
+
+ public static final int CURSOR_STYLE_BLOCK = 0;
+ public static final int CURSOR_STYLE_UNDERLINE = 1;
+ public static final int CURSOR_STYLE_BAR = 2;
+
+ /** Used for invalid data - http://en.wikipedia.org/wiki/Replacement_character#Replacement_character */
+ public static final int UNICODE_REPLACEMENT_CHAR = 0xFFFD;
+
+ /** Escape processing: Not currently in an escape sequence. */
+ private static final int ESC_NONE = 0;
+ /** Escape processing: Have seen an ESC character - proceed to {@link #doEsc(int)} */
+ private static final int ESC = 1;
+ /** Escape processing: Have seen ESC POUND */
+ private static final int ESC_POUND = 2;
+ /** Escape processing: Have seen ESC and a character-set-select ( char */
+ private static final int ESC_SELECT_LEFT_PAREN = 3;
+ /** Escape processing: Have seen ESC and a character-set-select ) char */
+ private static final int ESC_SELECT_RIGHT_PAREN = 4;
+ /** Escape processing: Have seen ESC and a character-set-select + char */
+ // private static final int ESC_SELECT_PLUS = 5;
+ /** Escape processing: "ESC [" or CSI (Control Sequence Introducer). */
+ private static final int ESC_CSI = 6;
+ /** Escape processing: ESC [ ? */
+ private static final int ESC_CSI_QUESTIONMARK = 7;
+ /** Escape processing: ESC [ $ */
+ private static final int ESC_CSI_DOLLAR = 8;
+ /** Escape processing: ESC % */
+ private static final int ESC_PERCENT = 9;
+ /** Escape processing: ESC ] (AKA OSC - Operating System Controls) */
+ private static final int ESC_OSC = 10;
+ /** Escape processing: ESC ] (AKA OSC - Operating System Controls) ESC */
+ private static final int ESC_OSC_ESC = 11;
+ /** Escape processing: ESC [ > */
+ private static final int ESC_CSI_BIGGERTHAN = 12;
+ /** Escape procession: "ESC P" or Device Control String (DCS) */
+ private static final int ESC_P = 13;
+ /** Escape processing: CSI > */
+ private static final int ESC_CSI_QUESTIONMARK_ARG_DOLLAR = 14;
+ /** Escape processing: CSI $ARGS ' ' */
+ private static final int ESC_CSI_ARGS_SPACE = 15;
+ /** Escape processing: CSI $ARGS '*' */
+ private static final int ESC_CSI_ARGS_ASTERIX = 16;
+ /** Escape processing: CSI " */
+ private static final int ESC_CSI_DOUBLE_QUOTE = 17;
+ /** Escape processing: CSI ' */
+ private static final int ESC_CSI_SINGLE_QUOTE = 18;
+ /** Escape processing: CSI ! */
+ private static final int ESC_CSI_EXCLAMATION = 19;
+
+ /** The number of parameter arguments. This name comes from the ANSI standard for terminal escape codes. */
+ private static final int MAX_ESCAPE_PARAMETERS = 16;
+
+ /** Needs to be large enough to contain reasonable OSC 52 pastes. */
+ private static final int MAX_OSC_STRING_LENGTH = 8192;
+
+ /** DECSET 1 - application cursor keys. */
+ private static final int DECSET_BIT_APPLICATION_CURSOR_KEYS = 1;
+ private static final int DECSET_BIT_REVERSE_VIDEO = 1 << 1;
+ /**
+ * http://www.vt100.net/docs/vt510-rm/DECOM: "When DECOM is set, the home cursor position is at the upper-left
+ * corner of the screen, within the margins. The starting point for line numbers depends on the current top margin
+ * setting. The cursor cannot move outside of the margins. When DECOM is reset, the home cursor position is at the
+ * upper-left corner of the screen. The starting point for line numbers is independent of the margins. The cursor
+ * can move outside of the margins."
+ */
+ private static final int DECSET_BIT_ORIGIN_MODE = 1 << 2;
+ /**
+ * http://www.vt100.net/docs/vt510-rm/DECAWM: "If the DECAWM function is set, then graphic characters received when
+ * the cursor is at the right border of the page appear at the beginning of the next line. Any text on the page
+ * scrolls up if the cursor is at the end of the scrolling region. If the DECAWM function is reset, then graphic
+ * characters received when the cursor is at the right border of the page replace characters already on the page."
+ */
+ private static final int DECSET_BIT_AUTOWRAP = 1 << 3;
+ /** DECSET 25 - if the cursor should be visible, {@link #isShowingCursor()}. */
+ private static final int DECSET_BIT_SHOWING_CURSOR = 1 << 4;
+ private static final int DECSET_BIT_APPLICATION_KEYPAD = 1 << 5;
+ /** DECSET 1000 - if to report mouse press&release events. */
+ private static final int DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE = 1 << 6;
+ /** DECSET 1002 - like 1000, but report moving mouse while pressed. */
+ private static final int DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT = 1 << 7;
+ /** DECSET 1004 - NOT implemented. */
+ private static final int DECSET_BIT_SEND_FOCUS_EVENTS = 1 << 8;
+ /** DECSET 1006 - SGR-like mouse protocol (the modern sane choice). */
+ private static final int DECSET_BIT_MOUSE_PROTOCOL_SGR = 1 << 9;
+ /** DECSET 2004 - see {@link #paste(String)} */
+ private static final int DECSET_BIT_BRACKETED_PASTE_MODE = 1 << 10;
+ /** Toggled with DECLRMM - http://www.vt100.net/docs/vt510-rm/DECLRMM */
+ private static final int DECSET_BIT_LEFTRIGHT_MARGIN_MODE = 1 << 11;
+ /** Not really DECSET bit... - http://www.vt100.net/docs/vt510-rm/DECSACE */
+ private static final int DECSET_BIT_RECTANGULAR_CHANGEATTRIBUTE = 1 << 12;
+
+ private String mTitle;
+ private final Stack mTitleStack = new Stack<>();
+
+ /** The cursor position. Between (0,0) and (mRows-1, mColumns-1). */
+ private int mCursorRow, mCursorCol;
+
+ private int mCursorStyle = CURSOR_STYLE_BLOCK;
+
+ /** The number of character rows and columns in the terminal screen. */
+ public int mRows, mColumns;
+
+ /** The normal screen buffer. Stores the characters that appear on the screen of the emulated terminal. */
+ private final TerminalBuffer mMainBuffer;
+ /**
+ * The alternate screen buffer, exactly as large as the display and contains no additional saved lines (so that when
+ * the alternate screen buffer is active, you cannot scroll back to view saved lines).
+ *
+ * See http://www.xfree86.org/current/ctlseqs.html#The%20Alternate%20Screen%20Buffer
+ */
+ final TerminalBuffer mAltBuffer;
+ /** The current screen buffer, pointing at either {@link #mMainBuffer} or {@link #mAltBuffer}. */
+ private TerminalBuffer mScreen;
+
+ /** The terminal session this emulator is bound to. */
+ private final TerminalOutput mSession;
+
+ /** Keeps track of the current argument of the current escape sequence. Ranges from 0 to MAX_ESCAPE_PARAMETERS-1. */
+ private int mArgIndex;
+ /** Holds the arguments of the current escape sequence. */
+ private final int[] mArgs = new int[MAX_ESCAPE_PARAMETERS];
+
+ /** Holds OSC and device control arguments, which can be strings. */
+ private final StringBuilder mOSCOrDeviceControlArgs = new StringBuilder();
+
+ /**
+ * True if the current escape sequence should continue, false if the current escape sequence should be terminated.
+ * Used when parsing a single character.
+ */
+ private boolean mContinueSequence;
+
+ /** The current state of the escape sequence state machine. One of the ESC_* constants. */
+ private int mEscapeState;
+
+ private final SavedScreenState mSavedStateMain = new SavedScreenState();
+ private final SavedScreenState mSavedStateAlt = new SavedScreenState();
+
+ /** http://www.vt100.net/docs/vt102-ug/table5-15.html */
+ private boolean mUseLineDrawingG0, mUseLineDrawingG1, mUseLineDrawingUsesG0 = true;
+
+ /**
+ * @see TerminalEmulator#mapDecSetBitToInternalBit(int)
+ */
+ private int mCurrentDecSetFlags, mSavedDecSetFlags;
+
+ /**
+ * If insert mode (as opposed to replace mode) is active. In insert mode new characters are inserted, pushing
+ * existing text to the right. Characters moved past the right margin are lost.
+ */
+ private boolean mInsertMode;
+
+ /** An array of tab stops. mTabStop[i] is true if there is a tab stop set for column i. */
+ private boolean[] mTabStop;
+
+ /**
+ * Top margin of screen for scrolling ranges from 0 to mRows-2. Bottom margin ranges from mTopMargin + 2 to mRows
+ * (Defines the first row after the scrolling region). Left/right margin in [0, mColumns].
+ */
+ private int mTopMargin, mBottomMargin, mLeftMargin, mRightMargin;
+
+ /**
+ * If the next character to be emitted will be automatically wrapped to the next line. Used to disambiguate the case
+ * where the cursor is positioned on the last column (mColumns-1). When standing there, a written character will be
+ * output in the last column, the cursor not moving but this flag will be set. When outputting another character
+ * this will move to the next line.
+ */
+ private boolean mAboutToAutoWrap;
+
+ /** Foreground and background color indices, 0..255. */
+ int mForeColor, mBackColor;
+
+ /** Current TextStyle effect */
+ private int mEffect;
+
+ /**
+ * The number of scrolled lines since last calling {@link #clearScrollCounter()}. Used for moving selection up along
+ * with the scrolling text.
+ */
+ private int mScrollCounter = 0;
+
+ private int mUtf8ToFollow, mUtf8Index;
+ private final byte[] mUtf8InputBuffer = new byte[4];
+
+ public final TerminalColors mColors = new TerminalColors();
+
+ private boolean isDecsetInternalBitSet(int bit) {
+ return (mCurrentDecSetFlags & bit) != 0;
+ }
+
+ private void setDecsetinternalBit(int internalBit, boolean set) {
+ if (set) {
+ // The mouse modes are mutually exclusive.
+ if (internalBit == DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE) {
+ setDecsetinternalBit(DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT, false);
+ } else if (internalBit == DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT) {
+ setDecsetinternalBit(DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE, false);
+ }
+ }
+ if (set) {
+ mCurrentDecSetFlags |= internalBit;
+ } else {
+ mCurrentDecSetFlags &= ~internalBit;
+ }
+ }
+
+ static int mapDecSetBitToInternalBit(int decsetBit) {
+ switch (decsetBit) {
+ case 1:
+ return DECSET_BIT_APPLICATION_CURSOR_KEYS;
+ case 5:
+ return DECSET_BIT_REVERSE_VIDEO;
+ case 6:
+ return DECSET_BIT_ORIGIN_MODE;
+ case 7:
+ return DECSET_BIT_AUTOWRAP;
+ case 25:
+ return DECSET_BIT_SHOWING_CURSOR;
+ case 66:
+ return DECSET_BIT_APPLICATION_KEYPAD;
+ case 69:
+ return DECSET_BIT_LEFTRIGHT_MARGIN_MODE;
+ case 1000:
+ return DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE;
+ case 1002:
+ return DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT;
+ case 1004:
+ return DECSET_BIT_SEND_FOCUS_EVENTS;
+ case 1006:
+ return DECSET_BIT_MOUSE_PROTOCOL_SGR;
+ case 2004:
+ return DECSET_BIT_BRACKETED_PASTE_MODE;
+ default:
+ return -1;
+ // throw new IllegalArgumentException("Unsupported decset: " + decsetBit);
+ }
+ }
+
+ public TerminalEmulator(TerminalOutput session, int columns, int rows, int transcriptRows) {
+ mSession = session;
+ mScreen = mMainBuffer = new TerminalBuffer(columns, transcriptRows, rows);
+ mAltBuffer = new TerminalBuffer(columns, rows, rows);
+ mRows = rows;
+ mColumns = columns;
+ mTabStop = new boolean[mColumns];
+ reset();
+ }
+
+ public TerminalBuffer getScreen() {
+ return mScreen;
+ }
+
+ public boolean isAlternateBufferActive() {
+ return mScreen == mAltBuffer;
+ }
+
+ /**
+ * @param mouseButton
+ * one of the MOUSE_* constants of this class.
+ */
+ public void sendMouseEvent(int mouseButton, int column, int row, boolean pressed) {
+ if (mouseButton == MOUSE_LEFT_BUTTON_MOVED && !isDecsetInternalBitSet(DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT)) {
+ // Do not send tracking.
+ } else if (isDecsetInternalBitSet(DECSET_BIT_MOUSE_PROTOCOL_SGR)) {
+ mSession.write(String.format("\033[<%d;%d;%d" + (pressed ? 'M' : 'm'), mouseButton, column, row));
+ } else {
+ mouseButton = pressed ? mouseButton : 3; // 3 for release of all buttons.
+ // Clip to screen, and clip to the limits of 8-bit data.
+ boolean out_of_bounds = column < 1 || row < 1 || column > mColumns || row > mRows || column > 255 - 32 || row > 255 - 32;
+ if (!out_of_bounds) {
+ byte[] data = { '\033', '[', 'M', (byte) (32 + mouseButton), (byte) (32 + column), (byte) (32 + row) };
+ mSession.write(data, 0, data.length);
+ }
+ }
+ }
+
+ public void resize(int columns, int rows) {
+ if (mRows == rows && mColumns == columns) {
+ return;
+ } else if (columns < 2 || rows < 2) {
+ throw new IllegalArgumentException("rows=" + rows + ", columns=" + columns);
+ }
+
+ if (mRows != rows) {
+ mRows = rows;
+ mTopMargin = 0;
+ mBottomMargin = mRows;
+ }
+ if (mColumns != columns) {
+ int oldColumns = mColumns;
+ mColumns = columns;
+ boolean[] oldTabStop = mTabStop;
+ mTabStop = new boolean[mColumns];
+ setDefaultTabStops();
+ int toTransfer = Math.min(oldColumns, columns);
+ System.arraycopy(oldTabStop, 0, mTabStop, 0, toTransfer);
+ mLeftMargin = 0;
+ mRightMargin = mColumns;
+ }
+
+ resizeScreen();
+ }
+
+ private void resizeScreen() {
+ final int[] cursor = { mCursorCol, mCursorRow };
+ int newTotalRows = (mScreen == mAltBuffer) ? mRows : mMainBuffer.mTotalRows;
+ mScreen.resize(mColumns, mRows, newTotalRows, cursor, getStyle(), isAlternateBufferActive());
+ mCursorCol = cursor[0];
+ mCursorRow = cursor[1];
+ }
+
+ public int getCursorRow() {
+ return mCursorRow;
+ }
+
+ public int getCursorCol() {
+ return mCursorCol;
+ }
+
+ /** {@link #CURSOR_STYLE_BAR}, {@link #CURSOR_STYLE_BLOCK} or {@link #CURSOR_STYLE_UNDERLINE} */
+ public int getCursorStyle() {
+ return mCursorStyle;
+ }
+
+ public boolean isReverseVideo() {
+ return isDecsetInternalBitSet(DECSET_BIT_REVERSE_VIDEO);
+ }
+
+ public boolean isShowingCursor() {
+ return isDecsetInternalBitSet(DECSET_BIT_SHOWING_CURSOR);
+ }
+
+ public boolean isKeypadApplicationMode() {
+ return isDecsetInternalBitSet(DECSET_BIT_APPLICATION_KEYPAD);
+ }
+
+ public boolean isCursorKeysApplicationMode() {
+ return isDecsetInternalBitSet(DECSET_BIT_APPLICATION_CURSOR_KEYS);
+ }
+
+ /** If mouse events are being sent as escape codes to the terminal. */
+ public boolean isMouseTrackingActive() {
+ return isDecsetInternalBitSet(DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE) || isDecsetInternalBitSet(DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT);
+ }
+
+ private void setDefaultTabStops() {
+ for (int i = 0; i < mColumns; i++)
+ mTabStop[i] = (i & 7) == 0 && i != 0;
+ }
+
+ /**
+ * Accept bytes (typically from the pseudo-teletype) and process them.
+ *
+ * @param buffer
+ * a byte array containing the bytes to be processed
+ * @param length
+ * the number of bytes in the array to process
+ */
+ public void append(byte[] buffer, int length) {
+ for (int i = 0; i < length; i++)
+ processByte(buffer[i]);
+ }
+
+ private void processByte(byte byteToProcess) {
+ if (mUtf8ToFollow > 0) {
+ if ((byteToProcess & 0b11000000) == 0b10000000) {
+ // 10xxxxxx, a continuation byte.
+ mUtf8InputBuffer[mUtf8Index++] = byteToProcess;
+ if (--mUtf8ToFollow == 0) {
+ byte firstByteMask = (byte) (mUtf8Index == 2 ? 0b00011111 : (mUtf8Index == 3 ? 0b00001111 : 0b00000111));
+ int codePoint = (mUtf8InputBuffer[0] & firstByteMask);
+ for (int i = 1; i < mUtf8Index; i++)
+ codePoint = ((codePoint << 6) | (mUtf8InputBuffer[i] & 0b00111111));
+ if (((codePoint <= 0b1111111) && mUtf8Index > 1) || (codePoint < 0b11111111111 && mUtf8Index > 2)
+ || (codePoint < 0b1111111111111111 && mUtf8Index > 3)) {
+ // Overlong encoding.
+ codePoint = UNICODE_REPLACEMENT_CHAR;
+ }
+
+ mUtf8Index = mUtf8ToFollow = 0;
+
+ if (codePoint >= 0x80 && codePoint <= 0x9F) {
+ // Sequence decoded to a C1 control character which is the same as escape followed by
+ // ((code & 0x7F) + 0x40).
+ processCodePoint(/* escape (hexadecimal=0x1B, octal=033): */27);
+ processCodePoint((codePoint & 0x7F) + 0x40);
+ } else {
+ if (Character.UNASSIGNED == Character.getType(codePoint)) codePoint = UNICODE_REPLACEMENT_CHAR;
+ processCodePoint(codePoint);
+ }
+ }
+ } else {
+ // Not a UTF-8 continuation byte so replace the entire sequence up to now with the replacement char:
+ mUtf8Index = mUtf8ToFollow = 0;
+ emitCodePoint(UNICODE_REPLACEMENT_CHAR);
+ // The Unicode Standard Version 6.2 – Core Specification
+ // (http://www.unicode.org/versions/Unicode6.2.0/ch03.pdf):
+ // "If the converter encounters an ill-formed UTF-8 code unit sequence which starts with a valid first
+ // byte, but which does not continue with valid successor bytes (see Table 3-7), it must not consume the
+ // successor bytes as part of the ill-formed subsequence
+ // whenever those successor bytes themselves constitute part of a well-formed UTF-8 code unit
+ // subsequence."
+ processByte(byteToProcess);
+ }
+ } else {
+ if ((byteToProcess & 0b10000000) == 0) { // The leading bit is not set so it is a 7-bit ASCII character.
+ processCodePoint(byteToProcess);
+ return;
+ } else if ((byteToProcess & 0b11100000) == 0b11000000) { // 110xxxxx, a two-byte sequence.
+ mUtf8ToFollow = 1;
+ } else if ((byteToProcess & 0b11110000) == 0b11100000) { // 1110xxxx, a three-byte sequence.
+ mUtf8ToFollow = 2;
+ } else if ((byteToProcess & 0b11111000) == 0b11110000) { // 11110xxx, a four-byte sequence.
+ mUtf8ToFollow = 3;
+ } else {
+ // Not a valid UTF-8 sequence start, signal invalid data:
+ processCodePoint(UNICODE_REPLACEMENT_CHAR);
+ return;
+ }
+ mUtf8InputBuffer[mUtf8Index++] = byteToProcess;
+ }
+ }
+
+ public void processCodePoint(int b) {
+ switch (b) {
+ case 0: // Null character (NUL, ^@). Do nothing.
+ break;
+ case 7: // Bell (BEL, ^G, \a). If in an OSC sequence, BEL may terminate a string; otherwise signal bell.
+ if (mEscapeState == ESC_OSC)
+ doOsc(b);
+ else
+ mSession.onBell();
+ break;
+ case 8: // BS
+ setCursorCol(Math.max(mLeftMargin, mCursorCol - 1));
+ break;
+ case 9: // Horizontal tab - move to next tab stop, but not past edge of screen
+ int nextTabStop = nextTabStop(1);
+ while (mCursorCol < nextTabStop) {
+ // Emit newlines to get background color right.
+ processCodePoint(' ');
+ }
+ break;
+ case 10: // Line feed (LF, \n).
+ case 11: // Vertical tab (VT, \v).
+ case 12: // Form feed (FF, \f).
+ doLinefeed();
+ break;
+ case 13: // Carriage return (CR, \r).
+ setCursorCol(mLeftMargin);
+ break;
+ case 14: // Shift Out (Ctrl-N, SO) → Switch to Alternate Character Set. This invokes the G1 character set.
+ mUseLineDrawingUsesG0 = false;
+ break;
+ case 15: // Shift In (Ctrl-O, SI) → Switch to Standard Character Set. This invokes the G0 character set.
+ mUseLineDrawingUsesG0 = true;
+ break;
+ case 24: // CAN.
+ case 26: // SUB.
+ if (mEscapeState != ESC_NONE) {
+ // FIXME: What is this??
+ mEscapeState = ESC_NONE;
+ emitCodePoint(127);
+ }
+ break;
+ case 27: // ESC
+ // Starts an escape sequence unless we're parsing a string
+ if (mEscapeState == ESC_P) {
+ // XXX: Ignore escape when reading device control sequence, since it may be part of string terminator.
+ return;
+ } else if (mEscapeState != ESC_OSC) {
+ startEscapeSequence();
+ } else {
+ doOsc(b);
+ }
+ break;
+ default:
+ mContinueSequence = false;
+ switch (mEscapeState) {
+ case ESC_NONE:
+ if (b >= 32) emitCodePoint(b);
+ break;
+ case ESC:
+ doEsc(b);
+ break;
+ case ESC_POUND:
+ doEscPound(b);
+ break;
+ case ESC_SELECT_LEFT_PAREN: // Designate G0 Character Set (ISO 2022, VT100).
+ mUseLineDrawingG0 = (b == '0');
+ break;
+ case ESC_SELECT_RIGHT_PAREN: // Designate G1 Character Set (ISO 2022, VT100).
+ mUseLineDrawingG1 = (b == '0');
+ break;
+ case ESC_CSI:
+ doCsi(b);
+ break;
+ case ESC_CSI_EXCLAMATION:
+ if (b == 'p') { // Soft terminal reset (DECSTR, http://vt100.net/docs/vt510-rm/DECSTR).
+ reset();
+ } else {
+ unknownSequence(b);
+ }
+ break;
+ case ESC_CSI_QUESTIONMARK:
+ doCsiQuestionMark(b);
+ break;
+ case ESC_CSI_BIGGERTHAN:
+ doCsiBiggerThan(b);
+ break;
+ case ESC_CSI_DOLLAR:
+ boolean originMode = isDecsetInternalBitSet(DECSET_BIT_ORIGIN_MODE);
+ int effectiveTopMargin = originMode ? mTopMargin : 0;
+ int effectiveBottomMargin = originMode ? mBottomMargin : mRows;
+ int effectiveLeftMargin = originMode ? mLeftMargin : 0;
+ int effectiveRightMargin = originMode ? mRightMargin : mColumns;
+ switch (b) {
+ case 'v': // ${CSI}${SRC_TOP}${SRC_LEFT}${SRC_BOTTOM}${SRC_RIGHT}${SRC_PAGE}${DST_TOP}${DST_LEFT}${DST_PAGE}$v"
+ // Copy rectangular area (DECCRA - http://vt100.net/docs/vt510-rm/DECCRA):
+ // "If Pbs is greater than Pts, or Pls is greater than Prs, the terminal ignores DECCRA.
+ // The coordinates of the rectangular area are affected by the setting of origin mode (DECOM).
+ // DECCRA is not affected by the page margins.
+ // The copied text takes on the line attributes of the destination area.
+ // If the value of Pt, Pl, Pb, or Pr exceeds the width or height of the active page, then the value
+ // is treated as the width or height of that page.
+ // If the destination area is partially off the page, then DECCRA clips the off-page data.
+ // DECCRA does not change the active cursor position."
+ int topSource = Math.min(getArg(0, 1, true) - 1 + effectiveTopMargin, mRows);
+ int leftSource = Math.min(getArg(1, 1, true) - 1 + effectiveLeftMargin, mColumns);
+ // Inclusive, so do not subtract one:
+ int bottomSource = Math.min(Math.max(getArg(2, mRows, true) + effectiveTopMargin, topSource), mRows);
+ int rightSource = Math.min(Math.max(getArg(3, mColumns, true) + effectiveLeftMargin, leftSource), mColumns);
+ // int sourcePage = getArg(4, 1, true);
+ int destionationTop = Math.min(getArg(5, 1, true) - 1 + effectiveTopMargin, mRows);
+ int destinationLeft = Math.min(getArg(6, 1, true) - 1 + effectiveLeftMargin, mColumns);
+ // int destinationPage = getArg(7, 1, true);
+ int heightToCopy = Math.min(mRows - destionationTop, bottomSource - topSource);
+ int widthToCopy = Math.min(mColumns - destinationLeft, rightSource - leftSource);
+ mScreen.blockCopy(leftSource, topSource, widthToCopy, heightToCopy, destinationLeft, destionationTop);
+ break;
+ case '{': // ${CSI}${TOP}${LEFT}${BOTTOM}${RIGHT}${"
+ // Selective erase rectangular area (DECSERA - http://www.vt100.net/docs/vt510-rm/DECSERA).
+ case 'x': // ${CSI}${CHAR};${TOP}${LEFT}${BOTTOM}${RIGHT}$x"
+ // Fill rectangular area (DECFRA - http://www.vt100.net/docs/vt510-rm/DECFRA).
+ case 'z': // ${CSI}$${TOP}${LEFT}${BOTTOM}${RIGHT}$z"
+ // Erase rectangular area (DECERA - http://www.vt100.net/docs/vt510-rm/DECERA).
+ boolean erase = b != 'x';
+ boolean selective = b == '{';
+ // Only DECSERA keeps visual attributes, DECERA does not:
+ boolean keepVisualAttributes = erase && selective;
+ int argIndex = 0;
+ int fillChar = erase ? ' ' : getArg(argIndex++, -1, true);
+ // "Pch can be any value from 32 to 126 or from 160 to 255. If Pch is not in this range, then the
+ // terminal ignores the DECFRA command":
+ if ((fillChar >= 32 && fillChar <= 126) || (fillChar >= 160 && fillChar <= 255)) {
+ // "If the value of Pt, Pl, Pb, or Pr exceeds the width or height of the active page, the value
+ // is treated as the width or height of that page."
+ int top = Math.min(getArg(argIndex++, 1, true) + effectiveTopMargin, effectiveBottomMargin + 1);
+ int left = Math.min(getArg(argIndex++, 1, true) + effectiveLeftMargin, effectiveRightMargin + 1);
+ int bottom = Math.min(getArg(argIndex++, mRows, true) + effectiveTopMargin, effectiveBottomMargin);
+ int right = Math.min(getArg(argIndex, mColumns, true) + effectiveLeftMargin, effectiveRightMargin);
+ int style = getStyle();
+ for (int row = top - 1; row < bottom; row++)
+ for (int col = left - 1; col < right; col++)
+ if (!selective || (TextStyle.decodeEffect(mScreen.getStyleAt(row, col)) & TextStyle.CHARACTER_ATTRIBUTE_PROTECTED) == 0)
+ mScreen.setChar(col, row, fillChar, keepVisualAttributes ? mScreen.getStyleAt(row, col) : style);
+ }
+ break;
+ case 'r': // "${CSI}${TOP}${LEFT}${BOTTOM}${RIGHT}${ATTRIBUTES}$r"
+ // Change attributes in rectangular area (DECCARA - http://vt100.net/docs/vt510-rm/DECCARA).
+ case 't': // "${CSI}${TOP}${LEFT}${BOTTOM}${RIGHT}${ATTRIBUTES}$t"
+ // Reverse attributes in rectangular area (DECRARA - http://www.vt100.net/docs/vt510-rm/DECRARA).
+ boolean reverse = b == 't';
+ // FIXME: "coordinates of the rectangular area are affected by the setting of origin mode (DECOM)".s
+ int top = Math.min(getArg(0, 1, true) - 1, effectiveBottomMargin) + effectiveTopMargin;
+ int left = Math.min(getArg(1, 1, true) - 1, effectiveRightMargin) + effectiveLeftMargin;
+ int bottom = Math.min(getArg(2, mRows, true) + 1, effectiveBottomMargin - 1) + effectiveTopMargin;
+ int right = Math.min(getArg(3, mColumns, true) + 1, effectiveRightMargin - 1) + effectiveLeftMargin;
+ if (mArgIndex >= 4) {
+ for (int i = 4; i <= mArgIndex; i++) {
+ int bits = 0;
+ boolean setOrClear = true; // True if setting, false if clearing.
+ switch (getArg(i, 0, false)) {
+ case 0: // Attributes off (no bold, no underline, no blink, positive image).
+ bits = (TextStyle.CHARACTER_ATTRIBUTE_BOLD | TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE | TextStyle.CHARACTER_ATTRIBUTE_BLINK
+ | TextStyle.CHARACTER_ATTRIBUTE_INVERSE);
+ if (!reverse) setOrClear = false;
+ break;
+ case 1: // Bold.
+ bits = TextStyle.CHARACTER_ATTRIBUTE_BOLD;
+ break;
+ case 4: // Underline.
+ bits = TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;
+ break;
+ case 5: // Blink.
+ bits = TextStyle.CHARACTER_ATTRIBUTE_BLINK;
+ break;
+ case 7: // Negative image.
+ bits = TextStyle.CHARACTER_ATTRIBUTE_INVERSE;
+ break;
+ case 22: // No bold.
+ bits = TextStyle.CHARACTER_ATTRIBUTE_BOLD;
+ setOrClear = false;
+ break;
+ case 24: // No underline.
+ bits = TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;
+ setOrClear = false;
+ break;
+ case 25: // No blink.
+ bits = TextStyle.CHARACTER_ATTRIBUTE_BLINK;
+ setOrClear = false;
+ break;
+ case 27: // Positive image.
+ bits = TextStyle.CHARACTER_ATTRIBUTE_INVERSE;
+ setOrClear = false;
+ break;
+ }
+ if (reverse && !setOrClear) {
+ // Reverse attributes in rectangular area ignores non-(1,4,5,7) bits.
+ } else {
+ mScreen.setOrClearEffect(bits, setOrClear, reverse, isDecsetInternalBitSet(DECSET_BIT_RECTANGULAR_CHANGEATTRIBUTE),
+ effectiveLeftMargin, effectiveRightMargin, top, left, bottom, right);
+ }
+ }
+ } else {
+ // Do nothing.
+ }
+ break;
+ default:
+ unknownSequence(b);
+ }
+ break;
+ case ESC_CSI_DOUBLE_QUOTE:
+ if (b == 'q') {
+ // http://www.vt100.net/docs/vt510-rm/DECSCA
+ int arg = getArg0(0);
+ if (arg == 0 || arg == 2) {
+ // DECSED and DECSEL can erase characters.
+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_PROTECTED;
+ } else if (arg == 1) {
+ // DECSED and DECSEL cannot erase characters.
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_PROTECTED;
+ } else {
+ unknownSequence(b);
+ }
+ } else {
+ unknownSequence(b);
+ }
+ break;
+ case ESC_CSI_SINGLE_QUOTE:
+ if (b == '}') { // Insert Ps Column(s) (default = 1) (DECIC), VT420 and up.
+ int columnsAfterCursor = mRightMargin - mCursorCol;
+ int columnsToInsert = Math.min(getArg0(1), columnsAfterCursor);
+ int columnsToMove = columnsAfterCursor - columnsToInsert;
+ mScreen.blockCopy(mCursorCol, 0, columnsToMove, mRows, mCursorCol + columnsToInsert, 0);
+ blockClear(mCursorCol, 0, columnsToInsert, mRows);
+ } else if (b == '~') { // Delete Ps Column(s) (default = 1) (DECDC), VT420 and up.
+ int columnsAfterCursor = mRightMargin - mCursorCol;
+ int columnsToDelete = Math.min(getArg0(1), columnsAfterCursor);
+ int columnsToMove = columnsAfterCursor - columnsToDelete;
+ mScreen.blockCopy(mCursorCol + columnsToDelete, 0, columnsToMove, mRows, mCursorCol, 0);
+ blockClear(mCursorRow + columnsToMove, 0, columnsToDelete, mRows);
+ } else {
+ unknownSequence(b);
+ }
+ break;
+ case ESC_PERCENT:
+ Log.i(EmulatorDebug.LOG_TAG, "Ignoring character set sequence 'ESC % " + (char) b + "'");
+ break;
+ case ESC_OSC:
+ doOsc(b);
+ break;
+ case ESC_OSC_ESC:
+ doOscEsc(b);
+ break;
+ case ESC_P:
+ doDeviceControl(b);
+ break;
+ case ESC_CSI_QUESTIONMARK_ARG_DOLLAR:
+ if (b == 'p') {
+ // Request DEC private mode (DECRQM).
+ int mode = getArg0(0);
+ int value;
+ if (mode == 47 || mode == 1047 || mode == 1049) {
+ // This state is carried by mScreen pointer.
+ value = (mScreen == mAltBuffer) ? 1 : 2;
+ } else {
+ int internalBit = mapDecSetBitToInternalBit(mode);
+ if (internalBit == -1) {
+ value = isDecsetInternalBitSet(internalBit) ? 1 : 2; // 1=set, 2=reset.
+ } else {
+ Log.e(EmulatorDebug.LOG_TAG, "Got DECRQM for unrecognized private DEC mode=" + mode);
+ value = 0; // 0=not recognized, 3=permanently set, 4=permanently reset
+ }
+ }
+ mSession.write(String.format(Locale.US, "\033[?%d;%d$y", mode, value));
+ } else {
+ unknownSequence(b);
+ }
+ break;
+ case ESC_CSI_ARGS_SPACE:
+ int arg = getArg0(0);
+ switch (b) {
+ case 'q': // "${CSI}${STYLE} q" - set cursor style (http://www.vt100.net/docs/vt510-rm/DECSCUSR).
+ switch (arg) {
+ case 0: // Blinking block.
+ case 1: // Blinking block.
+ case 2: // Steady block.
+ mCursorStyle = CURSOR_STYLE_BLOCK;
+ break;
+ case 3: // Blinking underline.
+ case 4: // Steady underline.
+ mCursorStyle = CURSOR_STYLE_UNDERLINE;
+ break;
+ case 5: // Blinking bar (xterm addition).
+ case 6: // Steady bar (xterm addition).
+ mCursorStyle = CURSOR_STYLE_BAR;
+ break;
+ }
+ break;
+ case 't':
+ case 'u':
+ // Set margin-bell volume - ignore.
+ break;
+ default:
+ unknownSequence(b);
+ }
+ break;
+ case ESC_CSI_ARGS_ASTERIX:
+ int attributeChangeExtent = getArg0(0);
+ if (b == 'x' && (attributeChangeExtent >= 0 && attributeChangeExtent <= 2)) {
+ // Select attribute change extent (DECSACE - http://www.vt100.net/docs/vt510-rm/DECSACE).
+ setDecsetinternalBit(DECSET_BIT_RECTANGULAR_CHANGEATTRIBUTE, attributeChangeExtent == 2);
+ } else {
+ unknownSequence(b);
+ }
+ break;
+ default:
+ unknownSequence(b);
+ break;
+ }
+ if (!mContinueSequence) mEscapeState = ESC_NONE;
+ break;
+ }
+ }
+
+ /** When in {@link #ESC_P} ("device control") sequence. */
+ private void doDeviceControl(int b) {
+ switch (b) {
+ case (byte) '\\': // End of ESC \ string Terminator
+ {
+ String dcs = mOSCOrDeviceControlArgs.toString();
+ // DCS $ q P t ST. Request Status String (DECRQSS)
+ if (dcs.startsWith("$q")) {
+ if (dcs.equals("$q\"p")) {
+ // DECSCL, conformance level, http://www.vt100.net/docs/vt510-rm/DECSCL:
+ String csiString = "64;1\"p";
+ mSession.write("\033P1$r" + csiString + "\033\\");
+ } else {
+ finishSequenceAndLogError("Unrecognized DECRQSS string: '" + dcs + "'");
+ }
+ } else if (dcs.startsWith("+q")) {
+ // Request Termcap/Terminfo String. The string following the "q" is a list of names encoded in
+ // hexadecimal (2 digits per character) separated by ; which correspond to termcap or terminfo key
+ // names.
+ // Two special features are also recognized, which are not key names: Co for termcap colors (or colors
+ // for terminfo colors), and TN for termcap name (or name for terminfo name).
+ // xterm responds with DCS 1 + r P t ST for valid requests, adding to P t an = , and the value of the
+ // corresponding string that xterm would send, or DCS 0 + r P t ST for invalid requests. The strings are
+ // encoded in hexadecimal (2 digits per character).
+ // Example:
+ // :kr=\EOC: ks=\E[?1h\E=: ku=\EOA: le=^H:mb=\E[5m:md=\E[1m:\
+ // where
+ // kd=down-arrow key
+ // kl=left-arrow key
+ // kr=right-arrow key
+ // ku=up-arrow key
+ // #2=key_shome, "shifted home"
+ // #4=key_sleft, "shift arrow left"
+ // %i=key_sright, "shift arrow right"
+ // *7=key_send, "shifted end"
+ // k1=F1 function key
+
+ // Example: Request for ku is "ESC P + q 6 b 7 5 ESC \", where 6b7d=ku in hexadecimal.
+ // Xterm response in normal cursor mode:
+ // "<27> P 1 + r 6 b 7 5 = 1 B 5 B 4 1" where 0x1B 0x5B 0x41 = 27 91 65 = ESC [ A
+ // Xterm response in application cursor mode:
+ // "<27> P 1 + r 6 b 7 5 = 1 B 5 B 4 1" where 0x1B 0x4F 0x41 = 27 91 65 = ESC 0 A
+
+ // #4 is "shift arrow left":
+ // *** Device Control (DCS) for '#4'- 'ESC P + q 23 34 ESC \'
+ // Response: <27> P 1 + r 2 3 3 4 = 1 B 5 B 3 1 3 B 3 2 4 4 <27> \
+ // where 0x1B 0x5B 0x31 0x3B 0x32 0x44 = ESC [ 1 ; 2 D
+ // which we find in: TermKeyListener.java: KEY_MAP.put(KEYMOD_SHIFT | KEYCODE_DPAD_LEFT, "\033[1;2D");
+
+ // See http://h30097.www3.hp.com/docs/base_doc/DOCUMENTATION/V40G_HTML/MAN/MAN4/0178____.HTM for what to
+ // respond, as well as http://www.freebsd.org/cgi/man.cgi?query=termcap&sektion=5#CAPABILITIES for
+ // the meaning of e.g. "ku", "kd", "kr", "kl"
+
+ for (String part : dcs.substring(2).split(";")) {
+ if (part.length() % 2 == 0) {
+ StringBuilder transBuffer = new StringBuilder();
+ for (int i = 0; i < part.length(); i += 2) {
+ char c = (char) Long.decode("0x" + part.charAt(i) + "" + part.charAt(i + 1)).longValue();
+ transBuffer.append(c);
+ }
+ String trans = transBuffer.toString();
+ String responseValue;
+ switch (trans) {
+ case "Co":
+ case "colors":
+ responseValue = "256"; // Number of colors.
+ break;
+ case "TN":
+ case "name":
+ responseValue = "xterm";
+ break;
+ default:
+ responseValue = KeyHandler.getCodeFromTermcap(trans, isDecsetInternalBitSet(DECSET_BIT_APPLICATION_CURSOR_KEYS),
+ isDecsetInternalBitSet(DECSET_BIT_APPLICATION_KEYPAD));
+ break;
+ }
+ if (responseValue == null) {
+ switch (trans) {
+ case "%1": // Help key - ignore
+ case "&8": // Undo key - ignore.
+ break;
+ default:
+ Log.w(EmulatorDebug.LOG_TAG, "Unhandled termcap/terminfo name: '" + trans + "'");
+ }
+ // Respond with invalid request:
+ mSession.write("\033P0+r" + part + "\033\\");
+ } else {
+ StringBuilder hexEncoded = new StringBuilder();
+ for (int j = 0; j < responseValue.length(); j++) {
+ hexEncoded.append(String.format("%02X", (int) responseValue.charAt(j)));
+ }
+ mSession.write("\033P1+r" + part + "=" + hexEncoded + "\033\\");
+ }
+ } else {
+ Log.e(EmulatorDebug.LOG_TAG, "Invalid device termcap/terminfo name of odd length: " + part);
+ }
+ }
+ } else {
+ if (LOG_ESCAPE_SEQUENCES) Log.e(EmulatorDebug.LOG_TAG, "Unrecognized device control string: " + dcs);
+ }
+ finishSequence();
+ }
+ break;
+ default:
+ if (mOSCOrDeviceControlArgs.length() > MAX_OSC_STRING_LENGTH) {
+ // Too long.
+ mOSCOrDeviceControlArgs.setLength(0);
+ finishSequence();
+ } else {
+ mOSCOrDeviceControlArgs.appendCodePoint(b);
+ continueSequence(mEscapeState);
+ }
+ }
+ }
+
+ private int nextTabStop(int numTabs) {
+ for (int i = mCursorCol + 1; i < mColumns; i++)
+ if (mTabStop[i] && --numTabs == 0) return Math.min(i, mRightMargin);
+ return mRightMargin - 1;
+ }
+
+ /** Process byte while in the {@link #ESC_CSI_QUESTIONMARK} escape state. */
+ private void doCsiQuestionMark(int b) {
+ switch (b) {
+ case 'J': // Selective erase in display (DECSED - http://www.vt100.net/docs/vt510-rm/DECSED).
+ case 'K': // Selective erase in line (DECSEL - http://vt100.net/docs/vt510-rm/DECSEL).
+ int fillChar = ' ';
+ int startCol = -1;
+ int startRow = -1;
+ int endCol = -1;
+ int endRow = -1;
+ boolean justRow = (b == 'K');
+ switch (getArg0(0)) {
+ case 0: // Erase from the active position to the end, inclusive (default).
+ startCol = mCursorCol;
+ startRow = mCursorRow;
+ endCol = mColumns;
+ endRow = justRow ? (mCursorRow + 1) : mRows;
+ break;
+ case 1: // Erase from start to the active position, inclusive.
+ startCol = 0;
+ startRow = justRow ? mCursorRow : 0;
+ endCol = mCursorCol + 1;
+ endRow = mCursorRow + 1;
+ break;
+ case 2: // Erase all of the display/line.
+ startCol = 0;
+ startRow = justRow ? mCursorRow : 0;
+ endCol = mColumns;
+ endRow = justRow ? (mCursorRow + 1) : mRows;
+ break;
+ default:
+ unknownSequence(b);
+ break;
+ }
+ int style = getStyle();
+ for (int row = startRow; row < endRow; row++) {
+ for (int col = startCol; col < endCol; col++) {
+ if ((TextStyle.decodeEffect(mScreen.getStyleAt(row, col)) & TextStyle.CHARACTER_ATTRIBUTE_PROTECTED) == 0)
+ mScreen.setChar(col, row, fillChar, style);
+ }
+ }
+ break;
+ case 'h':
+ case 'l':
+ for (int i = 0; i <= mArgIndex; i++)
+ doDecSetOrReset(b == 'h', mArgs[i]);
+ break;
+ case 'n': // Device Status Report (DSR, DEC-specific).
+ switch (getArg0(-1)) {
+ case 6:
+ // Extended Cursor Position (DECXCPR - http://www.vt100.net/docs/vt510-rm/DECXCPR). Page=1.
+ mSession.write(String.format(Locale.US, "\033[?%d;%d;1R", mCursorRow + 1, mCursorCol + 1));
+ break;
+ default:
+ finishSequence();
+ return;
+ }
+ break;
+ case 'r':
+ case 's':
+ for (int i = 0; i <= mArgIndex; i++) {
+ int externalBit = mArgs[i];
+ int internalBit = mapDecSetBitToInternalBit(externalBit);
+ if (internalBit == -1) {
+ Log.w(EmulatorDebug.LOG_TAG, "Ignoring request to save/recall decset bit=" + externalBit);
+ } else {
+ if (b == 's') {
+ mSavedDecSetFlags |= internalBit;
+ } else {
+ doDecSetOrReset((mSavedDecSetFlags & internalBit) != 0, externalBit);
+ }
+ }
+ }
+ break;
+ case '$':
+ continueSequence(ESC_CSI_QUESTIONMARK_ARG_DOLLAR);
+ return;
+ default:
+ parseArg(b);
+ }
+ }
+
+ public void doDecSetOrReset(boolean setting, int externalBit) {
+ int internalBit = mapDecSetBitToInternalBit(externalBit);
+ if (internalBit != -1) {
+ setDecsetinternalBit(internalBit, setting);
+ }
+ switch (externalBit) {
+ case 1: // Application Cursor Keys (DECCKM).
+ break;
+ case 3: // Set: 132 column mode (. Reset: 80 column mode. ANSI name: DECCOLM.
+ // We don't actually set/reset 132 cols, but we do want the side effects
+ // (FIXME: Should only do this if the 95 DECSET bit (DECNCSM) is set, and if changing value?):
+ // Sets the left, right, top and bottom scrolling margins to their default positions, which is important for
+ // the "reset" utility to really reset the terminal:
+ mLeftMargin = mTopMargin = 0;
+ mBottomMargin = mRows;
+ mRightMargin = mColumns;
+ // "DECCOLM resets vertical split screen mode (DECLRMM) to unavailable":
+ setDecsetinternalBit(DECSET_BIT_LEFTRIGHT_MARGIN_MODE, false);
+ // "Erases all data in page memory":
+ blockClear(0, 0, mColumns, mRows);
+ setCursorRowCol(0, 0);
+ break;
+ case 4: // DECSCLM-Scrolling Mode. Ignore.
+ break;
+ case 5: // Reverse video. No action.
+ break;
+ case 6: // Set: Origin Mode. Reset: Normal Cursor Mode. Ansi name: DECOM.
+ if (setting) setCursorPosition(0, 0);
+ break;
+ case 7: // Wrap-around bit, not specific action.
+ case 8: // Auto-repeat Keys (DECARM). Do not implement.
+ case 9: // X10 mouse reporting - outdated. Do not implement.
+ case 12: // Control cursor blinking - ignore.
+ case 25: // Hide/show cursor - no action needed, renderer will check with isShowingCursor().
+ case 40: // Allow 80 => 132 Mode, ignore.
+ case 45: // TODO: Reverse wrap-around. Implement???
+ case 66: // Application keypad (DECNKM).
+ break;
+ case 69: // Left and right margin mode (DECLRMM).
+ if (!setting) {
+ mLeftMargin = 0;
+ mRightMargin = mColumns;
+ }
+ break;
+ case 1000:
+ case 1001:
+ case 1002:
+ case 1003:
+ case 1004:
+ case 1005: // UTF-8 mouse mode, ignore.
+ case 1006: // SGR Mouse Mode
+ case 1015:
+ case 1034: // Interpret "meta" key, sets eighth bit.
+ break;
+ case 1048: // Set: Save cursor as in DECSC. Reset: Restore cursor as in DECRC.
+ if (setting)
+ saveCursor();
+ else
+ restoreCursor();
+ break;
+ case 47:
+ case 1047:
+ case 1049: {
+ // Set: Save cursor as in DECSC and use Alternate Screen Buffer, clearing it first.
+ // Reset: Use Normal Screen Buffer and restore cursor as in DECRC.
+ TerminalBuffer newScreen = setting ? mAltBuffer : mMainBuffer;
+ if (newScreen != mScreen) {
+ boolean resized = !(newScreen.mColumns == mColumns && newScreen.mScreenRows == mRows);
+ if (setting) saveCursor();
+ mScreen = newScreen;
+ if (!setting) {
+ int col = mSavedStateMain.mSavedCursorCol;
+ int row = mSavedStateMain.mSavedCursorRow;
+ restoreCursor();
+ if (resized) {
+ // Restore cursor position _not_ clipped to current screen (let resizeScreen() handle that):
+ mCursorCol = col;
+ mCursorRow = row;
+ }
+ }
+ // Check if buffer size needs to be updated:
+ if (resized) resizeScreen();
+ // Clear new screen if alt buffer:
+ if (newScreen == mAltBuffer) newScreen.blockSet(0, 0, mColumns, mRows, ' ', getStyle());
+ }
+ break;
+ }
+ case 2004:
+ // Bracketed paste mode - setting bit is enough.
+ break;
+ default:
+ unknownParameter(externalBit);
+ break;
+ }
+ }
+
+ private void doCsiBiggerThan(int b) {
+ switch (b) {
+ case 'c': // "${CSI}>c" or "${CSI}>c". Secondary Device Attributes (DA2).
+ // Originally this was used for the terminal to respond with "identification code, firmware version level,
+ // and hardware options" (http://vt100.net/docs/vt510-rm/DA2), with the first "41" meaning the VT420
+ // terminal type. This is not used anymore, but the second version level field has been changed by xterm
+ // to mean it's release number ("patch numbers" listed at http://invisible-island.net/xterm/xterm.log.html),
+ // and some applications use it as a feature check:
+ // * tmux used to have a "xterm won't reach version 500 for a while so set that as the upper limit" check,
+ // and then check "xterm_version > 270" if rectangular area operations such as DECCRA could be used.
+ // * vim checks xterm version number >140 for "Request termcap/terminfo string" functionality >276 for SGR
+ // mouse report.
+ // The third number is a keyboard identifier not used nowadays.
+ mSession.write("\033[>41;320;0c");
+ break;
+ case 'm':
+ // https://bugs.launchpad.net/gnome-terminal/+bug/96676/comments/25
+ // Depending on the first number parameter, this can set one of the xterm resources
+ // modifyKeyboard, modifyCursorKeys, modifyFunctionKeys and modifyOtherKeys.
+ // http://invisible-island.net/xterm/manpage/xterm.html#RESOURCES
+
+ // * modifyKeyboard (parameter=1):
+ // Normally xterm makes a special case regarding modifiers (shift, control, etc.) to handle special keyboard
+ // layouts (legacy and vt220). This is done to provide compatible keyboards for DEC VT220 and related
+ // terminals that implement user-defined keys (UDK).
+ // The bits of the resource value selectively enable modification of the given category when these keyboards
+ // are selected. The default is "0":
+ // (0) The legacy/vt220 keyboards interpret only the Control-modifier when constructing numbered
+ // function-keys. Other special keys are not modified.
+ // (1) allows modification of the numeric keypad
+ // (2) allows modification of the editing keypad
+ // (4) allows modification of function-keys, overrides use of Shift-modifier for UDK.
+ // (8) allows modification of other special keys
+
+ // * modifyCursorKeys (parameter=2):
+ // Tells how to handle the special case where Control-, Shift-, Alt- or Meta-modifiers are used to add a
+ // parameter to the escape sequence returned by a cursor-key. The default is "2".
+ // - Set it to -1 to disable it.
+ // - Set it to 0 to use the old/obsolete behavior.
+ // - Set it to 1 to prefix modified sequences with CSI.
+ // - Set it to 2 to force the modifier to be the second parameter if it would otherwise be the first.
+ // - Set it to 3 to mark the sequence with a ">" to hint that it is private.
+
+ // * modifyFunctionKeys (parameter=3):
+ // Tells how to handle the special case where Control-, Shift-, Alt- or Meta-modifiers are used to add a
+ // parameter to the escape sequence returned by a (numbered) function-
+ // key. The default is "2". The resource values are similar to modifyCursorKeys:
+ // Set it to -1 to permit the user to use shift- and control-modifiers to construct function-key strings
+ // using the normal encoding scheme.
+ // - Set it to 0 to use the old/obsolete behavior.
+ // - Set it to 1 to prefix modified sequences with CSI.
+ // - Set it to 2 to force the modifier to be the second parameter if it would otherwise be the first.
+ // - Set it to 3 to mark the sequence with a ">" to hint that it is private.
+ // If modifyFunctionKeys is zero, xterm uses Control- and Shift-modifiers to allow the user to construct
+ // numbered function-keys beyond the set provided by the keyboard:
+ // (Control) adds the value given by the ctrlFKeys resource.
+ // (Shift) adds twice the value given by the ctrlFKeys resource.
+ // (Control/Shift) adds three times the value given by the ctrlFKeys resource.
+ //
+ // As a special case, legacy (when oldFunctionKeys is true) or vt220 (when sunKeyboard is true)
+ // keyboards interpret only the Control-modifier when constructing numbered function-keys.
+ // This is done to provide compatible keyboards for DEC VT220 and related terminals that
+ // implement user-defined keys (UDK).
+
+ // * modifyOtherKeys (parameter=4):
+ // Like modifyCursorKeys, tells xterm to construct an escape sequence for other keys (such as "2") when
+ // modified by Control-, Alt- or Meta-modifiers. This feature does not apply to function keys and
+ // well-defined keys such as ESC or the control keys. The default is "0".
+ // (0) disables this feature.
+ // (1) enables this feature for keys except for those with well-known behavior, e.g., Tab, Backarrow and
+ // some special control character cases, e.g., Control-Space to make a NUL.
+ // (2) enables this feature for keys including the exceptions listed.
+ Log.e(EmulatorDebug.LOG_TAG, "(ignored) CSI > MODIFY RESOURCE: " + getArg0(-1) + " to " + getArg1(-1));
+ break;
+ default:
+ parseArg(b);
+ break;
+ }
+ }
+
+ private void startEscapeSequence() {
+ mEscapeState = ESC;
+ mArgIndex = 0;
+ Arrays.fill(mArgs, -1);
+ }
+
+ private void doLinefeed() {
+ int newCursorRow = mCursorRow + 1;
+ if (newCursorRow >= mBottomMargin) {
+ scrollDownOneLine();
+ newCursorRow = mBottomMargin - 1;
+ }
+ setCursorRow(newCursorRow);
+ }
+
+ private void continueSequence(int state) {
+ mEscapeState = state;
+ mContinueSequence = true;
+ }
+
+ private void doEscPound(int b) {
+ switch (b) {
+ case '8': // Esc # 8 - DEC screen alignment test - fill screen with E's.
+ mScreen.blockSet(0, 0, mColumns, mRows, 'E', getStyle());
+ break;
+ default:
+ unknownSequence(b);
+ break;
+ }
+ }
+
+ /** Encountering a character in the {@link #ESC} state. */
+ private void doEsc(int b) {
+ switch (b) {
+ case '#':
+ continueSequence(ESC_POUND);
+ break;
+ case '(':
+ continueSequence(ESC_SELECT_LEFT_PAREN);
+ break;
+ case ')':
+ continueSequence(ESC_SELECT_RIGHT_PAREN);
+ break;
+ case '6': // Back index (http://www.vt100.net/docs/vt510-rm/DECBI). Move left, insert blank column if start.
+ if (mCursorCol > mLeftMargin) {
+ mCursorCol--;
+ } else {
+ int rows = mBottomMargin - mTopMargin;
+ mScreen.blockCopy(mLeftMargin, mTopMargin, mRightMargin - mLeftMargin - 1, rows, mLeftMargin + 1, mTopMargin);
+ mScreen.blockSet(mLeftMargin, mTopMargin, 1, rows, ' ', TextStyle.encode(mForeColor, mBackColor, 0));
+ }
+ break;
+ case '7': // DECSC save cursor - http://www.vt100.net/docs/vt510-rm/DECSC
+ saveCursor();
+ break;
+ case '8': // DECRC restore cursor - http://www.vt100.net/docs/vt510-rm/DECRC
+ restoreCursor();
+ break;
+ case '9': // Forward Index (http://www.vt100.net/docs/vt510-rm/DECFI). Move right, insert blank column if end.
+ if (mCursorCol < mRightMargin - 1) {
+ mCursorCol++;
+ } else {
+ int rows = mBottomMargin - mTopMargin;
+ mScreen.blockCopy(mLeftMargin + 1, mTopMargin, mRightMargin - mLeftMargin - 1, rows, mLeftMargin, mTopMargin);
+ mScreen.blockSet(mRightMargin - 1, mTopMargin, 1, rows, ' ', TextStyle.encode(mForeColor, mBackColor, 0));
+ }
+ break;
+ case 'D': // INDEX
+ doLinefeed();
+ break;
+ case 'E': // Next line (http://www.vt100.net/docs/vt510-rm/NEL).
+ setCursorCol(isDecsetInternalBitSet(DECSET_BIT_ORIGIN_MODE) ? mLeftMargin : 0);
+ doLinefeed();
+ break;
+ case 'F': // Cursor to lower-left corner of screen
+ setCursorRowCol(0, mBottomMargin - 1);
+ break;
+ case 'H': // Tab set
+ mTabStop[mCursorCol] = true;
+ break;
+ case 'M': // "${ESC}M" - reverse index (RI).
+ // http://www.vt100.net/docs/vt100-ug/chapter3.html: "Move the active position to the same horizontal
+ // position on the preceding line. If the active position is at the top margin, a scroll down is performed".
+ if (mCursorRow <= mTopMargin) {
+ mScreen.blockCopy(0, mTopMargin, mColumns, mBottomMargin - (mTopMargin + 1), 0, mTopMargin + 1);
+ blockClear(0, mTopMargin, mColumns);
+ } else {
+ mCursorRow--;
+ }
+ break;
+ case 'N': // SS2, ignore.
+ case '0': // SS3, ignore.
+ break;
+ case 'P': // Device control string
+ mOSCOrDeviceControlArgs.setLength(0);
+ continueSequence(ESC_P);
+ break;
+ case '[':
+ continueSequence(ESC_CSI);
+ break;
+ case '=': // DECKPAM
+ setDecsetinternalBit(DECSET_BIT_APPLICATION_KEYPAD, true);
+ break;
+ case ']': // OSC
+ mOSCOrDeviceControlArgs.setLength(0);
+ continueSequence(ESC_OSC);
+ break;
+ case '>': // DECKPNM
+ setDecsetinternalBit(DECSET_BIT_APPLICATION_KEYPAD, false);
+ break;
+ default:
+ unknownSequence(b);
+ break;
+ }
+ }
+
+ /** DECSC save cursor - http://www.vt100.net/docs/vt510-rm/DECSC . See {@link #restoreCursor()}. */
+ private void saveCursor() {
+ SavedScreenState state = (mScreen == mMainBuffer) ? mSavedStateMain : mSavedStateAlt;
+ state.mSavedCursorRow = mCursorRow;
+ state.mSavedCursorCol = mCursorCol;
+ state.mSavedEffect = mEffect;
+ state.mSavedDecFlags = mCurrentDecSetFlags;
+ state.mUseLineDrawingG0 = mUseLineDrawingG0;
+ state.mUseLineDrawingG1 = mUseLineDrawingG1;
+ state.mUseLineDrawingUsesG0 = mUseLineDrawingUsesG0;
+ }
+
+ /** DECRS restore cursor - http://www.vt100.net/docs/vt510-rm/DECRC. See {@link #saveCursor()}. */
+ private void restoreCursor() {
+ SavedScreenState state = (mScreen == mMainBuffer) ? mSavedStateMain : mSavedStateAlt;
+ setCursorRowCol(state.mSavedCursorRow, state.mSavedCursorCol);
+ mEffect = state.mSavedEffect;
+ int mask = (DECSET_BIT_AUTOWRAP | DECSET_BIT_ORIGIN_MODE);
+ mCurrentDecSetFlags = (mCurrentDecSetFlags & ~mask) | (state.mSavedDecFlags & mask);
+ mUseLineDrawingG0 = state.mUseLineDrawingG0;
+ mUseLineDrawingG1 = state.mUseLineDrawingG1;
+ mUseLineDrawingUsesG0 = state.mUseLineDrawingUsesG0;
+ }
+
+ /** Following a CSI - Control Sequence Introducer, "\033[". {@link #ESC_CSI}. */
+ private void doCsi(int b) {
+ switch (b) {
+ case '!':
+ continueSequence(ESC_CSI_EXCLAMATION);
+ break;
+ case '"':
+ continueSequence(ESC_CSI_DOUBLE_QUOTE);
+ break;
+ case '\'':
+ continueSequence(ESC_CSI_SINGLE_QUOTE);
+ break;
+ case '$':
+ continueSequence(ESC_CSI_DOLLAR);
+ break;
+ case '*':
+ continueSequence(ESC_CSI_ARGS_ASTERIX);
+ break;
+ case '@': {
+ // ESC [ Pn @ - ICH Insert Characters.
+ // "This control function inserts one or more space (SP) characters starting at the cursor position."
+ // http://www.vt100.net/docs/vt510-rm/ICH
+ int columnsAfterCursor = mColumns - mCursorCol;
+ int spacesToInsert = Math.min(getArg0(1), columnsAfterCursor);
+ int charsToMove = columnsAfterCursor - spacesToInsert;
+ mScreen.blockCopy(mCursorCol, mCursorRow, charsToMove, 1, mCursorCol + spacesToInsert, mCursorRow);
+ blockClear(mCursorCol, mCursorRow, spacesToInsert);
+ }
+ break;
+ case 'A': // "CSI${n}A" - Cursor up (CUU) ${n} rows.
+ setCursorRow(Math.max(mTopMargin, mCursorRow - getArg0(1)));
+ break;
+ case 'B': // "CSI${n}B" - Cursor down (CUD) ${n} rows.
+ setCursorRow(Math.min(mBottomMargin - 1, mCursorRow + getArg0(1)));
+ break;
+ case 'C': // "CSI${n}C" - Cursor forward (CUF).
+ case 'a': // "CSI${n}a" - Horizontal position relative (HPR). From ISO-6428/ECMA-48.
+ setCursorCol(Math.min(mRightMargin - 1, mCursorCol + getArg0(1)));
+ break;
+ case 'D': // "CSI${n}D" - Cursor backward (CUB) ${n} columns.
+ setCursorCol(Math.max(mLeftMargin, mCursorCol - getArg0(1)));
+ break;
+ case 'E': // "CSI{n}E - Cursor Next Line (CNL). From ISO-6428/ECMA-48.
+ setCursorPosition(0, mCursorRow + getArg0(1));
+ break;
+ case 'F': // "CSI{n}F - Cursor Previous Line (CPL). From ISO-6428/ECMA-48.
+ setCursorPosition(0, mCursorRow - getArg0(1));
+ break;
+ case 'G': // "CSI${n}G" - Cursor horizontal absolute (CHA) to column ${n}.
+ setCursorCol(Math.min(Math.max(1, getArg0(1)), mColumns) - 1);
+ break;
+ case 'H': // "${CSI}${ROW};${COLUMN}H" - Cursor position (CUP).
+ case 'f': // "${CSI}${ROW};${COLUMN}f" - Horizontal and Vertical Position (HVP).
+ setCursorPosition(getArg1(1) - 1, getArg0(1) - 1);
+ break;
+ case 'I': // Cursor Horizontal Forward Tabulation (CHT). Move the active position n tabs forward.
+ setCursorCol(nextTabStop(getArg0(1)));
+ break;
+ case 'J': // ESC [ Pn J - ED - Erase in Display
+ // ED ignores the scrolling margins.
+ switch (getArg0(0)) {
+ case 0: // Erase from the active position to the end of the screen, inclusive (default).
+ blockClear(mCursorCol, mCursorRow, mColumns - mCursorCol);
+ blockClear(0, mCursorRow + 1, mColumns, mRows - (mCursorRow + 1));
+ break;
+ case 1: // Erase from start of the screen to the active position, inclusive.
+ blockClear(0, 0, mColumns, mCursorRow);
+ blockClear(0, mCursorRow, mCursorCol + 1);
+ break;
+ case 2: // Erase all of the display - all lines are erased, changed to single-width, and the cursor does not
+ // move..
+ blockClear(0, 0, mColumns, mRows);
+ break;
+ default:
+ unknownSequence(b);
+ break;
+ }
+ break;
+ case 'K': // "CSI{n}K" - Erase in line (EL).
+ switch (getArg0(0)) {
+ case 0: // Erase from the cursor to the end of the line, inclusive (default)
+ blockClear(mCursorCol, mCursorRow, mColumns - mCursorCol);
+ break;
+ case 1: // Erase from the start of the screen to the cursor, inclusive.
+ blockClear(0, mCursorRow, mCursorCol + 1);
+ break;
+ case 2: // Erase all of the line.
+ blockClear(0, mCursorRow, mColumns);
+ break;
+ default:
+ unknownSequence(b);
+ break;
+ }
+ break;
+ case 'L': // "${CSI}{N}L" - insert ${N} lines (IL).
+ {
+ int linesAfterCursor = mBottomMargin - mCursorRow;
+ int linesToInsert = Math.min(getArg0(1), linesAfterCursor);
+ int linesToMove = linesAfterCursor - linesToInsert;
+ mScreen.blockCopy(0, mCursorRow, mColumns, linesToMove, 0, mCursorRow + linesToInsert);
+ blockClear(0, mCursorRow, mColumns, linesToInsert);
+ }
+ break;
+ case 'M': // "${CSI}${N}M" - delete N lines (DL).
+ {
+ int linesAfterCursor = mBottomMargin - mCursorRow;
+ int linesToDelete = Math.min(getArg0(1), linesAfterCursor);
+ int linesToMove = linesAfterCursor - linesToDelete;
+ mScreen.blockCopy(0, mCursorRow + linesToDelete, mColumns, linesToMove, 0, mCursorRow);
+ blockClear(0, mCursorRow + linesToMove, mColumns, linesToDelete);
+ }
+ break;
+ case 'P': // "${CSI}{N}P" - delete ${N} characters (DCH).
+ {
+ // http://www.vt100.net/docs/vt510-rm/DCH: "If ${N} is greater than the number of characters between the
+ // cursor and the right margin, then DCH only deletes the remaining characters.
+ // As characters are deleted, the remaining characters between the cursor and right margin move to the left.
+ // Character attributes move with the characters. The terminal adds blank spaces with no visual character
+ // attributes at the right margin. DCH has no effect outside the scrolling margins."
+ int cellsAfterCursor = mColumns - mCursorCol;
+ int cellsToDelete = Math.min(getArg0(1), cellsAfterCursor);
+ int cellsToMove = cellsAfterCursor - cellsToDelete;
+ mScreen.blockCopy(mCursorCol + cellsToDelete, mCursorRow, cellsToMove, 1, mCursorCol, mCursorRow);
+ blockClear(mCursorCol + cellsToMove, mCursorRow, cellsToDelete);
+ }
+ break;
+ case 'S': { // "${CSI}${N}S" - scroll up ${N} lines (default = 1) (SU).
+ final int linesToScroll = getArg0(1);
+ for (int i = 0; i < linesToScroll; i++)
+ scrollDownOneLine();
+ break;
+ }
+ case 'T':
+ if (mArgIndex == 0) {
+ // "${CSI}${N}T" - Scroll down N lines (default = 1) (SD).
+ // http://vt100.net/docs/vt510-rm/SD: "N is the number of lines to move the user window up in page
+ // memory. N new lines appear at the top of the display. N old lines disappear at the bottom of the
+ // display. You cannot pan past the top margin of the current page".
+ final int linesToScrollArg = getArg0(1);
+ final int linesBetweenTopAndBottomMargins = mBottomMargin - mTopMargin;
+ final int linesToScroll = Math.min(linesBetweenTopAndBottomMargins, linesToScrollArg);
+ mScreen.blockCopy(0, mTopMargin, mColumns, linesBetweenTopAndBottomMargins - linesToScroll, 0, linesToScroll);
+ blockClear(0, mTopMargin, mColumns, linesToScroll);
+ } else {
+ // "${CSI}${func};${startx};${starty};${firstrow};${lastrow}T" - initiate highlight mouse tracking.
+ unimplementedSequence(b);
+ }
+ break;
+ case 'X': // "${CSI}${N}X" - Erase ${N:=1} character(s) (ECH). FIXME: Clears character attributes?
+ mScreen.blockSet(mCursorCol, mCursorRow, Math.min(getArg0(1), mColumns - mCursorCol), 1, ' ', getStyle());
+ break;
+ case 'Z': // Cursor Backward Tabulation (CBT). Move the active position n tabs backward.
+ int numberOfTabs = getArg0(1);
+ int newCol = mLeftMargin;
+ for (int i = mCursorCol - 1; i >= 0; i--)
+ if (mTabStop[i]) {
+ if (--numberOfTabs == 0) {
+ newCol = Math.max(i, mLeftMargin);
+ break;
+ }
+ }
+ mCursorCol = newCol;
+ break;
+ case '?': // Esc [ ? -- start of a private mode set
+ continueSequence(ESC_CSI_QUESTIONMARK);
+ break;
+ case '>': // "Esc [ >" --
+ continueSequence(ESC_CSI_BIGGERTHAN);
+ break;
+ case '`': // Horizontal position absolute (HPA - http://www.vt100.net/docs/vt510-rm/HPA).
+ setCursorColRespectingOriginMode(getArg0(1) - 1);
+ break;
+ case 'c': // Primary Device Attributes (http://www.vt100.net/docs/vt510-rm/DA1) if argument is missing or zero.
+ // The important part that may still be used by some (tmux stores this value but does not currently use it)
+ // is the first response parameter identifying the terminal service class, where we send 64 for "vt420".
+ // This is followed by a list of attributes which is probably unused by applications. Send like xterm.
+ if (getArg0(0) == 0) mSession.write("\033[?64;1;2;6;9;15;18;21;22c");
+ break;
+ case 'd': // ESC [ Pn d - Vert Position Absolute
+ setCursorRow(Math.min(Math.max(1, getArg0(1)), mRows) - 1);
+ break;
+ case 'e': // Vertical Position Relative (VPR). From ISO-6429 (ECMA-48).
+ setCursorPosition(mCursorCol, mCursorRow + getArg0(1));
+ break;
+ // case 'f': "${CSI}${ROW};${COLUMN}f" - Horizontal and Vertical Position (HVP). Grouped with case 'H'.
+ case 'g': // Clear tab stop
+ switch (getArg0(0)) {
+ case 0:
+ mTabStop[mCursorCol] = false;
+ break;
+ case 3:
+ for (int i = 0; i < mColumns; i++) {
+ mTabStop[i] = false;
+ }
+ break;
+ default:
+ // Specified to have no effect.
+ break;
+ }
+ break;
+ case 'h': // Set Mode
+ doSetMode(true);
+ break;
+ case 'l': // Reset Mode
+ doSetMode(false);
+ break;
+ case 'm': // Esc [ Pn m - character attributes. (can have up to 16 numerical arguments)
+ selectGraphicRendition();
+ break;
+ case 'n': // Esc [ Pn n - ECMA-48 Status Report Commands
+ // sendDeviceAttributes()
+ switch (getArg0(0)) {
+ case 5: // Device status report (DSR):
+ // Answer is ESC [ 0 n (Terminal OK).
+ byte[] dsr = { (byte) 27, (byte) '[', (byte) '0', (byte) 'n' };
+ mSession.write(dsr, 0, dsr.length);
+ break;
+ case 6: // Cursor position report (CPR):
+ // Answer is ESC [ y ; x R, where x,y is
+ // the cursor location.
+ mSession.write(String.format(Locale.US, "\033[%d;%dR", mCursorRow + 1, mCursorCol + 1));
+ break;
+ default:
+ break;
+ }
+ break;
+ case 'r': // "CSI${top};${bottom}r" - set top and bottom Margins (DECSTBM).
+ {
+ // http://www.vt100.net/docs/vt510-rm/DECSTBM
+ // The top margin defaults to 1, the bottom margin defaults to mRows.
+ // The escape sequence numbers top 1..23, but we number top 0..22.
+ // The escape sequence numbers bottom 2..24, and so do we (because we use a zero based numbering
+ // scheme, but we store the first line below the bottom-most scrolling line.
+ // As a result, we adjust the top line by -1, but we leave the bottom line alone.
+ // Also require that top + 2 <= bottom.
+ mTopMargin = Math.max(0, Math.min(getArg0(1) - 1, mRows - 2));
+ mBottomMargin = Math.max(mTopMargin + 2, Math.min(getArg1(mRows), mRows));
+ // DECSTBM moves the cursor to column 1, line 1 of the page respecting origin mode.
+ setCursorPosition(0, 0);
+ }
+ break;
+ case 's':
+ if (isDecsetInternalBitSet(DECSET_BIT_LEFTRIGHT_MARGIN_MODE)) {
+ // Set left and right margins (DECSLRM - http://www.vt100.net/docs/vt510-rm/DECSLRM).
+ mLeftMargin = Math.min(getArg0(1) - 1, mColumns - 2);
+ mRightMargin = Math.max(mLeftMargin + 1, Math.min(getArg1(mColumns), mColumns));
+ // DECSLRM moves the cursor to column 1, line 1 of the page.
+ setCursorPosition(0, 0);
+ } else {
+ // Save cursor (ANSI.SYS), available only when DECLRMM is disabled.
+ saveCursor();
+ }
+ break;
+ case 't': // Window manipulation (from dtterm, as well as extensions)
+ switch (getArg0(0)) {
+ case 11: // Report xterm window state. If the xterm window is open (non-iconified), it returns CSI 1 t .
+ mSession.write("\033[1t");
+ break;
+ case 13: // Report xterm window position. Result is CSI 3 ; x ; y t
+ mSession.write("\033[3;0;0t");
+ break;
+ case 14: // Report xterm window in pixels. Result is CSI 4 ; height ; width t
+ // We just report characters time 12 here.
+ mSession.write(String.format(Locale.US, "\033[4;%d;%dt", mRows * 12, mColumns * 12));
+ break;
+ case 18: // Report the size of the text area in characters. Result is CSI 8 ; height ; width t
+ mSession.write(String.format(Locale.US, "\033[8;%d;%dt", mRows, mColumns));
+ break;
+ case 19: // Report the size of the screen in characters. Result is CSI 9 ; height ; width t
+ // We report the same size as the view, since it's the view really isn't resizable from the shell.
+ mSession.write(String.format(Locale.US, "\033[9;%d;%dt", mRows, mColumns));
+ break;
+ case 20: // Report xterm windows icon label. Result is OSC L label ST. Disabled due to security concerns:
+ mSession.write("\033]LIconLabel\033\\");
+ break;
+ case 21: // Report xterm windows title. Result is OSC l label ST. Disabled due to security concerns:
+ mSession.write("\033]l\033\\");
+ break;
+ case 22:
+ // 22;0 -> Save xterm icon and window title on stack.
+ // 22;1 -> Save xterm icon title on stack.
+ // 22;2 -> Save xterm window title on stack.
+ mTitleStack.push(mTitle);
+ if (mTitleStack.size() > 20) {
+ // Limit size
+ mTitleStack.remove(0);
+ }
+ break;
+ case 23: // Like 22 above but restore from stack.
+ if (!mTitleStack.isEmpty()) setTitle(mTitleStack.pop());
+ break;
+ default:
+ // Ignore window manipulation.
+ break;
+ }
+ break;
+ case 'u': // Restore cursor (ANSI.SYS).
+ restoreCursor();
+ break;
+ case ' ':
+ continueSequence(ESC_CSI_ARGS_SPACE);
+ break;
+ default:
+ parseArg(b);
+ break;
+ }
+ }
+
+ /** Select Graphic Rendition (SGR) - see http://en.wikipedia.org/wiki/ANSI_escape_code#graphics. */
+ private void selectGraphicRendition() {
+ for (int i = 0; i <= mArgIndex; i++) {
+ int code = mArgs[i];
+ if (code < 0) {
+ if (mArgIndex > 0) {
+ continue;
+ } else {
+ code = 0;
+ }
+ }
+ if (code == 0) { // reset
+ mForeColor = TextStyle.COLOR_INDEX_FOREGROUND;
+ mBackColor = TextStyle.COLOR_INDEX_BACKGROUND;
+ mEffect = 0;
+ } else if (code == 1) {
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_BOLD;
+ } else if (code == 2) {
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_DIM;
+ } else if (code == 3) {
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_ITALIC;
+ } else if (code == 4) {
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;
+ } else if (code == 5) {
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_BLINK;
+ } else if (code == 7) {
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_INVERSE;
+ } else if (code == 8) {
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_INVISIBLE;
+ } else if (code == 9) {
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH;
+ } else if (code == 10) {
+ // Exit alt charset (TERM=linux) - ignore.
+ } else if (code == 11) {
+ // Enter alt charset (TERM=linux) - ignore.
+ } else if (code == 22) { // Normal color or intensity, neither bright, bold nor faint.
+ mEffect &= ~(TextStyle.CHARACTER_ATTRIBUTE_BOLD | TextStyle.CHARACTER_ATTRIBUTE_DIM);
+ } else if (code == 23) { // not italic, but rarely used as such; clears standout with TERM=screen
+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_ITALIC;
+ } else if (code == 24) { // underline: none
+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;
+ } else if (code == 25) { // blink: none
+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_BLINK;
+ } else if (code == 27) { // image: positive
+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_INVERSE;
+ } else if (code == 28) {
+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_INVISIBLE;
+ } else if (code == 29) {
+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH;
+ } else if (code >= 30 && code <= 37) {
+ mForeColor = code - 30;
+ } else if (code == 38 || code == 48) {
+ // ISO-8613-3 controls to set foreground (38) or background (48) colors.
+ // P_s = (38|48) ; 2 ; P_r ; P_g ; P_b => Set to RGB value in range (0-255).
+ // P_s = (38|48) ; 5 ; P_s => Set to indexed color.
+ if (i + 2 <= mArgIndex) {
+ int color = -1;
+ int firstArg = mArgs[i + 1];
+ if (firstArg == 2) {
+ if (i + 4 > mArgIndex) {
+ Log.w(EmulatorDebug.LOG_TAG, "Too few CSI" + code + ";2 RGB arguments");
+ } else {
+ int red = mArgs[i + 2], green = mArgs[i + 3], blue = mArgs[i + 4];
+ if (red < 0 || green < 0 || blue < 0 || red > 255 || green > 255 || blue > 255) {
+ finishSequenceAndLogError("Invalid RGB: " + red + "," + green + "," + blue);
+ } else {
+ // TODO: Implement 24 bit color.
+ finishSequenceAndLogError("Unimplemented RGB: " + red + "," + green + "," + blue);
+ }
+ i += 4; // "2;P_r;P_g;P_r"
+ }
+ } else if (firstArg == 5) {
+ color = mArgs[i + 2];
+ i += 2; // "5;P_s"
+ } else {
+ finishSequenceAndLogError("Invalid ISO-8613-3 SGR first argument: " + firstArg);
+ }
+ if (i != -1) {
+ if (color >= 0 && color < TextStyle.NUM_INDEXED_COLORS) {
+ if (code == 38) {
+ mForeColor = color;
+ } else {
+ mBackColor = color;
+ }
+ } else {
+ if (LOG_ESCAPE_SEQUENCES) Log.w(EmulatorDebug.LOG_TAG, "Invalid color index: " + color);
+ }
+ }
+ }
+ } else if (code == 39) { // Set default foreground color.
+ mForeColor = TextStyle.COLOR_INDEX_FOREGROUND;
+ } else if (code >= 40 && code <= 47) { // Set background color.
+ mBackColor = code - 40;
+ } else if (code == 49) { // Set default background color.
+ mBackColor = TextStyle.COLOR_INDEX_BACKGROUND;
+ } else if (code >= 90 && code <= 97) { // Bright foreground colors (aixterm codes).
+ mForeColor = code - 90 + 8;
+ } else if (code >= 100 && code <= 107) { // Bright background color (aixterm codes).
+ mBackColor = code - 100 + 8;
+ } else {
+ if (LOG_ESCAPE_SEQUENCES) Log.w(EmulatorDebug.LOG_TAG, String.format("SGR unknown code %d", code));
+ }
+ }
+ }
+
+ private void doOsc(int b) {
+ switch (b) {
+ case 7: // Bell.
+ doOscSetTextParameters("\007");
+ break;
+ case 27: // Escape.
+ continueSequence(ESC_OSC_ESC);
+ break;
+ default:
+ collectOSCArgs(b);
+ break;
+ }
+ }
+
+ private void doOscEsc(int b) {
+ switch (b) {
+ case '\\':
+ doOscSetTextParameters("\033\\");
+ break;
+ default:
+ // The ESC character was not followed by a \, so insert the ESC and
+ // the current character in arg buffer.
+ collectOSCArgs((byte) 033);
+ collectOSCArgs(b);
+ continueSequence(ESC_OSC);
+ break;
+ }
+ }
+
+ /** An Operating System Controls (OSC) Set Text Parameters. May come here from BEL or ST. */
+ private void doOscSetTextParameters(String bellOrStringTerminator) {
+ int value = -1;
+ String textParameter = "";
+ // Extract initial $value from initial "$value;..." string.
+ for (int mOSCArgTokenizerIndex = 0; mOSCArgTokenizerIndex < mOSCOrDeviceControlArgs.length(); mOSCArgTokenizerIndex++) {
+ char b = mOSCOrDeviceControlArgs.charAt(mOSCArgTokenizerIndex);
+ if (b == ';') {
+ textParameter = mOSCOrDeviceControlArgs.substring(mOSCArgTokenizerIndex + 1);
+ break;
+ } else if (b >= '0' && b <= '9') {
+ value = ((value < 0) ? 0 : value * 10) + (b - '0');
+ } else {
+ unknownSequence(b);
+ return;
+ }
+ }
+
+ switch (value) {
+ case 0: // Change icon name and window title to T.
+ case 1: // Change icon name to T.
+ case 2: // Change window title to T.
+ setTitle(textParameter);
+ break;
+ case 4:
+ // P s = 4 ; c ; spec → Change Color Number c to the color specified by spec. This can be a name or RGB
+ // specification as per XParseColor. Any number of c name pairs may be given. The color numbers correspond
+ // to the ANSI colors 0-7, their bright versions 8-15, and if supported, the remainder of the 88-color or
+ // 256-color table.
+ // If a "?" is given rather than a name or RGB specification, xterm replies with a control sequence of the
+ // same form which can be used to set the corresponding color. Because more than one pair of color number
+ // and specification can be given in one control sequence, xterm can make more than one reply.
+ int colorIndex = -1;
+ int parsingPairStart = -1;
+ for (int i = 0;; i++) {
+ boolean endOfInput = i == textParameter.length();
+ char b = endOfInput ? ';' : textParameter.charAt(i);
+ if (b == ';') {
+ if (parsingPairStart < 0) {
+ parsingPairStart = i + 1;
+ } else {
+ if (colorIndex < 0 || colorIndex > 255) {
+ unknownSequence(b);
+ return;
+ } else {
+ mColors.tryParseColor(colorIndex, textParameter.substring(parsingPairStart, i));
+ colorIndex = -1;
+ parsingPairStart = -1;
+ }
+ }
+ } else if (parsingPairStart >= 0) {
+ // We have passed a color index and are now going through color spec.
+ } else if (parsingPairStart < 0 && (b >= '0' && b <= '9')) {
+ colorIndex = ((colorIndex < 0) ? 0 : colorIndex * 10) + (b - '0');
+ } else {
+ unknownSequence(b);
+ return;
+ }
+ if (endOfInput) break;
+ }
+ break;
+ case 10: // Set foreground color.
+ case 11: // Set background color.
+ case 12: // Set cursor color.
+ int specialIndex = TextStyle.COLOR_INDEX_FOREGROUND + (value - 10);
+ int lastSemiIndex = 0;
+ for (int charIndex = 0;; charIndex++) {
+ boolean endOfInput = charIndex == textParameter.length();
+ if (endOfInput || textParameter.charAt(charIndex) == ';') {
+ try {
+ String colorSpec = textParameter.substring(lastSemiIndex, charIndex);
+ if ("?".equals(colorSpec)) {
+ // Report current color in the same format xterm and gnome-terminal does.
+ int rgb = mColors.mCurrentColors[specialIndex];
+ int r = (65535 * ((rgb & 0x00FF0000) >> 16)) / 255;
+ int g = (65535 * ((rgb & 0x0000FF00) >> 8)) / 255;
+ int b = (65535 * ((rgb & 0x000000FF))) / 255;
+ mSession.write("\033]" + value + ";rgb:" + String.format(Locale.US, "%04x", r) + "/" + String.format(Locale.US, "%04x", g) + "/"
+ + String.format(Locale.US, "%04x", b) + bellOrStringTerminator);
+ } else {
+ mColors.tryParseColor(specialIndex, colorSpec);
+ }
+ specialIndex++;
+ if (endOfInput || (specialIndex > TextStyle.COLOR_INDEX_CURSOR) || ++charIndex >= textParameter.length()) break;
+ lastSemiIndex = charIndex;
+ } catch (NumberFormatException e) {
+ // Ignore.
+ }
+ }
+ }
+ break;
+ case 52: // Manipulate Selection Data. Skip the optional first selection parameter(s).
+ int startIndex = textParameter.indexOf(";") + 1;
+ try {
+ String clipboardText = new String(Base64.decode(textParameter.substring(startIndex), 0), StandardCharsets.UTF_8);
+ mSession.clipboardText(clipboardText);
+ } catch (Exception e) {
+ Log.e(EmulatorDebug.LOG_TAG, "OSC Manipulate selection, invalid string '" + textParameter + "");
+ }
+ break;
+ case 104:
+ // "104;$c" → Reset Color Number $c. It is reset to the color specified by the corresponding X
+ // resource. Any number of c parameters may be given. These parameters correspond to the ANSI colors 0-7,
+ // their bright versions 8-15, and if supported, the remainder of the 88-color or 256-color table. If no
+ // parameters are given, the entire table will be reset.
+ if (textParameter.isEmpty()) {
+ mColors.reset();
+ } else {
+ int lastIndex = 0;
+ for (int charIndex = 0;; charIndex++) {
+ boolean endOfInput = charIndex == textParameter.length();
+ if (endOfInput || textParameter.charAt(charIndex) == ';') {
+ try {
+ int colorToReset = Integer.parseInt(textParameter.substring(lastIndex, charIndex));
+ mColors.reset(colorToReset);
+ if (endOfInput) break;
+ charIndex++;
+ lastIndex = charIndex;
+ } catch (NumberFormatException e) {
+ // Ignore.
+ }
+ }
+ }
+ }
+ break;
+ case 110: // Reset foreground color.
+ case 111: // Reset background color.
+ case 112: // Reset cursor color.
+ mColors.reset(TextStyle.COLOR_INDEX_FOREGROUND + (value - 110));
+ break;
+ case 119: // Reset highlight color.
+ break;
+ default:
+ unknownParameter(value);
+ break;
+ }
+ finishSequence();
+ }
+
+ private void blockClear(int sx, int sy, int w) {
+ blockClear(sx, sy, w, 1);
+ }
+
+ private void blockClear(int sx, int sy, int w, int h) {
+ mScreen.blockSet(sx, sy, w, h, ' ', getStyle());
+ }
+
+ private int getStyle() {
+ return TextStyle.encode(mForeColor, mBackColor, mEffect);
+ }
+
+ /** "CSI P_m h" for set or "CSI P_m l" for reset ANSI mode. */
+ private void doSetMode(boolean newValue) {
+ int modeBit = getArg0(0);
+ switch (modeBit) {
+ case 4: // Set="Insert Mode". Reset="Replace Mode". (IRM).
+ mInsertMode = newValue;
+ break;
+ case 20: // Normal Linefeed (LNM).
+ unknownParameter(modeBit);
+ // http://www.vt100.net/docs/vt510-rm/LNM
+ break;
+ case 34:
+ // Normal cursor visibility - when using TERM=screen, see
+ // http://www.gnu.org/software/screen/manual/html_node/Control-Sequences.html
+ break;
+ default:
+ unknownParameter(modeBit);
+ break;
+ }
+ }
+
+ /**
+ * NOTE: The parameters of this function respect the {@link #DECSET_BIT_ORIGIN_MODE}. Use
+ * {@link #setCursorRowCol(int, int)} for absolute pos.
+ */
+ private void setCursorPosition(int x, int y) {
+ boolean originMode = isDecsetInternalBitSet(DECSET_BIT_ORIGIN_MODE);
+ int effectiveTopMargin = originMode ? mTopMargin : 0;
+ int effectiveBottomMargin = originMode ? mBottomMargin : mRows;
+ int effectiveLeftMargin = originMode ? mLeftMargin : 0;
+ int effectiveRightMargin = originMode ? mRightMargin : mColumns;
+ int newRow = Math.max(effectiveTopMargin, Math.min(effectiveTopMargin + y, effectiveBottomMargin - 1));
+ int newCol = Math.max(effectiveLeftMargin, Math.min(effectiveLeftMargin + x, effectiveRightMargin - 1));
+ setCursorRowCol(newRow, newCol);
+ }
+
+ private void scrollDownOneLine() {
+ mScrollCounter++;
+ if (mLeftMargin != 0 || mRightMargin != mColumns) {
+ // Horizontal margin: Do not put anything into scroll history, just non-margin part of screen up.
+ mScreen.blockCopy(mLeftMargin, mTopMargin + 1, mRightMargin - mLeftMargin, mBottomMargin - mTopMargin - 1, mLeftMargin, mTopMargin);
+ // .. and blank bottom row between margins:
+ mScreen.blockSet(mLeftMargin, mBottomMargin - 1, mRightMargin - mLeftMargin, 1, ' ', mEffect);
+ } else {
+ mScreen.scrollDownOneLine(mTopMargin, mBottomMargin, getStyle());
+ }
+ }
+
+ /** Process the next ASCII character of a parameter. */
+ private void parseArg(int b) {
+ if (b >= '0' && b <= '9') {
+ if (mArgIndex < mArgs.length) {
+ int oldValue = mArgs[mArgIndex];
+ int thisDigit = b - '0';
+ int value;
+ if (oldValue >= 0) {
+ value = oldValue * 10 + thisDigit;
+ } else {
+ value = thisDigit;
+ }
+ mArgs[mArgIndex] = value;
+ }
+ continueSequence(mEscapeState);
+ } else if (b == ';') {
+ if (mArgIndex < mArgs.length) {
+ mArgIndex++;
+ }
+ continueSequence(mEscapeState);
+ } else {
+ unknownSequence(b);
+ }
+ }
+
+ private int getArg0(int defaultValue) {
+ return getArg(0, defaultValue, true);
+ }
+
+ private int getArg1(int defaultValue) {
+ return getArg(1, defaultValue, true);
+ }
+
+ private int getArg(int index, int defaultValue, boolean treatZeroAsDefault) {
+ int result = mArgs[index];
+ if (result < 0 || (result == 0 && treatZeroAsDefault)) {
+ result = defaultValue;
+ }
+ return result;
+ }
+
+ private void collectOSCArgs(int b) {
+ if (mOSCOrDeviceControlArgs.length() < MAX_OSC_STRING_LENGTH) {
+ mOSCOrDeviceControlArgs.appendCodePoint(b);
+ continueSequence(mEscapeState);
+ } else {
+ unknownSequence(b);
+ }
+ }
+
+ private void unimplementedSequence(int b) {
+ logError("Unimplemented sequence char '" + (char) b + "' (U+" + String.format("%04x", b) + ")");
+ finishSequence();
+ }
+
+ private void unknownSequence(int b) {
+ logError("Unknown sequence char '" + (char) b + "' (numeric value=" + b + ")");
+ finishSequence();
+ }
+
+ private void unknownParameter(int parameter) {
+ logError("Unknown parameter: " + parameter);
+ finishSequence();
+ }
+
+ private void logError(String errorType) {
+ if (LOG_ESCAPE_SEQUENCES) {
+ StringBuilder buf = new StringBuilder();
+ buf.append(errorType);
+ buf.append(", escapeState=");
+ buf.append(mEscapeState);
+ boolean firstArg = true;
+ for (int i = 0; i <= mArgIndex; i++) {
+ int value = mArgs[i];
+ if (value >= 0) {
+ if (firstArg) {
+ firstArg = false;
+ buf.append(", args={");
+ } else {
+ buf.append(',');
+ }
+ buf.append(value);
+ }
+ }
+ if (!firstArg) buf.append('}');
+ finishSequenceAndLogError(buf.toString());
+ }
+ }
+
+ private void finishSequenceAndLogError(String error) {
+ if (LOG_ESCAPE_SEQUENCES) Log.w(EmulatorDebug.LOG_TAG, error);
+ finishSequence();
+ }
+
+ private void finishSequence() {
+ mEscapeState = ESC_NONE;
+ }
+
+ /**
+ * Send a Unicode code point to the screen.
+ *
+ * @param codePoint
+ * The code point of the character to display
+ */
+ private void emitCodePoint(int codePoint) {
+ if (mUseLineDrawingUsesG0 ? mUseLineDrawingG0 : mUseLineDrawingG1) {
+ // http://www.vt100.net/docs/vt102-ug/table5-15.html.
+ switch (codePoint) {
+ case '_':
+ codePoint = ' '; // Blank.
+ break;
+ case '`':
+ codePoint = '◆'; // Diamond.
+ break;
+ case '0':
+ codePoint = '█'; // Solid block;
+ break;
+ case 'a':
+ codePoint = '▒'; // Checker board.
+ break;
+ case 'b':
+ codePoint = '␉'; // Horizontal tab.
+ break;
+ case 'c':
+ codePoint = '␌'; // Form feed.
+ break;
+ case 'd':
+ codePoint = '\r'; // Carriage return.
+ break;
+ case 'e':
+ codePoint = '␊'; // Linefeed.
+ break;
+ case 'f':
+ codePoint = '°'; // Degree.
+ break;
+ case 'g':
+ codePoint = '±'; // Plus-minus.
+ break;
+ case 'h':
+ codePoint = '\n'; // Newline.
+ break;
+ case 'i':
+ codePoint = '␋'; // Vertical tab.
+ break;
+ case 'j':
+ codePoint = '┘'; // Lower right corner.
+ break;
+ case 'k':
+ codePoint = '┐'; // Upper right corner.
+ break;
+ case 'l':
+ codePoint = '┌'; // Upper left corner.
+ break;
+ case 'm':
+ codePoint = '└'; // Left left corner.
+ break;
+ case 'n':
+ codePoint = '┼'; // Crossing lines.
+ break;
+ case 'o':
+ codePoint = '⎺'; // Horizontal line - scan 1.
+ break;
+ case 'p':
+ codePoint = '⎻'; // Horizontal line - scan 3.
+ break;
+ case 'q':
+ codePoint = '─'; // Horizontal line - scan 5.
+ break;
+ case 'r':
+ codePoint = '⎼'; // Horizontal line - scan 7.
+ break;
+ case 's':
+ codePoint = '⎽'; // Horizontal line - scan 9.
+ break;
+ case 't':
+ codePoint = '├'; // T facing rightwards.
+ break;
+ case 'u':
+ codePoint = '┤'; // T facing leftwards.
+ break;
+ case 'v':
+ codePoint = '┴'; // T facing upwards.
+ break;
+ case 'w':
+ codePoint = '┬'; // T facing downwards.
+ break;
+ case 'x':
+ codePoint = '│'; // Vertical line.
+ break;
+ case 'y':
+ codePoint = '≤'; // Less than or equal to.
+ break;
+ case 'z':
+ codePoint = '≥'; // Greater than or equal to.
+ break;
+ case '{':
+ codePoint = 'π'; // Pi.
+ break;
+ case '|':
+ codePoint = '≠'; // Not equal to.
+ break;
+ case '}':
+ codePoint = '£'; // UK pound.
+ break;
+ case '~':
+ codePoint = '·'; // Centered dot.
+ break;
+ }
+ }
+
+ final boolean autoWrap = isDecsetInternalBitSet(DECSET_BIT_AUTOWRAP);
+ final int displayWidth = WcWidth.width(codePoint);
+
+ if (autoWrap && (mCursorCol == mRightMargin - 1 && ((mAboutToAutoWrap && displayWidth == 1) || displayWidth == 2))) {
+ mScreen.setLineWrap(mCursorRow);
+ mCursorCol = mLeftMargin;
+ if (mCursorRow + 1 < mBottomMargin) {
+ mCursorRow++;
+ } else {
+ scrollDownOneLine();
+ }
+ }
+
+ if (mInsertMode && displayWidth > 0) {
+ // Move character to right one space.
+ int destCol = mCursorCol + displayWidth;
+ if (destCol < mRightMargin) mScreen.blockCopy(mCursorCol, mCursorRow, mRightMargin - destCol, 1, destCol, mCursorRow);
+ }
+
+ int offsetDueToCombiningChar = ((displayWidth <= 0 && mCursorCol > 0 && !mAboutToAutoWrap) ? 1 : 0);
+ mScreen.setChar(mCursorCol - offsetDueToCombiningChar, mCursorRow, codePoint, getStyle());
+
+ if (autoWrap && displayWidth > 0) mAboutToAutoWrap = (mCursorCol == mRightMargin - displayWidth);
+
+ mCursorCol = Math.min(mCursorCol + displayWidth, mRightMargin - 1);
+ }
+
+ private void setCursorRow(int row) {
+ mCursorRow = row;
+ mAboutToAutoWrap = false;
+ }
+
+ private void setCursorCol(int col) {
+ mCursorCol = col;
+ mAboutToAutoWrap = false;
+ }
+
+ /** Set the cursor mode, but limit it to margins if {@link #DECSET_BIT_ORIGIN_MODE} is enabled. */
+ private void setCursorColRespectingOriginMode(int col) {
+ setCursorPosition(col, mCursorRow);
+ }
+
+ /** TODO: Better name, distinguished from {@link #setCursorPosition(int, int)} by not regarding origin mode. */
+ private void setCursorRowCol(int row, int col) {
+ mCursorRow = Math.max(0, Math.min(row, mRows - 1));
+ mCursorCol = Math.max(0, Math.min(col, mColumns - 1));
+ mAboutToAutoWrap = false;
+ }
+
+ public int getScrollCounter() {
+ return mScrollCounter;
+ }
+
+ public void clearScrollCounter() {
+ mScrollCounter = 0;
+ }
+
+ /** Reset terminal state so user can interact with it regardless of present state. */
+ public void reset() {
+ mCursorStyle = CURSOR_STYLE_BLOCK;
+ mArgIndex = 0;
+ mContinueSequence = false;
+ mEscapeState = ESC_NONE;
+ mInsertMode = false;
+ mTopMargin = mLeftMargin = 0;
+ mBottomMargin = mRows;
+ mRightMargin = mColumns;
+ mAboutToAutoWrap = false;
+ mForeColor = TextStyle.COLOR_INDEX_FOREGROUND;
+ mBackColor = TextStyle.COLOR_INDEX_BACKGROUND;
+ setDefaultTabStops();
+
+ mUseLineDrawingG0 = mUseLineDrawingG1 = false;
+ mUseLineDrawingUsesG0 = true;
+
+ mSavedStateMain.mSavedCursorRow = mSavedStateMain.mSavedCursorCol = mSavedStateMain.mSavedEffect = mSavedStateMain.mSavedDecFlags = 0;
+ mSavedStateAlt.mSavedCursorRow = mSavedStateAlt.mSavedCursorCol = mSavedStateAlt.mSavedEffect = mSavedStateAlt.mSavedDecFlags = 0;
+ mCurrentDecSetFlags = 0;
+ // Initial wrap-around is not accurate but makes terminal more useful, especially on a small screen:
+ setDecsetinternalBit(DECSET_BIT_AUTOWRAP, true);
+ setDecsetinternalBit(DECSET_BIT_SHOWING_CURSOR, true);
+ mSavedDecSetFlags = mSavedStateMain.mSavedDecFlags = mSavedStateAlt.mSavedDecFlags = mCurrentDecSetFlags;
+
+ // XXX: Should we set terminal driver back to IUTF8 with termios?
+ mUtf8Index = mUtf8ToFollow = 0;
+
+ mColors.reset();
+ }
+
+ public String getSelectedText(int x1, int y1, int x2, int y2) {
+ return mScreen.getSelectedText(x1, y1, x2, y2);
+ }
+
+ /** Get the terminal session's title (null if not set). */
+ public String getTitle() {
+ return mTitle;
+ }
+
+ /** Change the terminal session's title. */
+ private void setTitle(String newTitle) {
+ String oldTitle = mTitle;
+ mTitle = newTitle;
+ if (!Objects.equals(oldTitle, newTitle)) {
+ mSession.titleChanged(oldTitle, newTitle);
+ }
+ }
+
+ /** If DECSET 2004 is set, prefix paste with "\033[200~" and suffix with "\033[201~". */
+ public void paste(String text) {
+ // First: Always remove escape key and C1 control characters [0x80,0x9F]:
+ text = text.replaceAll("(\u001B|[\u0080-\u009F])", "");
+ // Then: Implement bracketed paste mode if enabled:
+ boolean bracketed = isDecsetInternalBitSet(DECSET_BIT_BRACKETED_PASTE_MODE);
+ if (bracketed) mSession.write("\033[200~");
+ mSession.write(text);
+ if (bracketed) mSession.write("\033[201~");
+ }
+
+ /** http://www.vt100.net/docs/vt510-rm/DECSC */
+ static final class SavedScreenState {
+ /** Saved state of the cursor position, Used to implement the save/restore cursor position escape sequences. */
+ int mSavedCursorRow, mSavedCursorCol;
+ int mSavedEffect;
+ int mSavedDecFlags;
+ boolean mUseLineDrawingG0, mUseLineDrawingG1, mUseLineDrawingUsesG0 = true;
+ }
+
+ @Override
+ public String toString() {
+ return "TerminalEmulator[size=" + mScreen.mColumns + "x" + mScreen.mScreenRows + ", margins={" + mTopMargin + "," + mRightMargin + "," + mBottomMargin
+ + "," + mLeftMargin + "}]";
+ }
+
+}
diff --git a/app/src/main/java/com/termux/terminal/TerminalOutput.java b/app/src/main/java/com/termux/terminal/TerminalOutput.java
new file mode 100644
index 0000000000..e2c4c1a840
--- /dev/null
+++ b/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();
+
+}
diff --git a/app/src/main/java/com/termux/terminal/TerminalRow.java b/app/src/main/java/com/termux/terminal/TerminalRow.java
new file mode 100644
index 0000000000..0730938be8
--- /dev/null
+++ b/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];
+ }
+
+}
diff --git a/app/src/main/java/com/termux/terminal/TerminalSession.java b/app/src/main/java/com/termux/terminal/TerminalSession.java
new file mode 100644
index 0000000000..e7b6e08a54
--- /dev/null
+++ b/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.
+ *
+ * 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.
+ *
+ * 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
+ * InputStream and OutputStream.
+ */
+ 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);
+ }
+
+}
diff --git a/app/src/main/java/com/termux/terminal/TextStyle.java b/app/src/main/java/com/termux/terminal/TextStyle.java
new file mode 100644
index 0000000000..6b99b5a2a2
--- /dev/null
+++ b/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;
+ }
+
+}
diff --git a/app/src/main/java/com/termux/terminal/WcWidth.java b/app/src/main/java/com/termux/terminal/WcWidth.java
new file mode 100644
index 0000000000..0e5f391ad7
--- /dev/null
+++ b/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);
+ }
+
+}
diff --git a/app/src/main/java/com/termux/view/GestureAndScaleRecognizer.java b/app/src/main/java/com/termux/view/GestureAndScaleRecognizer.java
new file mode 100644
index 0000000000..861adbd418
--- /dev/null
+++ b/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();
+ }
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/termux/view/TerminalKeyListener.java b/app/src/main/java/com/termux/view/TerminalKeyListener.java
new file mode 100644
index 0000000000..184d1d8e0c
--- /dev/null
+++ b/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);
+
+}
diff --git a/app/src/main/java/com/termux/view/TerminalRenderer.java b/app/src/main/java/com/termux/view/TerminalRenderer.java
new file mode 100644
index 0000000000..022d7e7399
--- /dev/null
+++ b/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();
+ }
+}
diff --git a/app/src/main/java/com/termux/view/TerminalView.java b/app/src/main/java/com/termux/view/TerminalView.java
new file mode 100644
index 0000000000..ba3341044d
--- /dev/null
+++ b/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;
+ }
+
+}
diff --git a/app/src/main/jni/Android.mk b/app/src/main/jni/Android.mk
new file mode 100644
index 0000000000..6c6f8b2299
--- /dev/null
+++ b/app/src/main/jni/Android.mk
@@ -0,0 +1,5 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+LOCAL_MODULE:= libtermux
+LOCAL_SRC_FILES:= termux.c
+include $(BUILD_SHARED_LIBRARY)
diff --git a/app/src/main/jni/Application.mk b/app/src/main/jni/Application.mk
new file mode 100644
index 0000000000..a61ec782d4
--- /dev/null
+++ b/app/src/main/jni/Application.mk
@@ -0,0 +1,5 @@
+APP_ABI := armeabi-v7a x86
+APP_PLATFORM := android-21
+NDK_TOOLCHAIN_VERSION := 4.9
+APP_CFLAGS := -std=c11 -Wall -Wextra -Os -fno-stack-protector
+APP_LDFLAGS = -nostdlib -Wl,--gc-sections
diff --git a/app/src/main/jni/termux.c b/app/src/main/jni/termux.c
new file mode 100644
index 0000000000..ff3a31e06f
--- /dev/null
+++ b/app/src/main/jni/termux.c
@@ -0,0 +1,203 @@
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#define TERMUX_UNUSED(x) x __attribute__((__unused__))
+#ifdef __APPLE__
+# define LACKS_PTSNAME_R
+#endif
+
+static int throw_runtime_exception(JNIEnv* env, char const* message)
+{
+ jclass exClass = (*env)->FindClass(env, "java/lang/RuntimeException");
+ (*env)->ThrowNew(env, exClass, message);
+ return -1;
+}
+
+static int create_subprocess(JNIEnv* env, char const* cmd, char const* cwd, char* const argv[], char** envp, int* pProcessId)
+{
+ int ptm = open("/dev/ptmx", O_RDWR | O_CLOEXEC);
+ if (ptm < 0) return throw_runtime_exception(env, "Cannot open /dev/ptmx");
+
+#ifdef LACKS_PTSNAME_R
+ char* devname;
+#else
+ char devname[64];
+#endif
+ if (grantpt(ptm) || unlockpt(ptm) ||
+#ifdef LACKS_PTSNAME_R
+ (devname = ptsname(ptm)) == NULL
+#else
+ ptsname_r(ptm, devname, sizeof(devname))
+#endif
+ ) {
+ return throw_runtime_exception(env, "Cannot grantpt()/unlockpt()/ptsname_r() on /dev/ptmx");
+ }
+
+ // Enable UTF-8 mode and disable flow control to prevent Ctrl+S from locking up the display.
+ struct termios tios;
+ tcgetattr(ptm, &tios);
+ tios.c_iflag |= IUTF8;
+ tios.c_iflag &= ~(IXON | IXOFF);
+ tcsetattr(ptm, TCSANOW, &tios);
+
+ /** Set initial winsize (better too small than too large). */
+ struct winsize sz = { .ws_row = 20, .ws_col = 20 };
+ ioctl(ptm, TIOCSWINSZ, &sz);
+
+ pid_t pid = fork();
+ if (pid < 0) {
+ return throw_runtime_exception(env, "Fork failed");
+ } else if (pid > 0) {
+ *pProcessId = (int) pid;
+ return ptm;
+ } else {
+ // Clear signals which the Android java process may have blocked:
+ sigset_t signals_to_unblock;
+ sigfillset(&signals_to_unblock);
+ sigprocmask(SIG_UNBLOCK, &signals_to_unblock, 0);
+
+ close(ptm);
+ setsid();
+
+ int pts = open(devname, O_RDWR);
+ if (pts < 0) exit(-1);
+
+ dup2(pts, 0);
+ dup2(pts, 1);
+ dup2(pts, 2);
+
+ DIR* self_dir = opendir("/proc/self/fd");
+ if (self_dir != NULL) {
+ int self_dir_fd = dirfd(self_dir);
+ struct dirent* entry;
+ while ((entry = readdir(self_dir)) != NULL) {
+ int fd = atoi(entry->d_name);
+ if(fd > 2 && fd != self_dir_fd) close(fd);
+ }
+ closedir(self_dir);
+ }
+
+ clearenv();
+ if (envp) for (; *envp; ++envp) putenv(*envp);
+
+ if (chdir(cwd) != 0) {
+ char* error_message;
+ // No need to free asprintf()-allocated memory since doing execvp() or exit() below.
+ if (asprintf(&error_message, "chdir(\"%s\")", cwd) == -1) error_message = "chdir()";
+ perror(error_message);
+ fflush(stderr);
+ }
+ execvp(cmd, argv);
+ // Show terminal output about failing exec() call:
+ char* error_message;
+ if (asprintf(&error_message, "exec(\"%s\")", cmd) == -1) error_message = "exec()";
+ perror(error_message);
+ _exit(1);
+ }
+}
+
+JNIEXPORT jint JNICALL Java_com_termux_terminal_JNI_createSubprocess(JNIEnv* env, jclass TERMUX_UNUSED(clazz), jstring cmd, jstring cwd, jobjectArray args, jobjectArray envVars, jintArray processIdArray)
+{
+ jsize size = args ? (*env)->GetArrayLength(env, args) : 0;
+ char** argv = NULL;
+ if (size > 0) {
+ argv = (char**) malloc((size + 1) * sizeof(char*));
+ if (!argv) return throw_runtime_exception(env, "Couldn't allocate argv array");
+ for (int i = 0; i < size; ++i) {
+ jstring arg_java_string = (jstring) (*env)->GetObjectArrayElement(env, args, i);
+ char const* arg_utf8 = (*env)->GetStringUTFChars(env, arg_java_string, NULL);
+ if (!arg_utf8) return throw_runtime_exception(env, "GetStringUTFChars() failed for argv");
+ argv[i] = strdup(arg_utf8);
+ (*env)->ReleaseStringUTFChars(env, arg_java_string, arg_utf8);
+ }
+ argv[size] = NULL;
+ }
+
+ size = envVars ? (*env)->GetArrayLength(env, envVars) : 0;
+ char** envp = NULL;
+ if (size > 0) {
+ envp = (char**) malloc((size + 1) * sizeof(char *));
+ if (!envp) return throw_runtime_exception(env, "malloc() for envp array failed");
+ for (int i = 0; i < size; ++i) {
+ jstring env_java_string = (jstring) (*env)->GetObjectArrayElement(env, envVars, i);
+ char const* env_utf8 = (*env)->GetStringUTFChars(env, env_java_string, 0);
+ if (!env_utf8) return throw_runtime_exception(env, "GetStringUTFChars() failed for env");
+ envp[i] = strdup(env_utf8);
+ (*env)->ReleaseStringUTFChars(env, env_java_string, env_utf8);
+ }
+ envp[size] = NULL;
+ }
+
+ int procId = 0;
+ char const* cmd_cwd = (*env)->GetStringUTFChars(env, cwd, NULL);
+ char const* cmd_utf8 = (*env)->GetStringUTFChars(env, cmd, NULL);
+ int ptm = create_subprocess(env, cmd_utf8, cmd_cwd, argv, envp, &procId);
+ (*env)->ReleaseStringUTFChars(env, cmd, cmd_utf8);
+ (*env)->ReleaseStringUTFChars(env, cmd, cmd_cwd);
+
+ if (argv) {
+ for (char** tmp = argv; *tmp; ++tmp) free(*tmp);
+ free(argv);
+ }
+ if (envp) {
+ for (char** tmp = envp; *tmp; ++tmp) free(*tmp);
+ free(envp);
+ }
+
+ int* pProcId = (int*) (*env)->GetPrimitiveArrayCritical(env, processIdArray, NULL);
+ if (!pProcId) return throw_runtime_exception(env, "JNI call GetPrimitiveArrayCritical(processIdArray, &isCopy) failed");
+
+ *pProcId = procId;
+ (*env)->ReleasePrimitiveArrayCritical(env, processIdArray, pProcId, 0);
+
+ return ptm;
+}
+
+JNIEXPORT void JNICALL Java_com_termux_terminal_JNI_setPtyWindowSize(JNIEnv* TERMUX_UNUSED(env), jclass TERMUX_UNUSED(clazz), jint fd, jint rows, jint cols)
+{
+ struct winsize sz = { .ws_row = rows, .ws_col = cols };
+ ioctl(fd, TIOCSWINSZ, &sz);
+}
+
+JNIEXPORT void JNICALL Java_com_termux_terminal_JNI_setPtyUTF8Mode(JNIEnv* TERMUX_UNUSED(env), jclass TERMUX_UNUSED(clazz), jint fd)
+{
+ struct termios tios;
+ tcgetattr(fd, &tios);
+ if ((tios.c_iflag & IUTF8) == 0) {
+ tios.c_iflag |= IUTF8;
+ tcsetattr(fd, TCSANOW, &tios);
+ }
+}
+
+JNIEXPORT int JNICALL Java_com_termux_terminal_JNI_waitFor(JNIEnv* TERMUX_UNUSED(env), jclass TERMUX_UNUSED(clazz), jint pid)
+{
+ int status;
+ waitpid(pid, &status, 0);
+ if (WIFEXITED(status)) {
+ return WEXITSTATUS(status);
+ } else if (WIFSIGNALED(status)) {
+ return -WTERMSIG(status);
+ } else {
+ // Should never happen - waitpid(2) says "One of the first three macros will evaluate to a non-zero (true) value".
+ return 0;
+ }
+}
+
+JNIEXPORT void JNICALL Java_com_termux_terminal_JNI_hangupProcessGroup(JNIEnv* TERMUX_UNUSED(env), jclass TERMUX_UNUSED(clazz), jint procId)
+{
+ killpg(procId, SIGHUP);
+}
+
+JNIEXPORT void JNICALL Java_com_termux_terminal_JNI_close(JNIEnv* TERMUX_UNUSED(env), jclass TERMUX_UNUSED(clazz), jint fileDescriptor)
+{
+ close(fileDescriptor);
+}
diff --git a/app/src/main/jniLibs/armeabi-v7a/libtermux.so b/app/src/main/jniLibs/armeabi-v7a/libtermux.so
new file mode 100755
index 0000000000..3e66676607
Binary files /dev/null and b/app/src/main/jniLibs/armeabi-v7a/libtermux.so differ
diff --git a/app/src/main/jniLibs/x86/libtermux.so b/app/src/main/jniLibs/x86/libtermux.so
new file mode 100755
index 0000000000..aef93ad090
Binary files /dev/null and b/app/src/main/jniLibs/x86/libtermux.so differ
diff --git a/app/src/main/res/drawable-hdpi/ic_launcher.png b/app/src/main/res/drawable-hdpi/ic_launcher.png
new file mode 100644
index 0000000000..aa06923d42
Binary files /dev/null and b/app/src/main/res/drawable-hdpi/ic_launcher.png differ
diff --git a/app/src/main/res/drawable-hdpi/ic_service_notification.png b/app/src/main/res/drawable-hdpi/ic_service_notification.png
new file mode 100644
index 0000000000..52099fa02d
Binary files /dev/null and b/app/src/main/res/drawable-hdpi/ic_service_notification.png differ
diff --git a/app/src/main/res/drawable-mdpi/ic_launcher.png b/app/src/main/res/drawable-mdpi/ic_launcher.png
new file mode 100644
index 0000000000..8445121293
Binary files /dev/null and b/app/src/main/res/drawable-mdpi/ic_launcher.png differ
diff --git a/app/src/main/res/drawable-mdpi/ic_service_notification.png b/app/src/main/res/drawable-mdpi/ic_service_notification.png
new file mode 100644
index 0000000000..1f55514801
Binary files /dev/null and b/app/src/main/res/drawable-mdpi/ic_service_notification.png differ
diff --git a/app/src/main/res/drawable-xhdpi/ic_launcher.png b/app/src/main/res/drawable-xhdpi/ic_launcher.png
new file mode 100644
index 0000000000..bc8ecf9f69
Binary files /dev/null and b/app/src/main/res/drawable-xhdpi/ic_launcher.png differ
diff --git a/app/src/main/res/drawable-xhdpi/ic_service_notification.png b/app/src/main/res/drawable-xhdpi/ic_service_notification.png
new file mode 100644
index 0000000000..7c172bc82c
Binary files /dev/null and b/app/src/main/res/drawable-xhdpi/ic_service_notification.png differ
diff --git a/app/src/main/res/drawable-xxhdpi/ic_launcher.png b/app/src/main/res/drawable-xxhdpi/ic_launcher.png
new file mode 100644
index 0000000000..742e5629c8
Binary files /dev/null and b/app/src/main/res/drawable-xxhdpi/ic_launcher.png differ
diff --git a/app/src/main/res/drawable-xxhdpi/ic_service_notification.png b/app/src/main/res/drawable-xxhdpi/ic_service_notification.png
new file mode 100644
index 0000000000..ecaf5e5515
Binary files /dev/null and b/app/src/main/res/drawable-xxhdpi/ic_service_notification.png differ
diff --git a/app/src/main/res/drawable-xxxhdpi/ic_launcher.png b/app/src/main/res/drawable-xxxhdpi/ic_launcher.png
new file mode 100644
index 0000000000..18c486612d
Binary files /dev/null and b/app/src/main/res/drawable-xxxhdpi/ic_launcher.png differ
diff --git a/app/src/main/res/drawable-xxxhdpi/ic_service_notification.png b/app/src/main/res/drawable-xxxhdpi/ic_service_notification.png
new file mode 100644
index 0000000000..7a077ff5f5
Binary files /dev/null and b/app/src/main/res/drawable-xxxhdpi/ic_service_notification.png differ
diff --git a/app/src/main/res/drawable/banner.png b/app/src/main/res/drawable/banner.png
new file mode 100644
index 0000000000..020121b22c
Binary files /dev/null and b/app/src/main/res/drawable/banner.png differ
diff --git a/app/src/main/res/drawable/current_session.xml b/app/src/main/res/drawable/current_session.xml
new file mode 100644
index 0000000000..e118aa0174
--- /dev/null
+++ b/app/src/main/res/drawable/current_session.xml
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/app/src/main/res/drawable/selected_session_background.xml b/app/src/main/res/drawable/selected_session_background.xml
new file mode 100644
index 0000000000..3db6d6e502
--- /dev/null
+++ b/app/src/main/res/drawable/selected_session_background.xml
@@ -0,0 +1,5 @@
+
+
+
+
+
\ No newline at end of file
diff --git a/app/src/main/res/drawable/session_ripple.xml b/app/src/main/res/drawable/session_ripple.xml
new file mode 100644
index 0000000000..f38d75b66e
--- /dev/null
+++ b/app/src/main/res/drawable/session_ripple.xml
@@ -0,0 +1,7 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/app/src/main/res/drawable/terminal_scroll_shape.xml b/app/src/main/res/drawable/terminal_scroll_shape.xml
new file mode 100644
index 0000000000..76cb0719db
--- /dev/null
+++ b/app/src/main/res/drawable/terminal_scroll_shape.xml
@@ -0,0 +1,22 @@
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/app/src/main/res/layout/drawer_layout.xml b/app/src/main/res/layout/drawer_layout.xml
new file mode 100644
index 0000000000..854da9de13
--- /dev/null
+++ b/app/src/main/res/layout/drawer_layout.xml
@@ -0,0 +1,58 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/app/src/main/res/layout/line_in_drawer.xml b/app/src/main/res/layout/line_in_drawer.xml
new file mode 100644
index 0000000000..060c7db0ac
--- /dev/null
+++ b/app/src/main/res/layout/line_in_drawer.xml
@@ -0,0 +1,9 @@
+
\ No newline at end of file
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
new file mode 100644
index 0000000000..b404f4b35c
--- /dev/null
+++ b/app/src/main/res/values/strings.xml
@@ -0,0 +1,61 @@
+
+
+ Termux
+ Termux help
+ Termux user
+ New session
+ Normal - unnamed
+ Normal - named
+ Failsafe
+ Keyboard
+ Reset
+ Style
+ Fullscreen
+ Share
+ Terminal transcript
+ Help
+
+ Welcome to Termux
+ Long press anywhere on the terminal for a context menu where Help is available.\n\nExecute \'apt update\' to update the packages list before installing packages.
+ Do not show again
+
+ Installing…
+ Unable to install
+ Termux was unable to install the bootstrap packages.\n\nCheck your network connection and try again.
+ Abort
+ Try again
+ Unable to install
+ Termux can only be installed on the primary user account.
+
+ Max terminals reached
+ Close down existing ones before creating new.
+
+ Terminal reset.
+
+ Select…
+ Select text
+ Select URL
+ Click URL to copy or long press to open
+ Select all text and share
+ No URL found in the terminal.
+ URL copied to clipboard
+ Send text to:
+
+ Paste
+ Hangup
+
+ Close this process?
+
+ Set session name
+ Set
+ New named session
+ Create
+
+ The Termux:Style add-on is not installed.
+ Install
+
+ Exit
+ Wake
+ Wifi
+
+
diff --git a/app/src/main/res/values/styles.xml b/app/src/main/res/values/styles.xml
new file mode 100644
index 0000000000..d4f6e9112b
--- /dev/null
+++ b/app/src/main/res/values/styles.xml
@@ -0,0 +1,20 @@
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/app/src/test/java/com/termux/terminal/ByteQueueTest.java b/app/src/test/java/com/termux/terminal/ByteQueueTest.java
new file mode 100644
index 0000000000..aa761d3f85
--- /dev/null
+++ b/app/src/test/java/com/termux/terminal/ByteQueueTest.java
@@ -0,0 +1,54 @@
+package com.termux.terminal;
+
+import junit.framework.TestCase;
+
+public class ByteQueueTest extends TestCase {
+
+ private static void assertArrayEquals(byte[] expected, byte[] actual) {
+ if (expected.length != actual.length) {
+ fail("Difference array length");
+ }
+ for (int i = 0; i < expected.length; i++) {
+ if (expected[i] != actual[i]) {
+ fail("Inequals at index=" + i + ", expected=" + (int) expected[i] + ", actual=" + (int) actual[i]);
+ }
+ }
+ }
+
+ public void testCompleteWrites() throws Exception {
+ ByteQueue q = new ByteQueue(10);
+ assertEquals(true, q.write(new byte[] { 1, 2, 3 }, 0, 3));
+
+ byte[] arr = new byte[10];
+ assertEquals(3, q.read(arr, true));
+ assertArrayEquals(new byte[] { 1, 2, 3 }, new byte[] { arr[0], arr[1], arr[2] });
+
+ assertEquals(true, q.write(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, 0, 10));
+ assertEquals(10, q.read(arr, true));
+ assertArrayEquals(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, arr);
+ }
+
+ public void testQueueWraparound() throws Exception {
+ ByteQueue q = new ByteQueue(10);
+
+ byte[] origArray = new byte[] { 1, 2, 3, 4, 5, 6 };
+ byte[] readArray = new byte[origArray.length];
+ for (int i = 0; i < 20; i++) {
+ q.write(origArray, 0, origArray.length);
+ assertEquals(origArray.length, q.read(readArray, true));
+ assertArrayEquals(origArray, readArray);
+ }
+ }
+
+ public void testWriteNotesClosing() throws Exception {
+ ByteQueue q = new ByteQueue(10);
+ q.close();
+ assertEquals(false, q.write(new byte[] { 1, 2, 3 }, 0, 3));
+ }
+
+ public void testReadNonBlocking() throws Exception {
+ ByteQueue q = new ByteQueue(10);
+ assertEquals(0, q.read(new byte[128], false));
+ }
+
+}
diff --git a/app/src/test/java/com/termux/terminal/ControlSequenceIntroducerTest.java b/app/src/test/java/com/termux/terminal/ControlSequenceIntroducerTest.java
new file mode 100644
index 0000000000..585b4fae69
--- /dev/null
+++ b/app/src/test/java/com/termux/terminal/ControlSequenceIntroducerTest.java
@@ -0,0 +1,23 @@
+package com.termux.terminal;
+
+/** "\033[" is the Control Sequence Introducer char sequence (CSI). */
+public class ControlSequenceIntroducerTest extends TerminalTestCase {
+
+ /** CSI Ps P Scroll down Ps lines (default = 1) (SD). */
+ public void testCsiT() {
+ withTerminalSized(4, 6).enterString("1\r\n2\r\n3\r\nhi\033[2Tyo\r\nA\r\nB").assertLinesAre(" ", " ", "1 ", "2 yo", "A ",
+ "Bi ");
+ // Default value (1):
+ withTerminalSized(4, 6).enterString("1\r\n2\r\n3\r\nhi\033[Tyo\r\nA\r\nB").assertLinesAre(" ", "1 ", "2 ", "3 yo", "Ai ",
+ "B ");
+ }
+
+ /** CSI Ps S Scroll up Ps lines (default = 1) (SU). */
+ public void testCsiS() {
+ // The behaviour here is a bit inconsistent between terminals - this is how the OS X Terminal.app does it:
+ withTerminalSized(3, 4).enterString("1\r\n2\r\n3\r\nhi\033[2Sy").assertLinesAre("3 ", "hi ", " ", " y");
+ // Default value (1):
+ withTerminalSized(3, 4).enterString("1\r\n2\r\n3\r\nhi\033[Sy").assertLinesAre("2 ", "3 ", "hi ", " y");
+ }
+
+}
diff --git a/app/src/test/java/com/termux/terminal/CursorAndScreenTest.java b/app/src/test/java/com/termux/terminal/CursorAndScreenTest.java
new file mode 100644
index 0000000000..fe33966fd5
--- /dev/null
+++ b/app/src/test/java/com/termux/terminal/CursorAndScreenTest.java
@@ -0,0 +1,175 @@
+package com.termux.terminal;
+
+import junit.framework.Assert;
+
+public class CursorAndScreenTest extends TerminalTestCase {
+
+ public void testDeleteLinesKeepsStyles() {
+ int cols = 5, rows = 5;
+ withTerminalSized(cols, rows);
+ for (int row = 0; row < 5; row++) {
+ for (int col = 0; col < 5; col++) {
+ // Foreground color to col, background to row:
+ enterString("\033[38;5;" + col + "m");
+ enterString("\033[48;5;" + row + "m");
+ enterString(Character.toString((char) ('A' + col + row * 5)));
+ }
+ }
+ assertLinesAre("ABCDE", "FGHIJ", "KLMNO", "PQRST", "UVWXY");
+ for (int row = 0; row < 5; row++) {
+ for (int col = 0; col < 5; col++) {
+ int s = getStyleAt(row, col);
+ Assert.assertEquals(col, TextStyle.decodeForeColor(s));
+ Assert.assertEquals(row, TextStyle.decodeBackColor(s));
+ }
+ }
+ // "${CSI}H" - place cursor at 1,1, then "${CSI}2M" to delete two lines.
+ enterString("\033[H\033[2M");
+ assertLinesAre("KLMNO", "PQRST", "UVWXY", " ", " ");
+ for (int row = 0; row < 3; row++) {
+ for (int col = 0; col < 5; col++) {
+ int s = getStyleAt(row, col);
+ Assert.assertEquals(col, TextStyle.decodeForeColor(s));
+ Assert.assertEquals(row + 2, TextStyle.decodeBackColor(s));
+ }
+ }
+ // Set default fg and background for the new blank lines:
+ enterString("\033[38;5;98m");
+ enterString("\033[48;5;99m");
+ // "${CSI}B" to go down one line, then "${CSI}2L" to insert two lines:
+ enterString("\033[B\033[2L");
+ assertLinesAre("KLMNO", " ", " ", "PQRST", "UVWXY");
+ for (int row = 0; row < 5; row++) {
+ for (int col = 0; col < 5; col++) {
+ int wantedForeground = (row == 1 || row == 2) ? 98 : col;
+ int wantedBackground = (row == 1 || row == 2) ? 99 : (row == 0 ? 2 : row);
+ int s = getStyleAt(row, col);
+ Assert.assertEquals(wantedForeground, TextStyle.decodeForeColor(s));
+ Assert.assertEquals(wantedBackground, TextStyle.decodeBackColor(s));
+ }
+ }
+ }
+
+ public void testDeleteCharacters() {
+ withTerminalSized(5, 2).enterString("枝ce").assertLinesAre("枝ce ", " ");
+ withTerminalSized(5, 2).enterString("a枝ce").assertLinesAre("a枝ce", " ");
+ withTerminalSized(5, 2).enterString("nice").enterString("\033[G\033[P").assertLinesAre("ice ", " ");
+ withTerminalSized(5, 2).enterString("nice").enterString("\033[G\033[2P").assertLinesAre("ce ", " ");
+ withTerminalSized(5, 2).enterString("nice").enterString("\033[2G\033[2P").assertLinesAre("ne ", " ");
+ // "${CSI}${n}P, the delete characters (DCH) sequence should cap characters to delete.
+ withTerminalSized(5, 2).enterString("nice").enterString("\033[G\033[99P").assertLinesAre(" ", " ");
+ // With combining char U+0302.
+ withTerminalSized(5, 2).enterString("n\u0302ice").enterString("\033[G\033[2P").assertLinesAre("ce ", " ");
+ withTerminalSized(5, 2).enterString("n\u0302ice").enterString("\033[G\033[P").assertLinesAre("ice ", " ");
+ withTerminalSized(5, 2).enterString("n\u0302ice").enterString("\033[2G\033[2P").assertLinesAre("n\u0302e ", " ");
+ // With wide 枝 char, checking that putting char at part replaces other with whitespace:
+ withTerminalSized(5, 2).enterString("枝ce").enterString("\033[Ga").assertLinesAre("a ce ", " ");
+ withTerminalSized(5, 2).enterString("枝ce").enterString("\033[2Ga").assertLinesAre(" ace ", " ");
+ // With wide 枝 char, deleting either part replaces other with whitespace:
+ withTerminalSized(5, 2).enterString("枝ce").enterString("\033[G\033[P").assertLinesAre(" ce ", " ");
+ withTerminalSized(5, 2).enterString("枝ce").enterString("\033[2G\033[P").assertLinesAre(" ce ", " ");
+ withTerminalSized(5, 2).enterString("枝ce").enterString("\033[2G\033[2P").assertLinesAre(" e ", " ");
+ withTerminalSized(5, 2).enterString("枝ce").enterString("\033[G\033[2P").assertLinesAre("ce ", " ");
+ withTerminalSized(5, 2).enterString("a枝ce").enterString("\033[G\033[P").assertLinesAre("枝ce ", " ");
+ }
+
+ public void testInsertMode() {
+ // "${CSI}4h" enables insert mode.
+ withTerminalSized(5, 2).enterString("nice").enterString("\033[G\033[4hA").assertLinesAre("Anice", " ");
+ withTerminalSized(5, 2).enterString("nice").enterString("\033[2G\033[4hA").assertLinesAre("nAice", " ");
+ withTerminalSized(5, 2).enterString("nice").enterString("\033[G\033[4hABC").assertLinesAre("ABCni", " ");
+ // With combining char U+0302.
+ withTerminalSized(5, 2).enterString("n\u0302ice").enterString("\033[G\033[4hA").assertLinesAre("An\u0302ice", " ");
+ withTerminalSized(5, 2).enterString("n\u0302ice").enterString("\033[G\033[4hAB").assertLinesAre("ABn\u0302ic", " ");
+ withTerminalSized(5, 2).enterString("n\u0302ic\u0302e").enterString("\033[2G\033[4hA").assertLinesAre("n\u0302Aic\u0302e", " ");
+ // ... but without insert mode, combining char should be overwritten:
+ withTerminalSized(5, 2).enterString("n\u0302ice").enterString("\033[GA").assertLinesAre("Aice ", " ");
+ // ... also with two combining:
+ withTerminalSized(5, 2).enterString("n\u0302\u0302i\u0302ce").enterString("\033[GA").assertLinesAre("Ai\u0302ce ", " ");
+ // ... and in last column:
+ withTerminalSized(5, 2).enterString("n\u0302\u0302ice!\u0302").enterString("\033[5GA").assertLinesAre("n\u0302\u0302iceA", " ");
+ withTerminalSized(5, 2).enterString("nic\u0302e!\u0302").enterString("\033[4G枝").assertLinesAre("nic\u0302枝", " ");
+ withTerminalSized(5, 2).enterString("nic枝\u0302").enterString("\033[3GA").assertLinesAre("niA枝\u0302", " ");
+ withTerminalSized(5, 2).enterString("nic枝\u0302").enterString("\033[3GA").assertLinesAre("niA枝\u0302", " ");
+ // With wide 枝 char.
+ withTerminalSized(5, 2).enterString("nice").enterString("\033[G\033[4h枝").assertLinesAre("枝nic", " ");
+ withTerminalSized(5, 2).enterString("nice").enterString("\033[2G\033[4h枝").assertLinesAre("n枝ic", " ");
+ withTerminalSized(5, 2).enterString("n枝ce").enterString("\033[G\033[4ha").assertLinesAre("an枝c", " ");
+ }
+
+ /** HPA—Horizontal Position Absolute (http://www.vt100.net/docs/vt510-rm/HPA) */
+ public void testCursorHorizontalPositionAbsolute() {
+ withTerminalSized(4, 4).enterString("ABC\033[`").assertCursorAt(0, 0);
+ enterString("\033[1`").assertCursorAt(0, 0).enterString("\033[2`").assertCursorAt(0, 1);
+ enterString("\r\n\033[3`").assertCursorAt(1, 2).enterString("\033[22`").assertCursorAt(1, 3);
+ // Enable and configure right and left margins, first without origin mode:
+ enterString("\033[?69h\033[2;3s\033[`").assertCursorAt(0, 0).enterString("\033[22`").assertCursorAt(0, 3);
+ // .. now with origin mode:
+ enterString("\033[?6h\033[`").assertCursorAt(0, 1).enterString("\033[22`").assertCursorAt(0, 2);
+ }
+
+ public void testCursorForward() {
+ // "${CSI}${N:=1}C" moves cursor forward N columns:
+ withTerminalSized(6, 2).enterString("A\033[CB\033[2CC").assertLinesAre("A B C", " ");
+ // If an attempt is made to move the cursor to the right of the right margin, the cursor stops at the right margin:
+ withTerminalSized(6, 2).enterString("A\033[44CB").assertLinesAre("A B", " ");
+ // Enable right margin and verify that CUF ends at the set right margin:
+ withTerminalSized(6, 2).enterString("\033[?69h\033[1;3s\033[44CAB").assertLinesAre(" A ", "B ");
+ }
+
+ public void testCursorBack() {
+ // "${CSI}${N:=1}D" moves cursor back N columns:
+ withTerminalSized(3, 2).enterString("A\033[DB").assertLinesAre("B ", " ");
+ withTerminalSized(3, 2).enterString("AB\033[2DC").assertLinesAre("CB ", " ");
+ // If an attempt is made to move the cursor to the left of the left margin, the cursor stops at the left margin:
+ withTerminalSized(3, 2).enterString("AB\033[44DC").assertLinesAre("CB ", " ");
+ // Enable left margin and verify that CUB ends at the set left margin:
+ withTerminalSized(6, 2).enterString("ABCD\033[?69h\033[2;6s\033[44DE").assertLinesAre("AECD ", " ");
+ }
+
+ public void testCursorUp() {
+ // "${CSI}${N:=1}A" moves cursor up N rows:
+ withTerminalSized(3, 3).enterString("ABCDEFG\033[AH").assertLinesAre("ABC", "DHF", "G ");
+ withTerminalSized(3, 3).enterString("ABCDEFG\033[2AH").assertLinesAre("AHC", "DEF", "G ");
+ // If an attempt is made to move the cursor above the top margin, the cursor stops at the top margin:
+ withTerminalSized(3, 3).enterString("ABCDEFG\033[44AH").assertLinesAre("AHC", "DEF", "G ");
+ // Set top margin and validate that cursor does not go above it:
+ withTerminalSized(3, 3).enterString("\033[2rABCDEFG\033[44AH").assertLinesAre("ABC", "DHF", "G ");
+ }
+
+ public void testCursorDown() {
+ // "${CSI}${N:=1}B" moves cursor down N rows:
+ withTerminalSized(3, 3).enterString("AB\033[BC").assertLinesAre("AB ", " C", " ");
+ withTerminalSized(3, 3).enterString("AB\033[2BC").assertLinesAre("AB ", " ", " C");
+ // If an attempt is made to move the cursor below the bottom margin, the cursor stops at the bottom margin:
+ withTerminalSized(3, 3).enterString("AB\033[44BC").assertLinesAre("AB ", " ", " C");
+ // Set bottom margin and validate that cursor does not go above it:
+ withTerminalSized(3, 3).enterString("\033[1;2rAB\033[44BC").assertLinesAre("AB ", " C", " ");
+ }
+
+ public void testReportCursorPosition() {
+ withTerminalSized(10, 10);
+ for (int i = 0; i < 10; i++) {
+ for (int j = 0; j < 10; j++) {
+ enterString("\033[" + (i + 1) + ";" + (j + 1) + "H"); // CUP cursor position.
+ assertCursorAt(i, j);
+ // Device Status Report (DSR):
+ assertEnteringStringGivesResponse("\033[6n", "\033[" + (i + 1) + ";" + (j + 1) + "R");
+ // DECXCPR — Extended Cursor Position. Note that http://www.vt100.net/docs/vt510-rm/DECXCPR says
+ // the response is "${CSI}${LINE};${COLUMN};${PAGE}R" while xterm (http://invisible-island.net/xterm/ctlseqs/ctlseqs.html)
+ // drops the question mark. Expect xterm behaviour here.
+ assertEnteringStringGivesResponse("\033[?6n", "\033[?" + (i + 1) + ";" + (j + 1) + ";1R");
+ }
+ }
+ }
+
+ public void testHorizontalTabColorsBackground() {
+ withTerminalSized(10, 3).enterString("\033[48;5;15m").enterString("\t");
+ assertCursorAt(0, 8);
+ for (int i = 0; i < 10; i++) {
+ int expectedColor = i < 8 ? 15 : TextStyle.COLOR_INDEX_BACKGROUND;
+ assertEquals(expectedColor, TextStyle.decodeBackColor(getStyleAt(0, i)));
+ }
+ }
+
+}
diff --git a/app/src/test/java/com/termux/terminal/DecSetTest.java b/app/src/test/java/com/termux/terminal/DecSetTest.java
new file mode 100644
index 0000000000..5c115f06ef
--- /dev/null
+++ b/app/src/test/java/com/termux/terminal/DecSetTest.java
@@ -0,0 +1,62 @@
+package com.termux.terminal;
+
+/**
+ *
+ * "CSI ? Pm h", DEC Private Mode Set (DECSET)
+ *