Exemplo n.º 1
0
  @Override
  public boolean OnVerifiyCertificate(String subject, String issuer, String fingerprint) {

    // see if global settings says accept all
    if (GlobalSettings.getAcceptAllCertificates()) return true;

    // this is where the return code of our dialog will be stored
    callbackDialogResult = false;

    // set message
    String msg = getResources().getString(R.string.dlg_msg_verify_certificate);
    msg = msg + "\n\nSubject: " + subject + "\nIssuer: " + issuer + "\nFingerprint: " + fingerprint;
    dlgVerifyCertificate.setMessage(msg);

    // start dialog in UI thread
    uiHandler.sendMessage(Message.obtain(null, UIHandler.SHOW_DIALOG, dlgVerifyCertificate));

    // wait for result
    try {
      synchronized (dlgVerifyCertificate) {
        dlgVerifyCertificate.wait();
      }
    } catch (InterruptedException e) {
    }

    return callbackDialogResult;
  }
Exemplo n.º 2
0
 @Override
 public void onScrollChanged(ScrollView2D scrollView, int x, int y, int oldx, int oldy) {
   zoomControls.setIsZoomInEnabled(!sessionView.isAtMaxZoom());
   zoomControls.setIsZoomOutEnabled(!sessionView.isAtMinZoom());
   if (!GlobalSettings.getHideZoomControls() && zoomControls.getVisibility() != View.VISIBLE)
     zoomControls.show();
   resetZoomControlsAutoHideTimeout();
 }
Exemplo n.º 3
0
public class SessionActivity extends Activity
    implements LibFreeRDP.UIEventListener,
        KeyboardView.OnKeyboardActionListener,
        ScrollView2D.ScrollView2DListener,
        KeyboardMapper.KeyProcessingListener,
        SessionView.SessionViewListener,
        TouchPointerView.TouchPointerListener {
  private class UIHandler extends Handler {

    public static final int REFRESH_SESSIONVIEW = 1;
    public static final int DISPLAY_TOAST = 2;
    public static final int HIDE_ZOOMCONTROLS = 3;
    public static final int SEND_MOVE_EVENT = 4;
    public static final int SHOW_DIALOG = 5;
    public static final int GRAPHICS_CHANGED = 6;
    public static final int SCROLLING_REQUESTED = 7;

    UIHandler() {
      super();
    }

    @Override
    public void handleMessage(Message msg) {
      switch (msg.what) {
        case GRAPHICS_CHANGED:
          {
            sessionView.onSurfaceChange(session);
            scrollView.requestLayout();
            break;
          }
        case REFRESH_SESSIONVIEW:
          {
            sessionView.invalidateRegion();
            break;
          }
        case DISPLAY_TOAST:
          {
            Toast errorToast =
                Toast.makeText(getApplicationContext(), msg.obj.toString(), Toast.LENGTH_LONG);
            errorToast.show();
            break;
          }
        case HIDE_ZOOMCONTROLS:
          {
            zoomControls.hide();
            break;
          }
        case SEND_MOVE_EVENT:
          {
            LibFreeRDP.sendCursorEvent(
                session.getInstance(), msg.arg1, msg.arg2, Mouse.getMoveEvent());
            break;
          }
        case SHOW_DIALOG:
          {
            // create and show the dialog
            ((Dialog) msg.obj).show();
            break;
          }
        case SCROLLING_REQUESTED:
          {
            int scrollX = 0;
            int scrollY = 0;
            float[] pointerPos = touchPointerView.getPointerPosition();

            if (pointerPos[0] > (screen_width - touchPointerView.getPointerWidth()))
              scrollX = SCROLLING_DISTANCE;
            else if (pointerPos[0] < 0) scrollX = -SCROLLING_DISTANCE;

            if (pointerPos[1] > (screen_height - touchPointerView.getPointerHeight()))
              scrollY = SCROLLING_DISTANCE;
            else if (pointerPos[1] < 0) scrollY = -SCROLLING_DISTANCE;

            scrollView.scrollBy(scrollX, scrollY);

            // see if we reached the min/max scroll positions
            if (scrollView.getScrollX() == 0
                || scrollView.getScrollX() == (sessionView.getWidth() - scrollView.getWidth()))
              scrollX = 0;
            if (scrollView.getScrollY() == 0
                || scrollView.getScrollY() == (sessionView.getHeight() - scrollView.getHeight()))
              scrollY = 0;

            if (scrollX != 0 || scrollY != 0)
              uiHandler.sendEmptyMessageDelayed(SCROLLING_REQUESTED, SCROLLING_TIMEOUT);
            else Log.v(TAG, "Stopping auto-scroll");
            break;
          }
      }
    }
  }

  private class PinchZoomListener extends ScaleGestureDetector.SimpleOnScaleGestureListener {
    private float scaleFactor = 1.0f;

    @Override
    public boolean onScaleBegin(ScaleGestureDetector detector) {
      scrollView.setScrollEnabled(false);
      return true;
    }

    @Override
    public boolean onScale(ScaleGestureDetector detector) {

      // calc scale factor
      scaleFactor *= detector.getScaleFactor();
      scaleFactor =
          Math.max(
              SessionView.MIN_SCALE_FACTOR, Math.min(scaleFactor, SessionView.MAX_SCALE_FACTOR));
      sessionView.setZoom(scaleFactor);

      if (!sessionView.isAtMinZoom() && !sessionView.isAtMaxZoom()) {
        // transform scroll origin to the new zoom space
        float transOriginX = scrollView.getScrollX() * detector.getScaleFactor();
        float transOriginY = scrollView.getScrollY() * detector.getScaleFactor();

        // transform center point to the zoomed space
        float transCenterX =
            (scrollView.getScrollX() + detector.getFocusX()) * detector.getScaleFactor();
        float transCenterY =
            (scrollView.getScrollY() + detector.getFocusY()) * detector.getScaleFactor();

        // scroll by the difference between the distance of the transformed center/origin point and
        // their old distance (focusX/Y)
        scrollView.scrollBy(
            (int) ((transCenterX - transOriginX) - detector.getFocusX()),
            (int) ((transCenterY - transOriginY) - detector.getFocusY()));
      }

      return true;
    }

    @Override
    public void onScaleEnd(ScaleGestureDetector de) {
      scrollView.setScrollEnabled(true);
    }
  }

  private class LibFreeRDPBroadcastReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
      // still got a valid session?
      if (session == null) return;

      // is this event for the current session?
      if (session.getInstance() != intent.getExtras().getInt(GlobalApp.EVENT_PARAM, -1)) return;

      switch (intent.getExtras().getInt(GlobalApp.EVENT_TYPE, -1)) {
        case GlobalApp.FREERDP_EVENT_CONNECTION_SUCCESS:
          OnConnectionSuccess(context);
          break;

        case GlobalApp.FREERDP_EVENT_CONNECTION_FAILURE:
          OnConnectionFailure(context);
          break;
        case GlobalApp.FREERDP_EVENT_DISCONNECTED:
          OnDisconnected(context);
          break;
      }
    }

    private void OnConnectionSuccess(Context context) {
      Log.v(TAG, "OnConnectionSuccess");

      // bind session
      bindSession();

      if (progressDialog != null) {
        progressDialog.dismiss();
        progressDialog = null;
      }

      // add hostname to history if quick connect was used
      Bundle bundle = getIntent().getExtras();
      if (bundle != null && bundle.containsKey(PARAM_CONNECTION_REFERENCE)) {
        if (ConnectionReference.isHostnameReference(bundle.getString(PARAM_CONNECTION_REFERENCE))) {
          assert session.getBookmark().getType() == BookmarkBase.TYPE_MANUAL;
          String item = session.getBookmark().<ManualBookmark>get().getHostname();
          if (!GlobalApp.getQuickConnectHistoryGateway().historyItemExists(item))
            GlobalApp.getQuickConnectHistoryGateway().addHistoryItem(item);
        }
      }
    }

    private void OnConnectionFailure(Context context) {
      Log.v(TAG, "OnConnectionFailure");

      if (progressDialog != null) {
        progressDialog.dismiss();
        progressDialog = null;
      }

      // post error message on UI thread
      if (!connectCancelledByUser)
        uiHandler.sendMessage(
            Message.obtain(
                null,
                UIHandler.DISPLAY_TOAST,
                getResources().getText(R.string.error_connection_failure)));

      closeSessionActivity(RESULT_CANCELED);
    }

    private void OnDisconnected(Context context) {
      Log.v(TAG, "OnDisconnected");

      if (progressDialog != null) {
        progressDialog.dismiss();
        progressDialog = null;
      }

      session.setUIEventListener(null);
      closeSessionActivity(RESULT_OK);
    }
  }

  public static final String PARAM_CONNECTION_REFERENCE = "conRef";
  public static final String PARAM_INSTANCE = "instance";

  private static final float ZOOMING_STEP = 0.5f;
  private static final int ZOOMCONTROLS_AUTOHIDE_TIMEOUT = 4000;

  // timeout between subsequent scrolling requests when the touch-pointer is at the edge of the
  // session view
  private static final int SCROLLING_TIMEOUT = 50;
  private static final int SCROLLING_DISTANCE = 20;

  private Bitmap bitmap;
  private SessionState session;
  private SessionView sessionView;
  private TouchPointerView touchPointerView;
  private ProgressDialog progressDialog;
  private KeyboardView keyboardView;
  private KeyboardView modifiersKeyboardView;
  private ZoomControls zoomControls;
  private KeyboardMapper keyboardMapper;

  private Keyboard specialkeysKeyboard;
  private Keyboard numpadKeyboard;
  private Keyboard cursorKeyboard;
  private Keyboard modifiersKeyboard;

  private AlertDialog dlgVerifyCertificate;
  private AlertDialog dlgUserCredentials;
  private View userCredView;

  private UIHandler uiHandler;

  private int screen_width;
  private int screen_height;

  private boolean autoScrollTouchPointer = GlobalSettings.getAutoScrollTouchPointer();
  private boolean connectCancelledByUser = false;
  private boolean sessionRunning = false;
  private boolean toggleMouseButtons = false;

  private LibFreeRDPBroadcastReceiver libFreeRDPBroadcastReceiver;

  private static final String TAG = "FreeRDP.SessionActivity";

  private ScrollView2D scrollView;

  // keyboard visibility flags
  private boolean sysKeyboardVisible = false;
  private boolean extKeyboardVisible = false;

  // variables for delayed move event sending
  private static final int MAX_DISCARDED_MOVE_EVENTS = 3;
  private static final int SEND_MOVE_EVENT_TIMEOUT = 150;
  private int discardedMoveEvents = 0;

  private void createDialogs() {
    // build verify certificate dialog
    dlgVerifyCertificate =
        new AlertDialog.Builder(this)
            .setTitle(R.string.dlg_title_verify_certificate)
            .setPositiveButton(
                android.R.string.yes,
                new DialogInterface.OnClickListener() {
                  @Override
                  public void onClick(DialogInterface dialog, int which) {
                    callbackDialogResult = true;
                    synchronized (dialog) {
                      dialog.notify();
                    }
                  }
                })
            .setNegativeButton(
                android.R.string.no,
                new DialogInterface.OnClickListener() {
                  @Override
                  public void onClick(DialogInterface dialog, int which) {
                    callbackDialogResult = false;
                    connectCancelledByUser = true;
                    synchronized (dialog) {
                      dialog.notify();
                    }
                  }
                })
            .setCancelable(false)
            .create();

    // build the dialog
    userCredView = getLayoutInflater().inflate(R.layout.credentials, null, true);
    dlgUserCredentials =
        new AlertDialog.Builder(this)
            .setView(userCredView)
            .setTitle(R.string.dlg_title_credentials)
            .setPositiveButton(
                android.R.string.ok,
                new DialogInterface.OnClickListener() {
                  @Override
                  public void onClick(DialogInterface dialog, int which) {
                    callbackDialogResult = true;
                    synchronized (dialog) {
                      dialog.notify();
                    }
                  }
                })
            .setNegativeButton(
                android.R.string.cancel,
                new DialogInterface.OnClickListener() {
                  @Override
                  public void onClick(DialogInterface dialog, int which) {
                    callbackDialogResult = false;
                    connectCancelledByUser = true;
                    synchronized (dialog) {
                      dialog.notify();
                    }
                  }
                })
            .setCancelable(false)
            .create();
  }

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // show status bar or make fullscreen?
    if (GlobalSettings.getHideStatusBar())
      getWindow()
          .setFlags(
              WindowManager.LayoutParams.FLAG_FULLSCREEN,
              WindowManager.LayoutParams.FLAG_FULLSCREEN);
    this.setContentView(R.layout.session);

    Log.v(TAG, "Session.onCreate");

    // ATTENTION: We use the onGlobalLayout notification to start our session.
    // This is because only then we can know the exact size of our session when using fit screen
    // accounting for any status bars etc. that Android might throws on us. A bit weird looking
    // but this is the only way ...
    final View activityRootView = findViewById(R.id.session_root_view);
    activityRootView
        .getViewTreeObserver()
        .addOnGlobalLayoutListener(
            new OnGlobalLayoutListener() {
              @Override
              public void onGlobalLayout() {
                screen_width = activityRootView.getWidth();
                screen_height = activityRootView.getHeight();

                // start session
                if (!sessionRunning && getIntent() != null) {
                  processIntent(getIntent());
                  sessionRunning = true;
                }
              }
            });

    sessionView = (SessionView) findViewById(R.id.sessionView);
    sessionView.setScaleGestureDetector(new ScaleGestureDetector(this, new PinchZoomListener()));
    sessionView.setSessionViewListener(this);
    sessionView.requestFocus();

    touchPointerView = (TouchPointerView) findViewById(R.id.touchPointerView);
    touchPointerView.setTouchPointerListener(this);

    keyboardMapper = new KeyboardMapper();
    keyboardMapper.init(this);

    modifiersKeyboard = new Keyboard(getApplicationContext(), R.xml.modifiers_keyboard);
    specialkeysKeyboard = new Keyboard(getApplicationContext(), R.xml.specialkeys_keyboard);
    numpadKeyboard = new Keyboard(getApplicationContext(), R.xml.numpad_keyboard);
    cursorKeyboard = new Keyboard(getApplicationContext(), R.xml.cursor_keyboard);

    // hide keyboard below the sessionView
    keyboardView = (KeyboardView) findViewById(R.id.extended_keyboard);
    keyboardView.setKeyboard(specialkeysKeyboard);
    keyboardView.setOnKeyboardActionListener(this);

    modifiersKeyboardView = (KeyboardView) findViewById(R.id.extended_keyboard_header);
    modifiersKeyboardView.setKeyboard(modifiersKeyboard);
    modifiersKeyboardView.setOnKeyboardActionListener(this);

    scrollView = (ScrollView2D) findViewById(R.id.sessionScrollView);
    scrollView.setScrollViewListener(this);
    uiHandler = new UIHandler();
    libFreeRDPBroadcastReceiver = new LibFreeRDPBroadcastReceiver();

    zoomControls = (ZoomControls) findViewById(R.id.zoomControls);
    zoomControls.hide();
    zoomControls.setOnZoomInClickListener(
        new View.OnClickListener() {
          @Override
          public void onClick(View v) {
            resetZoomControlsAutoHideTimeout();
            zoomControls.setIsZoomInEnabled(sessionView.zoomIn(ZOOMING_STEP));
            zoomControls.setIsZoomOutEnabled(true);
          }
        });
    zoomControls.setOnZoomOutClickListener(
        new View.OnClickListener() {
          @Override
          public void onClick(View v) {
            resetZoomControlsAutoHideTimeout();
            zoomControls.setIsZoomOutEnabled(sessionView.zoomOut(ZOOMING_STEP));
            zoomControls.setIsZoomInEnabled(true);
          }
        });

    toggleMouseButtons = false;

    createDialogs();

    // register freerdp events broadcast receiver
    IntentFilter filter = new IntentFilter();
    filter.addAction(GlobalApp.ACTION_EVENT_FREERDP);
    registerReceiver(libFreeRDPBroadcastReceiver, filter);
  }

  @Override
  protected void onStart() {
    super.onStart();
    Log.v(TAG, "Session.onStart");
  }

  @Override
  protected void onRestart() {
    super.onRestart();
    Log.v(TAG, "Session.onRestart");
  }

  @Override
  protected void onResume() {
    super.onResume();
    Log.v(TAG, "Session.onResume");
  }

  @Override
  protected void onPause() {
    super.onPause();
    Log.v(TAG, "Session.onPause");

    // hide any visible keyboards
    showKeyboard(false, false);
  }

  @Override
  protected void onStop() {
    super.onStop();
    Log.v(TAG, "Session.onStop");
  }

  @Override
  protected void onDestroy() {
    super.onDestroy();
    Log.v(TAG, "Session.onDestroy");

    // unregister freerdp events broadcast receiver
    unregisterReceiver(libFreeRDPBroadcastReceiver);

    // free session
    GlobalApp.freeSession(session.getInstance());
    session = null;
  }

  @Override
  public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);

    // reload keyboard resources (changed from landscape)
    modifiersKeyboard = new Keyboard(getApplicationContext(), R.xml.modifiers_keyboard);
    specialkeysKeyboard = new Keyboard(getApplicationContext(), R.xml.specialkeys_keyboard);
    numpadKeyboard = new Keyboard(getApplicationContext(), R.xml.numpad_keyboard);
    cursorKeyboard = new Keyboard(getApplicationContext(), R.xml.cursor_keyboard);

    // apply loaded keyboards
    keyboardView.setKeyboard(specialkeysKeyboard);
    modifiersKeyboardView.setKeyboard(modifiersKeyboard);
  }

  private void processIntent(Intent intent) {
    // get either session instance or create one from a bookmark
    Bundle bundle = intent.getExtras();
    if (bundle.containsKey(PARAM_INSTANCE)) {
      int inst = bundle.getInt(PARAM_INSTANCE);
      session = GlobalApp.getSession(inst);
      bitmap = session.getSurface().getBitmap();
      bindSession();
    } else if (bundle.containsKey(PARAM_CONNECTION_REFERENCE)) {
      BookmarkBase bookmark = null;
      String refStr = bundle.getString(PARAM_CONNECTION_REFERENCE);
      if (ConnectionReference.isHostnameReference(refStr)) {
        bookmark = new ManualBookmark();
        bookmark.<ManualBookmark>get().setHostname(ConnectionReference.getHostname(refStr));
      } else if (ConnectionReference.isBookmarkReference(refStr)) {
        if (ConnectionReference.isManualBookmarkReference(refStr))
          bookmark =
              GlobalApp.getManualBookmarkGateway()
                  .findById(ConnectionReference.getManualBookmarkId(refStr));
        else assert false;
      }

      if (bookmark != null) connect(bookmark);
      else closeSessionActivity(RESULT_CANCELED);
    } else {
      // no session found - exit
      closeSessionActivity(RESULT_CANCELED);
    }
  }

  private void connect(BookmarkBase bookmark) {
    session = GlobalApp.createSession(bookmark);
    session.setUIEventListener(this);

    // set writeable data directory
    LibFreeRDP.setDataDirectory(session.getInstance(), getFilesDir().toString());

    BookmarkBase.ScreenSettings screenSettings = session.getBookmark().getActiveScreenSettings();
    Log.v(TAG, "Screen Resolution: " + screenSettings.getResolutionString());
    if (screenSettings.isAutomatic()) {
      if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK)
          >= Configuration.SCREENLAYOUT_SIZE_LARGE) {
        // large screen device i.e. tablet: simply use screen info
        screenSettings.setHeight(screen_height);
        screenSettings.setWidth(screen_width);
      } else {
        // small screen device i.e. phone:
        // Automatic uses the largest side length of the screen and makes a 16:10 resolution setting
        // out of it
        int screenMax = (screen_width > screen_height) ? screen_width : screen_height;
        screenSettings.setHeight(screenMax);
        screenSettings.setWidth((int) ((float) screenMax * 1.6f));
      }
    }

    progressDialog = new ProgressDialog(this);
    progressDialog.setTitle(bookmark.getLabel());
    progressDialog.setMessage(getResources().getText(R.string.dlg_msg_connecting));
    progressDialog.setButton(
        ProgressDialog.BUTTON_NEGATIVE,
        "Cancel",
        new DialogInterface.OnClickListener() {
          @Override
          public void onClick(DialogInterface dialog, int which) {
            connectCancelledByUser = true;
            LibFreeRDP.cancelConnection(session.getInstance());
          }
        });
    progressDialog.setCancelable(false);
    progressDialog.show();

    Thread thread =
        new Thread(
            new Runnable() {
              public void run() {
                session.connect();
              }
            });
    thread.start();
  }

  // binds the current session to the activity by wiring it up with the sessionView and updating all
  // internal objects accordingly
  private void bindSession() {
    Log.v("SessionActivity", "bindSession called");
    session.setUIEventListener(this);
    sessionView.onSurfaceChange(session);
    scrollView.requestLayout();
    keyboardMapper.reset(this);
  }

  // displays either the system or the extended keyboard or non of  them
  private void showKeyboard(boolean showSystemKeyboard, boolean showExtendedKeyboard) {
    // no matter what we are doing ... hide the zoom controls
    // TODO: this is not working correctly as hiding the keyboard issues a onScrollChange
    // notification showing the control again ...
    uiHandler.removeMessages(UIHandler.HIDE_ZOOMCONTROLS);
    if (zoomControls.getVisibility() == View.VISIBLE) zoomControls.hide();

    InputMethodManager mgr;
    if (showSystemKeyboard) {
      // hide extended keyboard
      keyboardView.setVisibility(View.GONE);

      // show system keyboard
      mgr = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
      if (!mgr.isActive(sessionView))
        Log.e(TAG, "Failed to show system keyboard: SessionView is not the active view!");
      mgr.showSoftInput(sessionView, 0);

      // show modifiers keyboard
      modifiersKeyboardView.setVisibility(View.VISIBLE);
    } else if (showExtendedKeyboard) {
      // hide system keyboard
      mgr = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
      mgr.hideSoftInputFromWindow(sessionView.getWindowToken(), 0);

      // show extended keyboard
      keyboardView.setKeyboard(specialkeysKeyboard);
      keyboardView.setVisibility(View.VISIBLE);
      modifiersKeyboardView.setVisibility(View.VISIBLE);
    } else {
      // hide both
      mgr = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
      mgr.hideSoftInputFromWindow(sessionView.getWindowToken(), 0);
      keyboardView.setVisibility(View.GONE);
      modifiersKeyboardView.setVisibility(View.GONE);

      // clear any active key modifiers)
      keyboardMapper.clearlAllModifiers();
    }

    sysKeyboardVisible = showSystemKeyboard;
    extKeyboardVisible = showExtendedKeyboard;
  }

  private void closeSessionActivity(int resultCode) {
    // Go back to home activity (and send intent data back to home)
    setResult(resultCode, getIntent());
    finish();
  }

  // update the state of our modifier keys
  private void updateModifierKeyStates() {
    // check if any key is in the keycodes list

    List<Keyboard.Key> keys = modifiersKeyboard.getKeys();
    for (Iterator<Keyboard.Key> it = keys.iterator(); it.hasNext(); ) {
      // if the key is a sticky key - just set it to off
      Keyboard.Key curKey = it.next();
      if (curKey.sticky) {
        switch (keyboardMapper.getModifierState(curKey.codes[0])) {
          case KeyboardMapper.KEYSTATE_ON:
            curKey.on = true;
            curKey.pressed = false;
            break;

          case KeyboardMapper.KEYSTATE_OFF:
            curKey.on = false;
            curKey.pressed = false;
            break;

          case KeyboardMapper.KEYSTATE_LOCKED:
            curKey.on = true;
            curKey.pressed = true;
            break;
        }
      }
    }

    // refresh image
    modifiersKeyboardView.invalidateAllKeys();
  }

  private void sendDelayedMoveEvent(int x, int y) {
    if (uiHandler.hasMessages(UIHandler.SEND_MOVE_EVENT)) {
      uiHandler.removeMessages(UIHandler.SEND_MOVE_EVENT);
      discardedMoveEvents++;
    } else discardedMoveEvents = 0;

    if (discardedMoveEvents > MAX_DISCARDED_MOVE_EVENTS)
      LibFreeRDP.sendCursorEvent(session.getInstance(), x, y, Mouse.getMoveEvent());
    else
      uiHandler.sendMessageDelayed(
          Message.obtain(null, UIHandler.SEND_MOVE_EVENT, x, y), SEND_MOVE_EVENT_TIMEOUT);
  }

  private void cancelDelayedMoveEvent() {
    uiHandler.removeMessages(UIHandler.SEND_MOVE_EVENT);
  }

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

  @Override
  public boolean onOptionsItemSelected(MenuItem item) {
    // refer to http://tools.android.com/tips/non-constant-fields why we can't use switch/case here
    // ..
    int itemId = item.getItemId();

    if (itemId == R.id.session_touch_pointer) {
      // toggle touch pointer
      if (touchPointerView.getVisibility() == View.VISIBLE) {
        touchPointerView.setVisibility(View.INVISIBLE);
        sessionView.setTouchPointerPadding(0, 0);
      } else {
        touchPointerView.setVisibility(View.VISIBLE);
        sessionView.setTouchPointerPadding(
            touchPointerView.getPointerWidth(), touchPointerView.getPointerHeight());
      }
    } else if (itemId == R.id.session_sys_keyboard) {
      showKeyboard(!sysKeyboardVisible, false);
    } else if (itemId == R.id.session_ext_keyboard) {
      showKeyboard(false, !extKeyboardVisible);
    } else if (itemId == R.id.session_disconnect) {
      showKeyboard(false, false);
      LibFreeRDP.disconnect(session.getInstance());
    }

    return true;
  }

  @Override
  public void onBackPressed() {
    // hide keyboards (if any visible) or send alt+f4 to the session
    if (sysKeyboardVisible || extKeyboardVisible) showKeyboard(false, false);
    else keyboardMapper.sendAltF4();
  }

  // android keyboard input handling
  // We always use the unicode value to process input from the android keyboard except if key
  // modifiers
  // (like Win, Alt, Ctrl) are activated. In this case we will send the virtual key code to allow
  // key
  // combinations (like Win + E to open the explorer).
  @Override
  public boolean onKeyDown(int keycode, KeyEvent event) {
    return keyboardMapper.processAndroidKeyEvent(event);
  }

  @Override
  public boolean onKeyUp(int keycode, KeyEvent event) {
    return keyboardMapper.processAndroidKeyEvent(event);
  }

  // onKeyMultiple is called for input of some special characters like umlauts and some symbol
  // characters
  @Override
  public boolean onKeyMultiple(int keyCode, int repeatCount, KeyEvent event) {
    return keyboardMapper.processAndroidKeyEvent(event);
  }

  // ****************************************************************************
  // KeyboardView.KeyboardActionEventListener
  @Override
  public void onKey(int primaryCode, int[] keyCodes) {
    keyboardMapper.processCustomKeyEvent(primaryCode);
  }

  @Override
  public void onText(CharSequence text) {}

  @Override
  public void swipeRight() {}

  @Override
  public void swipeLeft() {}

  @Override
  public void swipeDown() {}

  @Override
  public void swipeUp() {}

  @Override
  public void onPress(int primaryCode) {}

  @Override
  public void onRelease(int primaryCode) {}

  // ****************************************************************************
  // KeyboardMapper.KeyProcessingListener implementation
  @Override
  public void processVirtualKey(int virtualKeyCode, boolean down) {
    LibFreeRDP.sendKeyEvent(session.getInstance(), virtualKeyCode, down);
  }

  @Override
  public void processUnicodeKey(int unicodeKey) {
    LibFreeRDP.sendUnicodeKeyEvent(session.getInstance(), unicodeKey);
  }

  @Override
  public void switchKeyboard(int keyboardType) {
    switch (keyboardType) {
      case KeyboardMapper.KEYBOARD_TYPE_FUNCTIONKEYS:
        keyboardView.setKeyboard(specialkeysKeyboard);
        break;

      case KeyboardMapper.KEYBOARD_TYPE_NUMPAD:
        keyboardView.setKeyboard(numpadKeyboard);
        break;

      case KeyboardMapper.KEYBOARD_TYPE_CURSOR:
        keyboardView.setKeyboard(cursorKeyboard);
        break;

      default:
        break;
    }
  }

  @Override
  public void modifiersChanged() {
    updateModifierKeyStates();
  }

  // ****************************************************************************
  // LibFreeRDP UI event listener implementation
  @Override
  public void OnSettingsChanged(int width, int height, int bpp) {

    if (bpp > 16) bitmap = Bitmap.createBitmap(width, height, Config.ARGB_8888);
    else bitmap = Bitmap.createBitmap(width, height, Config.RGB_565);

    session.setSurface(new BitmapDrawable(bitmap));

    // check this settings and initial settings - if they are not equal the server doesn't support
    // our settings
    // FIXME: the additional check (settings.getWidth() != width + 1) is for the RDVH bug fix to
    // avoid accidental notifications
    // (refer to android_freerdp.c for more info on this problem)
    BookmarkBase.ScreenSettings settings = session.getBookmark().getActiveScreenSettings();
    if ((settings.getWidth() != width && settings.getWidth() != width + 1)
        || settings.getHeight() != height
        || settings.getColors() != bpp)
      uiHandler.sendMessage(
          Message.obtain(
              null,
              UIHandler.DISPLAY_TOAST,
              getResources().getText(R.string.info_capabilities_changed)));
  }

  @Override
  public void OnGraphicsUpdate(int x, int y, int width, int height) {
    LibFreeRDP.updateGraphics(session.getInstance(), bitmap, x, y, width, height);

    sessionView.addInvalidRegion(new Rect(x, y, x + width, y + height));

    /* since sessionView can only be modified from the UI thread
     * any modifications to it need to be scheduled */

    uiHandler.sendEmptyMessage(UIHandler.REFRESH_SESSIONVIEW);
  }

  @Override
  public void OnGraphicsResize(int width, int height, int bpp) {
    // replace bitmap
    if (bpp > 16) bitmap = Bitmap.createBitmap(width, height, Config.ARGB_8888);
    else bitmap = Bitmap.createBitmap(width, height, Config.RGB_565);
    session.setSurface(new BitmapDrawable(bitmap));

    /* since sessionView can only be modified from the UI thread
     * any modifications to it need to be scheduled */
    uiHandler.sendEmptyMessage(UIHandler.GRAPHICS_CHANGED);
  }

  private boolean callbackDialogResult;

  @Override
  public boolean OnAuthenticate(
      StringBuilder username, StringBuilder domain, StringBuilder password) {
    // this is where the return code of our dialog will be stored
    callbackDialogResult = false;

    // set text fields
    ((EditText) userCredView.findViewById(R.id.editTextUsername)).setText(username);
    ((EditText) userCredView.findViewById(R.id.editTextDomain)).setText(domain);
    ((EditText) userCredView.findViewById(R.id.editTextPassword)).setText(password);

    // start dialog in UI thread
    uiHandler.sendMessage(Message.obtain(null, UIHandler.SHOW_DIALOG, dlgUserCredentials));

    // wait for result
    try {
      synchronized (dlgUserCredentials) {
        dlgUserCredentials.wait();
      }
    } catch (InterruptedException e) {
    }

    // clear buffers
    username.setLength(0);
    domain.setLength(0);
    password.setLength(0);

    // read back user credentials
    username.append(
        ((EditText) userCredView.findViewById(R.id.editTextUsername)).getText().toString());
    domain.append(((EditText) userCredView.findViewById(R.id.editTextDomain)).getText().toString());
    password.append(
        ((EditText) userCredView.findViewById(R.id.editTextPassword)).getText().toString());

    return callbackDialogResult;
  }

  @Override
  public boolean OnVerifiyCertificate(String subject, String issuer, String fingerprint) {

    // see if global settings says accept all
    if (GlobalSettings.getAcceptAllCertificates()) return true;

    // this is where the return code of our dialog will be stored
    callbackDialogResult = false;

    // set message
    String msg = getResources().getString(R.string.dlg_msg_verify_certificate);
    msg = msg + "\n\nSubject: " + subject + "\nIssuer: " + issuer + "\nFingerprint: " + fingerprint;
    dlgVerifyCertificate.setMessage(msg);

    // start dialog in UI thread
    uiHandler.sendMessage(Message.obtain(null, UIHandler.SHOW_DIALOG, dlgVerifyCertificate));

    // wait for result
    try {
      synchronized (dlgVerifyCertificate) {
        dlgVerifyCertificate.wait();
      }
    } catch (InterruptedException e) {
    }

    return callbackDialogResult;
  }

  // ****************************************************************************
  // ScrollView2DListener implementation
  private void resetZoomControlsAutoHideTimeout() {
    uiHandler.removeMessages(UIHandler.HIDE_ZOOMCONTROLS);
    uiHandler.sendEmptyMessageDelayed(UIHandler.HIDE_ZOOMCONTROLS, ZOOMCONTROLS_AUTOHIDE_TIMEOUT);
  }

  @Override
  public void onScrollChanged(ScrollView2D scrollView, int x, int y, int oldx, int oldy) {
    zoomControls.setIsZoomInEnabled(!sessionView.isAtMaxZoom());
    zoomControls.setIsZoomOutEnabled(!sessionView.isAtMinZoom());
    if (!GlobalSettings.getHideZoomControls() && zoomControls.getVisibility() != View.VISIBLE)
      zoomControls.show();
    resetZoomControlsAutoHideTimeout();
  }

  // ****************************************************************************
  // SessionView.SessionViewListener
  @Override
  public void onSessionViewBeginTouch() {
    scrollView.setScrollEnabled(false);
  }

  @Override
  public void onSessionViewEndTouch() {
    scrollView.setScrollEnabled(true);
  }

  @Override
  public void onSessionViewLeftTouch(int x, int y, boolean down) {
    if (!down) cancelDelayedMoveEvent();

    LibFreeRDP.sendCursorEvent(
        session.getInstance(),
        x,
        y,
        toggleMouseButtons ? Mouse.getRightButtonEvent(down) : Mouse.getLeftButtonEvent(down));

    if (!down) toggleMouseButtons = false;
  }

  public void onSessionViewRightTouch(int x, int y, boolean down) {
    if (!down) toggleMouseButtons = !toggleMouseButtons;
  }

  @Override
  public void onSessionViewMove(int x, int y) {
    sendDelayedMoveEvent(x, y);
  }

  @Override
  public void onSessionViewScroll(boolean down) {
    LibFreeRDP.sendCursorEvent(session.getInstance(), 0, 0, Mouse.getScrollEvent(down));
  }

  // ****************************************************************************
  // TouchPointerView.TouchPointerListener
  @Override
  public void onTouchPointerClose() {
    touchPointerView.setVisibility(View.INVISIBLE);
    sessionView.setTouchPointerPadding(0, 0);
  }

  private Point mapScreenCoordToSessionCoord(int x, int y) {
    int mappedX = (int) ((float) (x + scrollView.getScrollX()) / sessionView.getZoom());
    int mappedY = (int) ((float) (y + scrollView.getScrollY()) / sessionView.getZoom());
    if (mappedX > bitmap.getWidth()) mappedX = bitmap.getWidth();
    if (mappedY > bitmap.getHeight()) mappedY = bitmap.getHeight();
    return new Point(mappedX, mappedY);
  }

  @Override
  public void onTouchPointerLeftClick(int x, int y, boolean down) {
    Point p = mapScreenCoordToSessionCoord(x, y);
    LibFreeRDP.sendCursorEvent(session.getInstance(), p.x, p.y, Mouse.getLeftButtonEvent(down));
  }

  @Override
  public void onTouchPointerRightClick(int x, int y, boolean down) {
    Point p = mapScreenCoordToSessionCoord(x, y);
    LibFreeRDP.sendCursorEvent(session.getInstance(), p.x, p.y, Mouse.getRightButtonEvent(down));
  }

  @Override
  public void onTouchPointerMove(int x, int y) {
    Point p = mapScreenCoordToSessionCoord(x, y);
    LibFreeRDP.sendCursorEvent(session.getInstance(), p.x, p.y, Mouse.getMoveEvent());

    if (autoScrollTouchPointer && !uiHandler.hasMessages(UIHandler.SCROLLING_REQUESTED)) {
      Log.v(TAG, "Starting auto-scroll");
      uiHandler.sendEmptyMessageDelayed(UIHandler.SCROLLING_REQUESTED, SCROLLING_TIMEOUT);
    }
  }

  @Override
  public void onTouchPointerScroll(boolean down) {
    LibFreeRDP.sendCursorEvent(session.getInstance(), 0, 0, Mouse.getScrollEvent(down));
  }

  @Override
  public void onTouchPointerToggleKeyboard() {
    showKeyboard(!sysKeyboardVisible, false);
  }

  @Override
  public void onTouchPointerToggleExtKeyboard() {
    showKeyboard(false, !extKeyboardVisible);
  }

  @Override
  public void onTouchPointerResetScrollZoom() {
    sessionView.setZoom(1.0f);
    scrollView.scrollTo(0, 0);
  }
}
Exemplo n.º 4
0
  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // show status bar or make fullscreen?
    if (GlobalSettings.getHideStatusBar())
      getWindow()
          .setFlags(
              WindowManager.LayoutParams.FLAG_FULLSCREEN,
              WindowManager.LayoutParams.FLAG_FULLSCREEN);
    this.setContentView(R.layout.session);

    Log.v(TAG, "Session.onCreate");

    // ATTENTION: We use the onGlobalLayout notification to start our session.
    // This is because only then we can know the exact size of our session when using fit screen
    // accounting for any status bars etc. that Android might throws on us. A bit weird looking
    // but this is the only way ...
    final View activityRootView = findViewById(R.id.session_root_view);
    activityRootView
        .getViewTreeObserver()
        .addOnGlobalLayoutListener(
            new OnGlobalLayoutListener() {
              @Override
              public void onGlobalLayout() {
                screen_width = activityRootView.getWidth();
                screen_height = activityRootView.getHeight();

                // start session
                if (!sessionRunning && getIntent() != null) {
                  processIntent(getIntent());
                  sessionRunning = true;
                }
              }
            });

    sessionView = (SessionView) findViewById(R.id.sessionView);
    sessionView.setScaleGestureDetector(new ScaleGestureDetector(this, new PinchZoomListener()));
    sessionView.setSessionViewListener(this);
    sessionView.requestFocus();

    touchPointerView = (TouchPointerView) findViewById(R.id.touchPointerView);
    touchPointerView.setTouchPointerListener(this);

    keyboardMapper = new KeyboardMapper();
    keyboardMapper.init(this);

    modifiersKeyboard = new Keyboard(getApplicationContext(), R.xml.modifiers_keyboard);
    specialkeysKeyboard = new Keyboard(getApplicationContext(), R.xml.specialkeys_keyboard);
    numpadKeyboard = new Keyboard(getApplicationContext(), R.xml.numpad_keyboard);
    cursorKeyboard = new Keyboard(getApplicationContext(), R.xml.cursor_keyboard);

    // hide keyboard below the sessionView
    keyboardView = (KeyboardView) findViewById(R.id.extended_keyboard);
    keyboardView.setKeyboard(specialkeysKeyboard);
    keyboardView.setOnKeyboardActionListener(this);

    modifiersKeyboardView = (KeyboardView) findViewById(R.id.extended_keyboard_header);
    modifiersKeyboardView.setKeyboard(modifiersKeyboard);
    modifiersKeyboardView.setOnKeyboardActionListener(this);

    scrollView = (ScrollView2D) findViewById(R.id.sessionScrollView);
    scrollView.setScrollViewListener(this);
    uiHandler = new UIHandler();
    libFreeRDPBroadcastReceiver = new LibFreeRDPBroadcastReceiver();

    zoomControls = (ZoomControls) findViewById(R.id.zoomControls);
    zoomControls.hide();
    zoomControls.setOnZoomInClickListener(
        new View.OnClickListener() {
          @Override
          public void onClick(View v) {
            resetZoomControlsAutoHideTimeout();
            zoomControls.setIsZoomInEnabled(sessionView.zoomIn(ZOOMING_STEP));
            zoomControls.setIsZoomOutEnabled(true);
          }
        });
    zoomControls.setOnZoomOutClickListener(
        new View.OnClickListener() {
          @Override
          public void onClick(View v) {
            resetZoomControlsAutoHideTimeout();
            zoomControls.setIsZoomOutEnabled(sessionView.zoomOut(ZOOMING_STEP));
            zoomControls.setIsZoomInEnabled(true);
          }
        });

    toggleMouseButtons = false;

    createDialogs();

    // register freerdp events broadcast receiver
    IntentFilter filter = new IntentFilter();
    filter.addAction(GlobalApp.ACTION_EVENT_FREERDP);
    registerReceiver(libFreeRDPBroadcastReceiver, filter);
  }