/*
  * For some reason, it's very difficult to create a layout that covers exactly the entire screen
  * and doesn't move when an unhandled key is pressed. The configuration we're using seems to
  * result in a layout that starts above the screen. So we split initialization into two
  * pieces, and here we find out where the overlay ended up and move it to be at the top
  * of the screen.
  * TODO(pweaver) Separating the menu and highlighting should be a cleaner way to solve this
  * issue
  */
 private void configureOverlayAfterShow() {
   int[] location = new int[2];
   mRelativeLayout.getLocationOnScreen(location);
   WindowManager.LayoutParams layoutParams = mOverlay.getParams();
   layoutParams.y -= location[1];
   mOverlay.setParams(layoutParams);
 }
 /** @param overlay The overlay on which to draw focus indications */
 public OverlayController(SimpleOverlay overlay) {
   mOverlay = overlay;
   mOverlay.setContentView(com.mpfa.empf.R.layout.switch_access_overlay_layout);
   mRelativeLayout =
       (RelativeLayout) mOverlay.findViewById(com.mpfa.empf.R.id.overlayRelativeLayout);
   IntentFilter filter = new IntentFilter();
   filter.addAction(Intent.ACTION_CONFIGURATION_CHANGED);
   mOverlay.getContext().registerReceiver(mBroadcastReceiver, filter);
 }
 /**
  * @return If option scanning is enabled, gets the location of the menu at the top of the screen.
  *     Otherwise null is returned.
  */
 public Rect getMenuButtonLocation() {
   Button menuButton = (Button) mOverlay.findViewById(com.mpfa.empf.R.id.top_screen_menu_button);
   if (menuButton != null) {
     Rect locationOnScreen = new Rect();
     menuButton.getGlobalVisibleRect(locationOnScreen);
     return locationOnScreen;
   }
   return null;
 }
 /**
  * When option scanning is enabled, a menu button is drawn at the top of the screen. This button
  * offers the user the possibility of clearing the focus or choosing global actions (i.e Home,
  * Back, Notifications, etc).
  */
 public void drawMenuButton() {
   Context context = mOverlay.getContext();
   LayoutInflater layoutInflater =
       (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
   LinearLayout menuButtonLayout =
       (LinearLayout)
           layoutInflater.inflate(
               com.mpfa.empf.R.layout.switch_access_global_menu_button, mRelativeLayout, false);
   addViewAndShow(menuButtonLayout);
 }
  private void configureOverlayBeforeShow() {
    // The overlay shouldn't capture touch events
    final WindowManager.LayoutParams params = mOverlay.getParams();
    params.type = WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY;
    params.flags |= WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
    params.flags |= WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS;

    /* The overlay covers the entire screen. However, there is a left, top, right, and
     * bottom margin.  */
    final WindowManager wm =
        (WindowManager) mOverlay.getContext().getSystemService(Context.WINDOW_SERVICE);
    final Point size = new Point();
    wm.getDefaultDisplay().getRealSize(size);
    params.height = size.y;
    params.width = size.x;
    params.x = 0;
    params.y = 0;

    mOverlay.setParams(params);
  }
 /**
  * Get the overlay ready to show. This method displays an empty overlay and tweaks it to make sure
  * it's in the right location.
  */
 public void configureOverlay() {
   configureOverlayBeforeShow();
   mOverlay.show();
   new Handler()
       .post(
           new Runnable() {
             @Override
             public void run() {
               configureOverlayAfterShow();
             }
           });
 }
  public void highlightPerimeterOfRects(Iterable<Rect> rects, Paint highlightPaint) {
    final Set<Rect> rectsToHighlight = new HashSet<>();
    final Paint finalHighlightPaint = new Paint(highlightPaint);
    for (Rect rect : rects) {
      rectsToHighlight.add(rect);
    }
    mOverlay.show();

    /*
     * Run the rest of the function in a handler to give the thread a chance to draw the
     * overlay.
     */
    new Handler()
        .post(
            new Runnable() {
              @Override
              public void run() {
                int[] layoutCoordinates = new int[2];
                mRelativeLayout.getLocationOnScreen(layoutCoordinates);
                for (Rect rect : rectsToHighlight) {
                  ShapeDrawable mainHighlightDrawable = new ShapeDrawable(new RectShape());
                  mainHighlightDrawable.setIntrinsicWidth(rect.width());
                  mainHighlightDrawable.setIntrinsicHeight(rect.height());
                  mainHighlightDrawable.getPaint().set(finalHighlightPaint);
                  Drawable highlightDrawable = mainHighlightDrawable;
                  if (MAIN_TO_OUTER_HIGHLIGHT_COLOR_MAP.containsKey(
                      finalHighlightPaint.getColor())) {
                    ShapeDrawable outerHighlightDrawable = new ShapeDrawable(new RectShape());
                    outerHighlightDrawable.setIntrinsicWidth(rect.width());
                    outerHighlightDrawable.setIntrinsicHeight(rect.height());
                    Paint outerHighlightPaint = new Paint(finalHighlightPaint);
                    outerHighlightPaint.setColor(
                        MAIN_TO_OUTER_HIGHLIGHT_COLOR_MAP.get(finalHighlightPaint.getColor()));
                    outerHighlightPaint.setStrokeWidth(finalHighlightPaint.getStrokeWidth() / 2);
                    outerHighlightDrawable.getPaint().set(outerHighlightPaint);
                    Drawable[] layers = {mainHighlightDrawable, outerHighlightDrawable};
                    highlightDrawable = new LayerDrawable(layers);
                  }

                  ImageView imageView = new ImageView(mOverlay.getContext());
                  imageView.setBackground(highlightDrawable);

                  // Align image with node we're highlighting
                  final RelativeLayout.LayoutParams layoutParams =
                      new RelativeLayout.LayoutParams(rect.width(), rect.height());
                  layoutParams.leftMargin = rect.left - layoutCoordinates[0];
                  layoutParams.topMargin = rect.top - layoutCoordinates[1];
                  imageView.setLayoutParams(layoutParams);
                  mRelativeLayout.addView(imageView);
                }
              }
            });
  }
 /** Obtain the context for drawing */
 public Context getContext() {
   return mOverlay.getContext();
 }
 /** Shut down nicely */
 public void shutdown() {
   mOverlay.getContext().unregisterReceiver(mBroadcastReceiver);
   mOverlay.hide();
 }
Exemple #10
0
 /** Clear focus highlighting */
 public void clearOverlay() {
   mRelativeLayout.removeAllViews();
   mOverlay.hide();
 }
Exemple #11
0
 /** Override focus highlighting with a custom overlay */
 public void addViewAndShow(View view) {
   mRelativeLayout.addView(view);
   mOverlay.show();
 }