/**
* Disables a port forward member. After calling this method, the port forward should be
* non-functioning.
*
* @param portForward member of our current port forwards list to enable
* @return true on successful port forward tear-down
*/
public boolean disablePortForward(PortForwardBean portForward) {
if (!transport.isConnected()) {
Log.i(TAG, "Attempt to disable port forward while not connected");
return false;
}
return transport.disablePortForward(portForward);
}
/** Spawn thread to open connection and start login process. */
protected void startConnection() {
transport = TransportFactory.getTransport(host.getProtocol());
transport.setBridge(this);
transport.setManager(manager);
transport.setHost(host);
// TODO make this more abstract so we don't litter on AbsTransport
transport.setCompression(host.getCompression());
transport.setUseAuthAgent(host.getUseAuthAgent());
transport.setEmulation(emulation);
if (transport.canForwardPorts()) {
for (PortForwardBean portForward : manager.hostdb.getPortForwardsForHost(host))
transport.addPortForward(portForward);
}
outputLine(
manager.res.getString(
R.string.terminal_connecting, host.getHostname(), host.getPort(), host.getProtocol()));
Thread connectionThread =
new Thread(
new Runnable() {
public void run() {
transport.connect();
}
});
connectionThread.setName("Connection");
connectionThread.setDaemon(true);
connectionThread.start();
}
/**
* Convenience method for writing a line into the underlying MUD buffer. Should never be called
* once the session is established.
*/
public final void outputLine(String line) {
if (transport != null && transport.isSessionOpen())
Log.e(
TAG,
"Session established, cannot use outputLine!",
new IOException("outputLine call traceback"));
synchronized (localOutput) {
final String s = line + "\r\n";
localOutput.add(s);
((vt320) buffer).putString(s);
// For accessibility
final char[] charArray = s.toCharArray();
propagateConsoleText(charArray, charArray.length);
}
}
/** @return */
public boolean isUsingNetwork() {
return transport.usesNetwork();
}
public void onScreenOn() {
transport.onScreenOn();
}
public void onForeground() {
transport.onForeground();
}
public void onBackground() {
transport.onBackground();
}
/** @return the list of port forwards */
public List<PortForwardBean> getPortForwards() {
return transport.getPortForwards();
}
/**
* Removes the {@link PortForwardBean} from the list.
*
* @param portForward the port forward bean to remove
* @return true on successful removal
*/
public boolean removePortForward(PortForwardBean portForward) {
return transport.removePortForward(portForward);
}
/**
* Adds the {@link PortForwardBean} to the list.
*
* @param portForward the port forward bean to add
* @return true on successful addition
*/
public boolean addPortForward(PortForwardBean portForward) {
return transport.addPortForward(portForward);
}
/** @return whether underlying transport can forward ports */
public boolean canFowardPorts() {
return transport.canForwardPorts();
}
/**
* Something changed in our parent {@link TerminalView}, maybe it's a new parent, or maybe it's an
* updated font size. We should recalculate terminal size information and request a PTY resize.
*/
public final synchronized void parentChanged(TerminalView parent) {
if (manager != null && !manager.isResizeAllowed()) {
Log.d(TAG, "Resize is not allowed now");
return;
}
this.parent = parent;
final int width = parent.getWidth();
final int height = parent.getHeight();
// Something has gone wrong with our layout; we're 0 width or height!
if (width <= 0 || height <= 0) return;
clipboard = (ClipboardManager) parent.getContext().getSystemService(Context.CLIPBOARD_SERVICE);
keyListener.setClipboardManager(clipboard);
if (!forcedSize) {
// recalculate buffer size
int newColumns, newRows;
newColumns = width / charWidth;
newRows = height / charHeight;
// If nothing has changed in the terminal dimensions and not an intial
// draw then don't blow away scroll regions and such.
if (newColumns == columns && newRows == rows) return;
columns = newColumns;
rows = newRows;
}
// reallocate new bitmap if needed
boolean newBitmap = (bitmap == null);
if (bitmap != null) newBitmap = (bitmap.getWidth() != width || bitmap.getHeight() != height);
if (newBitmap) {
discardBitmap();
bitmap = Bitmap.createBitmap(width, height, Config.ARGB_8888);
canvas.setBitmap(bitmap);
}
// clear out any old buffer information
defaultPaint.setColor(Color.BLACK);
canvas.drawPaint(defaultPaint);
// Stroke the border of the terminal if the size is being forced;
if (forcedSize) {
int borderX = (columns * charWidth) + 1;
int borderY = (rows * charHeight) + 1;
defaultPaint.setColor(Color.GRAY);
defaultPaint.setStrokeWidth(0.0f);
if (width >= borderX) canvas.drawLine(borderX, 0, borderX, borderY + 1, defaultPaint);
if (height >= borderY) canvas.drawLine(0, borderY, borderX + 1, borderY, defaultPaint);
}
try {
// request a terminal pty resize
synchronized (buffer) {
buffer.setScreenSize(columns, rows, true);
}
if (transport != null) transport.setDimensions(columns, rows, width, height);
} catch (Exception e) {
Log.e(TAG, "Problem while trying to resize screen or PTY", e);
}
// redraw local output if we don't have a sesson to receive our resize request
if (transport == null) {
synchronized (localOutput) {
((vt320) buffer).reset();
for (String line : localOutput) ((vt320) buffer).putString(line);
}
}
// force full redraw with new buffer size
fullRedraw = true;
redraw();
parent.notifyUser(String.format("%d x %d", columns, rows));
Log.i(TAG, String.format("parentChanged() now width=%d, height=%d", columns, rows));
}
/** @return whether a session is open or not */
public boolean isSessionOpen() {
if (transport != null) return transport.isSessionOpen();
return false;
}
