| /* |
| * ConnectBot: simple, powerful, open-source SSH client for Android |
| * Copyright 2007 Kenny Root, Jeffrey Sharkey |
| * |
| * 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. |
| */ |
| |
| /** |
| * @author modified by raaar |
| * |
| */ |
| |
| package org.connectbot; |
| |
| import android.app.Activity; |
| import android.app.AlertDialog; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.DialogInterface; |
| import android.content.Intent; |
| import android.content.ServiceConnection; |
| import android.content.SharedPreferences; |
| import android.content.pm.ActivityInfo; |
| import android.content.res.Configuration; |
| import android.media.AudioManager; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.IBinder; |
| import android.os.Message; |
| import android.os.PowerManager; |
| import android.preference.PreferenceManager; |
| import android.text.ClipboardManager; |
| import android.view.ContextMenu; |
| import android.view.ContextMenu.ContextMenuInfo; |
| import android.view.GestureDetector; |
| import android.view.LayoutInflater; |
| import android.view.Menu; |
| import android.view.MenuItem; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.View.OnClickListener; |
| import android.view.View.OnTouchListener; |
| import android.view.ViewConfiguration; |
| import android.view.WindowManager; |
| import android.view.animation.Animation; |
| import android.view.animation.AnimationUtils; |
| import android.view.inputmethod.InputMethodManager; |
| import android.widget.Button; |
| import android.widget.EditText; |
| import android.widget.ImageView; |
| import android.widget.RelativeLayout; |
| import android.widget.TextView; |
| import android.widget.Toast; |
| import android.widget.ViewFlipper; |
| |
| import com.googlecode.android_scripting.Constants; |
| import com.googlecode.android_scripting.Log; |
| import com.googlecode.android_scripting.R; |
| import com.googlecode.android_scripting.ScriptProcess; |
| import com.googlecode.android_scripting.activity.Preferences; |
| import com.googlecode.android_scripting.activity.ScriptingLayerService; |
| |
| import de.mud.terminal.VDUBuffer; |
| import de.mud.terminal.vt320; |
| |
| import org.connectbot.service.PromptHelper; |
| import org.connectbot.service.TerminalBridge; |
| import org.connectbot.service.TerminalManager; |
| import org.connectbot.util.PreferenceConstants; |
| import org.connectbot.util.SelectionArea; |
| |
| public class ConsoleActivity extends Activity { |
| |
| protected static final int REQUEST_EDIT = 1; |
| |
| private static final int CLICK_TIME = 250; |
| private static final float MAX_CLICK_DISTANCE = 25f; |
| private static final int KEYBOARD_DISPLAY_TIME = 1250; |
| |
| // Direction to shift the ViewFlipper |
| private static final int SHIFT_LEFT = 0; |
| private static final int SHIFT_RIGHT = 1; |
| |
| protected ViewFlipper flip = null; |
| protected TerminalManager manager = null; |
| protected ScriptingLayerService mService = null; |
| protected LayoutInflater inflater = null; |
| |
| private SharedPreferences prefs = null; |
| |
| private PowerManager.WakeLock wakelock = null; |
| |
| protected Integer processID; |
| |
| protected ClipboardManager clipboard; |
| |
| private RelativeLayout booleanPromptGroup; |
| private TextView booleanPrompt; |
| private Button booleanYes, booleanNo; |
| |
| private Animation slide_left_in, slide_left_out, slide_right_in, slide_right_out, |
| fade_stay_hidden, fade_out_delayed; |
| |
| private Animation keyboard_fade_in, keyboard_fade_out; |
| private ImageView keyboardButton; |
| private float lastX, lastY; |
| |
| private int mTouchSlopSquare; |
| |
| private InputMethodManager inputManager; |
| |
| protected TerminalBridge copySource = null; |
| private int lastTouchRow, lastTouchCol; |
| |
| private boolean forcedOrientation; |
| |
| private Handler handler = new Handler(); |
| |
| private static enum MenuId { |
| EDIT, PREFS, EMAIL, RESIZE, COPY, PASTE; |
| public int getId() { |
| return ordinal() + Menu.FIRST; |
| } |
| } |
| |
| private final ServiceConnection mConnection = new ServiceConnection() { |
| @Override |
| public void onServiceConnected(ComponentName name, IBinder service) { |
| mService = ((ScriptingLayerService.LocalBinder) service).getService(); |
| manager = mService.getTerminalManager(); |
| // let manager know about our event handling services |
| manager.setDisconnectHandler(disconnectHandler); |
| |
| Log.d(String.format("Connected to TerminalManager and found bridges.size=%d", manager |
| .getBridgeList().size())); |
| |
| manager.setResizeAllowed(true); |
| |
| // clear out any existing bridges and record requested index |
| flip.removeAllViews(); |
| |
| int requestedIndex = 0; |
| |
| TerminalBridge requestedBridge = manager.getConnectedBridge(processID); |
| |
| // If we didn't find the requested connection, try opening it |
| if (processID != null && requestedBridge == null) { |
| try { |
| Log.d(String.format( |
| "We couldnt find an existing bridge with id = %d, so creating one now", processID)); |
| requestedBridge = manager.openConnection(processID); |
| } catch (Exception e) { |
| Log.e("Problem while trying to create new requested bridge", e); |
| } |
| } |
| |
| // create views for all bridges on this service |
| for (TerminalBridge bridge : manager.getBridgeList()) { |
| |
| final int currentIndex = addNewTerminalView(bridge); |
| |
| // check to see if this bridge was requested |
| if (bridge == requestedBridge) { |
| requestedIndex = currentIndex; |
| } |
| } |
| |
| setDisplayedTerminal(requestedIndex); |
| } |
| |
| @Override |
| public void onServiceDisconnected(ComponentName name) { |
| manager = null; |
| mService = null; |
| } |
| }; |
| |
| protected Handler promptHandler = new Handler() { |
| @Override |
| public void handleMessage(Message msg) { |
| // someone below us requested to display a prompt |
| updatePromptVisible(); |
| } |
| }; |
| |
| protected Handler disconnectHandler = new Handler() { |
| @Override |
| public void handleMessage(Message msg) { |
| Log.d("Someone sending HANDLE_DISCONNECT to parentHandler"); |
| TerminalBridge bridge = (TerminalBridge) msg.obj; |
| closeBridge(bridge); |
| } |
| }; |
| |
| /** |
| * @param bridge |
| */ |
| private void closeBridge(final TerminalBridge bridge) { |
| synchronized (flip) { |
| final int flipIndex = getFlipIndex(bridge); |
| |
| if (flipIndex >= 0) { |
| if (flip.getDisplayedChild() == flipIndex) { |
| shiftCurrentTerminal(SHIFT_LEFT); |
| } |
| flip.removeViewAt(flipIndex); |
| |
| /* |
| * TODO Remove this workaround when ViewFlipper is fixed to listen to view removals. Android |
| * Issue 1784 |
| */ |
| final int numChildren = flip.getChildCount(); |
| if (flip.getDisplayedChild() >= numChildren && numChildren > 0) { |
| flip.setDisplayedChild(numChildren - 1); |
| } |
| } |
| |
| // If we just closed the last bridge, go back to the previous activity. |
| if (flip.getChildCount() == 0) { |
| finish(); |
| } |
| } |
| } |
| |
| protected View findCurrentView(int id) { |
| View view = flip.getCurrentView(); |
| if (view == null) { |
| return null; |
| } |
| return view.findViewById(id); |
| } |
| |
| protected PromptHelper getCurrentPromptHelper() { |
| View view = findCurrentView(R.id.console_flip); |
| if (!(view instanceof TerminalView)) { |
| return null; |
| } |
| return ((TerminalView) view).bridge.getPromptHelper(); |
| } |
| |
| protected void hideAllPrompts() { |
| booleanPromptGroup.setVisibility(View.GONE); |
| } |
| |
| @Override |
| public void onCreate(Bundle icicle) { |
| super.onCreate(icicle); |
| |
| this.setContentView(R.layout.act_console); |
| |
| clipboard = (ClipboardManager) getSystemService(CLIPBOARD_SERVICE); |
| prefs = PreferenceManager.getDefaultSharedPreferences(this); |
| |
| // hide status bar if requested by user |
| if (prefs.getBoolean(PreferenceConstants.FULLSCREEN, false)) { |
| getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, |
| WindowManager.LayoutParams.FLAG_FULLSCREEN); |
| } |
| |
| // TODO find proper way to disable volume key beep if it exists. |
| setVolumeControlStream(AudioManager.STREAM_MUSIC); |
| |
| PowerManager manager = (PowerManager) getSystemService(Context.POWER_SERVICE); |
| wakelock = manager.newWakeLock(PowerManager.SCREEN_DIM_WAKE_LOCK, getPackageName()); |
| |
| // handle requested console from incoming intent |
| int id = getIntent().getIntExtra(Constants.EXTRA_PROXY_PORT, -1); |
| |
| if (id > 0) { |
| processID = id; |
| } |
| |
| inflater = LayoutInflater.from(this); |
| |
| flip = (ViewFlipper) findViewById(R.id.console_flip); |
| booleanPromptGroup = (RelativeLayout) findViewById(R.id.console_boolean_group); |
| booleanPrompt = (TextView) findViewById(R.id.console_prompt); |
| |
| booleanYes = (Button) findViewById(R.id.console_prompt_yes); |
| booleanYes.setOnClickListener(new OnClickListener() { |
| public void onClick(View v) { |
| PromptHelper helper = getCurrentPromptHelper(); |
| if (helper == null) { |
| return; |
| } |
| helper.setResponse(Boolean.TRUE); |
| updatePromptVisible(); |
| } |
| }); |
| |
| booleanNo = (Button) findViewById(R.id.console_prompt_no); |
| booleanNo.setOnClickListener(new OnClickListener() { |
| public void onClick(View v) { |
| PromptHelper helper = getCurrentPromptHelper(); |
| if (helper == null) { |
| return; |
| } |
| helper.setResponse(Boolean.FALSE); |
| updatePromptVisible(); |
| } |
| }); |
| |
| // preload animations for terminal switching |
| slide_left_in = AnimationUtils.loadAnimation(this, R.anim.slide_left_in); |
| slide_left_out = AnimationUtils.loadAnimation(this, R.anim.slide_left_out); |
| slide_right_in = AnimationUtils.loadAnimation(this, R.anim.slide_right_in); |
| slide_right_out = AnimationUtils.loadAnimation(this, R.anim.slide_right_out); |
| |
| fade_out_delayed = AnimationUtils.loadAnimation(this, R.anim.fade_out_delayed); |
| fade_stay_hidden = AnimationUtils.loadAnimation(this, R.anim.fade_stay_hidden); |
| |
| // Preload animation for keyboard button |
| keyboard_fade_in = AnimationUtils.loadAnimation(this, R.anim.keyboard_fade_in); |
| keyboard_fade_out = AnimationUtils.loadAnimation(this, R.anim.keyboard_fade_out); |
| |
| inputManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); |
| keyboardButton = (ImageView) findViewById(R.id.keyboard_button); |
| keyboardButton.setOnClickListener(new OnClickListener() { |
| public void onClick(View view) { |
| View flip = findCurrentView(R.id.console_flip); |
| if (flip == null) { |
| return; |
| } |
| |
| inputManager.showSoftInput(flip, InputMethodManager.SHOW_FORCED); |
| keyboardButton.setVisibility(View.GONE); |
| } |
| }); |
| if (prefs.getBoolean(PreferenceConstants.HIDE_KEYBOARD, false)) { |
| // Force hidden keyboard. |
| getWindow().setSoftInputMode( |
| WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN |
| | WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE); |
| } |
| final ViewConfiguration configuration = ViewConfiguration.get(this); |
| int touchSlop = configuration.getScaledTouchSlop(); |
| mTouchSlopSquare = touchSlop * touchSlop; |
| |
| // detect fling gestures to switch between terminals |
| final GestureDetector detect = |
| new GestureDetector(new GestureDetector.SimpleOnGestureListener() { |
| private float totalY = 0; |
| |
| @Override |
| public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) { |
| |
| final float distx = e2.getRawX() - e1.getRawX(); |
| final float disty = e2.getRawY() - e1.getRawY(); |
| final int goalwidth = flip.getWidth() / 2; |
| |
| // need to slide across half of display to trigger console change |
| // make sure user kept a steady hand horizontally |
| if (Math.abs(disty) < (flip.getHeight() / 4)) { |
| if (distx > goalwidth) { |
| shiftCurrentTerminal(SHIFT_RIGHT); |
| return true; |
| } |
| |
| if (distx < -goalwidth) { |
| shiftCurrentTerminal(SHIFT_LEFT); |
| return true; |
| } |
| |
| } |
| |
| return false; |
| } |
| |
| @Override |
| public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) { |
| |
| // if copying, then ignore |
| if (copySource != null && copySource.isSelectingForCopy()) { |
| return false; |
| } |
| |
| if (e1 == null || e2 == null) { |
| return false; |
| } |
| |
| // if releasing then reset total scroll |
| if (e2.getAction() == MotionEvent.ACTION_UP) { |
| totalY = 0; |
| } |
| |
| // activate consider if within x tolerance |
| if (Math.abs(e1.getX() - e2.getX()) < ViewConfiguration.getTouchSlop() * 4) { |
| |
| View flip = findCurrentView(R.id.console_flip); |
| if (flip == null) { |
| return false; |
| } |
| TerminalView terminal = (TerminalView) flip; |
| |
| // estimate how many rows we have scrolled through |
| // accumulate distance that doesn't trigger immediate scroll |
| totalY += distanceY; |
| final int moved = (int) (totalY / terminal.bridge.charHeight); |
| |
| VDUBuffer buffer = terminal.bridge.getVDUBuffer(); |
| |
| // consume as scrollback only if towards right half of screen |
| if (e2.getX() > flip.getWidth() / 2) { |
| if (moved != 0) { |
| int base = buffer.getWindowBase(); |
| buffer.setWindowBase(base + moved); |
| totalY = 0; |
| return true; |
| } |
| } else { |
| // otherwise consume as pgup/pgdown for every 5 lines |
| if (moved > 5) { |
| ((vt320) buffer).keyPressed(vt320.KEY_PAGE_DOWN, ' ', 0); |
| terminal.bridge.tryKeyVibrate(); |
| totalY = 0; |
| return true; |
| } else if (moved < -5) { |
| ((vt320) buffer).keyPressed(vt320.KEY_PAGE_UP, ' ', 0); |
| terminal.bridge.tryKeyVibrate(); |
| totalY = 0; |
| return true; |
| } |
| |
| } |
| |
| } |
| |
| return false; |
| } |
| |
| }); |
| |
| flip.setOnCreateContextMenuListener(this); |
| |
| flip.setOnTouchListener(new OnTouchListener() { |
| |
| public boolean onTouch(View v, MotionEvent event) { |
| |
| // when copying, highlight the area |
| if (copySource != null && copySource.isSelectingForCopy()) { |
| int row = (int) Math.floor(event.getY() / copySource.charHeight); |
| int col = (int) Math.floor(event.getX() / copySource.charWidth); |
| |
| SelectionArea area = copySource.getSelectionArea(); |
| |
| switch (event.getAction()) { |
| case MotionEvent.ACTION_DOWN: |
| // recording starting area |
| if (area.isSelectingOrigin()) { |
| area.setRow(row); |
| area.setColumn(col); |
| lastTouchRow = row; |
| lastTouchCol = col; |
| copySource.redraw(); |
| } |
| return true; |
| case MotionEvent.ACTION_MOVE: |
| /* |
| * ignore when user hasn't moved since last time so we can fine-tune with directional |
| * pad |
| */ |
| if (row == lastTouchRow && col == lastTouchCol) { |
| return true; |
| } |
| // if the user moves, start the selection for other corner |
| area.finishSelectingOrigin(); |
| |
| // update selected area |
| area.setRow(row); |
| area.setColumn(col); |
| lastTouchRow = row; |
| lastTouchCol = col; |
| copySource.redraw(); |
| return true; |
| case MotionEvent.ACTION_UP: |
| /* |
| * If they didn't move their finger, maybe they meant to select the rest of the text |
| * with the directional pad. |
| */ |
| if (area.getLeft() == area.getRight() && area.getTop() == area.getBottom()) { |
| return true; |
| } |
| |
| // copy selected area to clipboard |
| String copiedText = area.copyFrom(copySource.getVDUBuffer()); |
| |
| clipboard.setText(copiedText); |
| Toast.makeText(ConsoleActivity.this, |
| getString(R.string.terminal_copy_done, copiedText.length()), Toast.LENGTH_LONG) |
| .show(); |
| // fall through to clear state |
| |
| case MotionEvent.ACTION_CANCEL: |
| // make sure we clear any highlighted area |
| area.reset(); |
| copySource.setSelectingForCopy(false); |
| copySource.redraw(); |
| return true; |
| } |
| } |
| |
| Configuration config = getResources().getConfiguration(); |
| |
| if (event.getAction() == MotionEvent.ACTION_DOWN) { |
| lastX = event.getX(); |
| lastY = event.getY(); |
| } else if (event.getAction() == MotionEvent.ACTION_MOVE) { |
| final int deltaX = (int) (lastX - event.getX()); |
| final int deltaY = (int) (lastY - event.getY()); |
| int distance = (deltaX * deltaX) + (deltaY * deltaY); |
| if (distance > mTouchSlopSquare) { |
| // If currently scheduled long press event is not canceled here, |
| // GestureDetector.onScroll is executed, which takes a while, and by the time we are |
| // back in the view's dispatchTouchEvent |
| // mPendingCheckForLongPress is already executed |
| flip.cancelLongPress(); |
| } |
| } else if (event.getAction() == MotionEvent.ACTION_UP) { |
| // Same as above, except now GestureDetector.onFling is called. |
| flip.cancelLongPress(); |
| if (config.hardKeyboardHidden != Configuration.KEYBOARDHIDDEN_NO |
| && keyboardButton.getVisibility() == View.GONE |
| && event.getEventTime() - event.getDownTime() < CLICK_TIME |
| && Math.abs(event.getX() - lastX) < MAX_CLICK_DISTANCE |
| && Math.abs(event.getY() - lastY) < MAX_CLICK_DISTANCE) { |
| keyboardButton.startAnimation(keyboard_fade_in); |
| keyboardButton.setVisibility(View.VISIBLE); |
| |
| handler.postDelayed(new Runnable() { |
| public void run() { |
| if (keyboardButton.getVisibility() == View.GONE) { |
| return; |
| } |
| |
| keyboardButton.startAnimation(keyboard_fade_out); |
| keyboardButton.setVisibility(View.GONE); |
| } |
| }, KEYBOARD_DISPLAY_TIME); |
| |
| return false; |
| } |
| } |
| // pass any touch events back to detector |
| return detect.onTouchEvent(event); |
| } |
| |
| }); |
| |
| } |
| |
| private void configureOrientation() { |
| String rotateDefault; |
| if (getResources().getConfiguration().keyboard == Configuration.KEYBOARD_NOKEYS) { |
| rotateDefault = PreferenceConstants.ROTATION_PORTRAIT; |
| } else { |
| rotateDefault = PreferenceConstants.ROTATION_LANDSCAPE; |
| } |
| |
| String rotate = prefs.getString(PreferenceConstants.ROTATION, rotateDefault); |
| if (PreferenceConstants.ROTATION_DEFAULT.equals(rotate)) { |
| rotate = rotateDefault; |
| } |
| |
| // request a forced orientation if requested by user |
| if (PreferenceConstants.ROTATION_LANDSCAPE.equals(rotate)) { |
| setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); |
| forcedOrientation = true; |
| } else if (PreferenceConstants.ROTATION_PORTRAIT.equals(rotate)) { |
| setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); |
| forcedOrientation = true; |
| } else { |
| setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED); |
| forcedOrientation = false; |
| } |
| } |
| |
| @Override |
| public boolean onCreateOptionsMenu(Menu menu) { |
| super.onCreateOptionsMenu(menu); |
| getMenuInflater().inflate(R.menu.terminal, menu); |
| menu.setQwertyMode(true); |
| return true; |
| } |
| |
| @Override |
| public boolean onPrepareOptionsMenu(Menu menu) { |
| super.onPrepareOptionsMenu(menu); |
| setVolumeControlStream(AudioManager.STREAM_NOTIFICATION); |
| TerminalBridge bridge = ((TerminalView) findCurrentView(R.id.console_flip)).bridge; |
| boolean sessionOpen = bridge.isSessionOpen(); |
| menu.findItem(R.id.terminal_menu_resize).setEnabled(sessionOpen); |
| if (bridge.getProcess() instanceof ScriptProcess) { |
| menu.findItem(R.id.terminal_menu_exit_and_edit).setEnabled(true); |
| } |
| bridge.onPrepareOptionsMenu(menu); |
| return true; |
| } |
| |
| @Override |
| public boolean onOptionsItemSelected(MenuItem item) { |
| if (item.getItemId() == R.id.terminal_menu_resize) { |
| doResize(); |
| } else if (item.getItemId() == R.id.terminal_menu_preferences) { |
| doPreferences(); |
| } else if (item.getItemId() == R.id.terminal_menu_send_email) { |
| doEmailTranscript(); |
| } else if (item.getItemId() == R.id.terminal_menu_exit_and_edit) { |
| TerminalView terminalView = (TerminalView) findCurrentView(R.id.console_flip); |
| TerminalBridge bridge = terminalView.bridge; |
| if (manager != null) { |
| manager.closeConnection(bridge, true); |
| } else { |
| Intent intent = new Intent(this, ScriptingLayerService.class); |
| intent.setAction(Constants.ACTION_KILL_PROCESS); |
| intent.putExtra(Constants.EXTRA_PROXY_PORT, bridge.getId()); |
| startService(intent); |
| Message.obtain(disconnectHandler, -1, bridge).sendToTarget(); |
| } |
| Intent intent = new Intent(Constants.ACTION_EDIT_SCRIPT); |
| ScriptProcess process = (ScriptProcess) bridge.getProcess(); |
| intent.putExtra(Constants.EXTRA_SCRIPT_PATH, process.getPath()); |
| startActivity(intent); |
| finish(); |
| } |
| return super.onOptionsItemSelected(item); |
| } |
| |
| @Override |
| public void onOptionsMenuClosed(Menu menu) { |
| super.onOptionsMenuClosed(menu); |
| setVolumeControlStream(AudioManager.STREAM_MUSIC); |
| } |
| |
| private void doResize() { |
| closeOptionsMenu(); |
| final TerminalView terminalView = (TerminalView) findCurrentView(R.id.console_flip); |
| final View resizeView = inflater.inflate(R.layout.dia_resize, null, false); |
| new AlertDialog.Builder(ConsoleActivity.this).setView(resizeView) |
| .setPositiveButton(R.string.button_resize, new DialogInterface.OnClickListener() { |
| public void onClick(DialogInterface dialog, int which) { |
| int width, height; |
| try { |
| width = |
| Integer.parseInt(((EditText) resizeView.findViewById(R.id.width)).getText() |
| .toString()); |
| height = |
| Integer.parseInt(((EditText) resizeView.findViewById(R.id.height)).getText() |
| .toString()); |
| } catch (NumberFormatException nfe) { |
| return; |
| } |
| terminalView.forceSize(width, height); |
| } |
| }).setNegativeButton(android.R.string.cancel, null).create().show(); |
| } |
| |
| private void doPreferences() { |
| startActivity(new Intent(this, Preferences.class)); |
| } |
| |
| private void doEmailTranscript() { |
| // Don't really want to supply an address, but currently it's required, |
| // otherwise we get an exception. |
| TerminalView terminalView = (TerminalView) findCurrentView(R.id.console_flip); |
| TerminalBridge bridge = terminalView.bridge; |
| // TODO(raaar): Replace with process log. |
| VDUBuffer buffer = bridge.getVDUBuffer(); |
| int height = buffer.getRows(); |
| int width = buffer.getColumns(); |
| StringBuilder string = new StringBuilder(); |
| for (int i = 0; i < height; i++) { |
| for (int j = 0; j < width; j++) { |
| string.append(buffer.getChar(j, i)); |
| } |
| } |
| String addr = "user@example.com"; |
| Intent intent = new Intent(Intent.ACTION_SENDTO, Uri.parse("mailto:" + addr)); |
| intent.putExtra("body", string.toString().trim()); |
| startActivity(intent); |
| } |
| |
| @Override |
| public void onCreateContextMenu(ContextMenu menu, View view, ContextMenuInfo menuInfo) { |
| TerminalBridge bridge = ((TerminalView) findCurrentView(R.id.console_flip)).bridge; |
| boolean sessionOpen = bridge.isSessionOpen(); |
| menu.add(Menu.NONE, MenuId.COPY.getId(), Menu.NONE, R.string.terminal_menu_copy); |
| if (clipboard.hasText() && sessionOpen) { |
| menu.add(Menu.NONE, MenuId.PASTE.getId(), Menu.NONE, R.string.terminal_menu_paste); |
| } |
| bridge.onCreateContextMenu(menu, view, menuInfo); |
| } |
| |
| @Override |
| public boolean onContextItemSelected(MenuItem item) { |
| int itemId = item.getItemId(); |
| if (itemId == MenuId.COPY.getId()) { |
| TerminalView terminalView = (TerminalView) findCurrentView(R.id.console_flip); |
| copySource = terminalView.bridge; |
| SelectionArea area = copySource.getSelectionArea(); |
| area.reset(); |
| area.setBounds(copySource.getVDUBuffer().getColumns(), copySource.getVDUBuffer().getRows()); |
| copySource.setSelectingForCopy(true); |
| // Make sure we show the initial selection |
| copySource.redraw(); |
| Toast.makeText(ConsoleActivity.this, getString(R.string.terminal_copy_start), |
| Toast.LENGTH_LONG).show(); |
| return true; |
| } else if (itemId == MenuId.PASTE.getId()) { |
| TerminalView terminalView = (TerminalView) findCurrentView(R.id.console_flip); |
| TerminalBridge bridge = terminalView.bridge; |
| // pull string from clipboard and generate all events to force down |
| String clip = clipboard.getText().toString(); |
| bridge.injectString(clip); |
| return true; |
| } |
| return false; |
| } |
| |
| @Override |
| public void onStart() { |
| super.onStart(); |
| // connect with manager service to find all bridges |
| // when connected it will insert all views |
| bindService(new Intent(this, ScriptingLayerService.class), mConnection, 0); |
| } |
| |
| @Override |
| public void onPause() { |
| super.onPause(); |
| Log.d("onPause called"); |
| |
| // Allow the screen to dim and fall asleep. |
| if (wakelock != null && wakelock.isHeld()) { |
| wakelock.release(); |
| } |
| |
| if (forcedOrientation && manager != null) { |
| manager.setResizeAllowed(false); |
| } |
| } |
| |
| @Override |
| public void onResume() { |
| super.onResume(); |
| Log.d("onResume called"); |
| |
| // Make sure we don't let the screen fall asleep. |
| // This also keeps the Wi-Fi chipset from disconnecting us. |
| if (wakelock != null && prefs.getBoolean(PreferenceConstants.KEEP_ALIVE, true)) { |
| wakelock.acquire(); |
| } |
| |
| configureOrientation(); |
| |
| if (forcedOrientation && manager != null) { |
| manager.setResizeAllowed(true); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see android.app.Activity#onNewIntent(android.content.Intent) |
| */ |
| @Override |
| protected void onNewIntent(Intent intent) { |
| super.onNewIntent(intent); |
| |
| Log.d("onNewIntent called"); |
| |
| int id = intent.getIntExtra(Constants.EXTRA_PROXY_PORT, -1); |
| |
| if (id > 0) { |
| processID = id; |
| } |
| |
| if (processID == null) { |
| Log.e("Got null intent data in onNewIntent()"); |
| return; |
| } |
| |
| if (manager == null) { |
| Log.e("We're not bound in onNewIntent()"); |
| return; |
| } |
| |
| TerminalBridge requestedBridge = manager.getConnectedBridge(processID); |
| int requestedIndex = 0; |
| |
| synchronized (flip) { |
| if (requestedBridge == null) { |
| // If we didn't find the requested connection, try opening it |
| |
| try { |
| Log.d(String.format("We couldnt find an existing bridge with id = %d," |
| + "so creating one now", processID)); |
| requestedBridge = manager.openConnection(processID); |
| } catch (Exception e) { |
| Log.e("Problem while trying to create new requested bridge", e); |
| } |
| |
| requestedIndex = addNewTerminalView(requestedBridge); |
| } else { |
| final int flipIndex = getFlipIndex(requestedBridge); |
| if (flipIndex > requestedIndex) { |
| requestedIndex = flipIndex; |
| } |
| } |
| |
| setDisplayedTerminal(requestedIndex); |
| } |
| } |
| |
| @Override |
| public void onStop() { |
| super.onStop(); |
| unbindService(mConnection); |
| } |
| |
| protected void shiftCurrentTerminal(final int direction) { |
| View overlay; |
| synchronized (flip) { |
| boolean shouldAnimate = flip.getChildCount() > 1; |
| |
| // Only show animation if there is something else to go to. |
| if (shouldAnimate) { |
| // keep current overlay from popping up again |
| overlay = findCurrentView(R.id.terminal_overlay); |
| if (overlay != null) { |
| overlay.startAnimation(fade_stay_hidden); |
| } |
| |
| if (direction == SHIFT_LEFT) { |
| flip.setInAnimation(slide_left_in); |
| flip.setOutAnimation(slide_left_out); |
| flip.showNext(); |
| } else if (direction == SHIFT_RIGHT) { |
| flip.setInAnimation(slide_right_in); |
| flip.setOutAnimation(slide_right_out); |
| flip.showPrevious(); |
| } |
| } |
| |
| if (shouldAnimate) { |
| // show overlay on new slide and start fade |
| overlay = findCurrentView(R.id.terminal_overlay); |
| if (overlay != null) { |
| overlay.startAnimation(fade_out_delayed); |
| } |
| } |
| |
| updatePromptVisible(); |
| } |
| } |
| |
| /** |
| * Show any prompts requested by the currently visible {@link TerminalView}. |
| */ |
| protected void updatePromptVisible() { |
| // check if our currently-visible terminalbridge is requesting any prompt services |
| View view = findCurrentView(R.id.console_flip); |
| |
| // Hide all the prompts in case a prompt request was canceled |
| hideAllPrompts(); |
| |
| if (!(view instanceof TerminalView)) { |
| // we dont have an active view, so hide any prompts |
| return; |
| } |
| |
| PromptHelper prompt = ((TerminalView) view).bridge.getPromptHelper(); |
| |
| if (Boolean.class.equals(prompt.promptRequested)) { |
| booleanPromptGroup.setVisibility(View.VISIBLE); |
| booleanPrompt.setText(prompt.promptHint); |
| booleanYes.requestFocus(); |
| } else { |
| hideAllPrompts(); |
| view.requestFocus(); |
| } |
| } |
| |
| @Override |
| public void onConfigurationChanged(Configuration newConfig) { |
| super.onConfigurationChanged(newConfig); |
| |
| Log.d(String.format( |
| "onConfigurationChanged; requestedOrientation=%d, newConfig.orientation=%d", |
| getRequestedOrientation(), newConfig.orientation)); |
| if (manager != null) { |
| if (forcedOrientation |
| && (newConfig.orientation != Configuration.ORIENTATION_LANDSCAPE && getRequestedOrientation() == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) |
| || (newConfig.orientation != Configuration.ORIENTATION_PORTRAIT && getRequestedOrientation() == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT)) { |
| manager.setResizeAllowed(false); |
| } else { |
| manager.setResizeAllowed(true); |
| } |
| |
| manager |
| .setHardKeyboardHidden(newConfig.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_YES); |
| } |
| } |
| |
| /** |
| * Adds a new TerminalBridge to the current set of views in our ViewFlipper. |
| * |
| * @param bridge |
| * TerminalBridge to add to our ViewFlipper |
| * @return the child index of the new view in the ViewFlipper |
| */ |
| private int addNewTerminalView(TerminalBridge bridge) { |
| // let them know about our prompt handler services |
| bridge.getPromptHelper().setHandler(promptHandler); |
| |
| // inflate each terminal view |
| RelativeLayout view = (RelativeLayout) inflater.inflate(R.layout.item_terminal, flip, false); |
| |
| // set the terminal overlay text |
| TextView overlay = (TextView) view.findViewById(R.id.terminal_overlay); |
| overlay.setText(bridge.getName()); |
| |
| // and add our terminal view control, using index to place behind overlay |
| TerminalView terminal = new TerminalView(ConsoleActivity.this, bridge); |
| terminal.setId(R.id.console_flip); |
| view.addView(terminal, 0); |
| |
| synchronized (flip) { |
| // finally attach to the flipper |
| flip.addView(view); |
| return flip.getChildCount() - 1; |
| } |
| } |
| |
| private int getFlipIndex(TerminalBridge bridge) { |
| synchronized (flip) { |
| final int children = flip.getChildCount(); |
| for (int i = 0; i < children; i++) { |
| final View view = flip.getChildAt(i).findViewById(R.id.console_flip); |
| |
| if (view == null || !(view instanceof TerminalView)) { |
| // How did that happen? |
| continue; |
| } |
| |
| final TerminalView tv = (TerminalView) view; |
| |
| if (tv.bridge == bridge) { |
| return i; |
| } |
| } |
| } |
| |
| return -1; |
| } |
| |
| /** |
| * Displays the child in the ViewFlipper at the requestedIndex and updates the prompts. |
| * |
| * @param requestedIndex |
| * the index of the terminal view to display |
| */ |
| private void setDisplayedTerminal(int requestedIndex) { |
| synchronized (flip) { |
| try { |
| // show the requested bridge if found, also fade out overlay |
| flip.setDisplayedChild(requestedIndex); |
| flip.getCurrentView().findViewById(R.id.terminal_overlay).startAnimation(fade_out_delayed); |
| } catch (NullPointerException npe) { |
| Log.d("View went away when we were about to display it", npe); |
| } |
| updatePromptVisible(); |
| } |
| } |
| } |
