package android.support.v4.widget;

import android.content.Context;
import android.graphics.Rect;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.util.SparseArrayCompat;
import android.support.v4.view.AccessibilityDelegateCompat;
import android.support.v4.view.KeyEventCompat;
import android.support.v4.view.ViewCompat;
import android.support.v4.view.ViewParentCompat;
import android.support.v4.view.accessibility.AccessibilityEventCompat;
import android.support.v4.view.accessibility.AccessibilityManagerCompat;
import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat;
import android.support.v4.view.accessibility.AccessibilityNodeProviderCompat;
import android.support.v4.view.accessibility.AccessibilityRecordCompat;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewParent;
import android.view.accessibility.AccessibilityEvent;
import android.view.accessibility.AccessibilityManager;
import java.util.ArrayList;
import java.util.List;

public abstract class ExploreByTouchHelper
  extends AccessibilityDelegateCompat
{
  public static final int HOST_ID = -1;
  public static final int INVALID_ID = Integer.MIN_VALUE;
  private static final Rect a = new Rect(Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE);
  private static final FocusStrategy.BoundsAdapter<AccessibilityNodeInfoCompat> m = new FocusStrategy.BoundsAdapter() {};
  private static final FocusStrategy.CollectionAdapter<SparseArrayCompat<AccessibilityNodeInfoCompat>, AccessibilityNodeInfoCompat> n = new FocusStrategy.CollectionAdapter() {};
  private final Rect c = new Rect();
  private final Rect d = new Rect();
  private final Rect e = new Rect();
  private final int[] f = new int[2];
  private final AccessibilityManager g;
  private final View h;
  private a i;
  private int j = Integer.MIN_VALUE;
  private int k = Integer.MIN_VALUE;
  private int l = Integer.MIN_VALUE;
  
  public ExploreByTouchHelper(View paramView)
  {
    if (paramView == null) {
      throw new IllegalArgumentException("View may not be null");
    }
    this.h = paramView;
    this.g = ((AccessibilityManager)paramView.getContext().getSystemService("accessibility"));
    paramView.setFocusable(true);
    if (ViewCompat.getImportantForAccessibility(paramView) == 0) {
      ViewCompat.setImportantForAccessibility(paramView, 1);
    }
  }
  
  private AccessibilityEvent a(int paramInt1, int paramInt2)
  {
    AccessibilityEvent localAccessibilityEvent;
    AccessibilityRecordCompat localAccessibilityRecordCompat;
    AccessibilityNodeInfoCompat localAccessibilityNodeInfoCompat;
    switch (paramInt1)
    {
    default: 
      localAccessibilityEvent = AccessibilityEvent.obtain(paramInt2);
      localAccessibilityRecordCompat = AccessibilityEventCompat.asRecord(localAccessibilityEvent);
      localAccessibilityNodeInfoCompat = a(paramInt1);
      localAccessibilityRecordCompat.getText().add(localAccessibilityNodeInfoCompat.getText());
      localAccessibilityRecordCompat.setContentDescription(localAccessibilityNodeInfoCompat.getContentDescription());
      localAccessibilityRecordCompat.setScrollable(localAccessibilityNodeInfoCompat.isScrollable());
      localAccessibilityRecordCompat.setPassword(localAccessibilityNodeInfoCompat.isPassword());
      localAccessibilityRecordCompat.setEnabled(localAccessibilityNodeInfoCompat.isEnabled());
      localAccessibilityRecordCompat.setChecked(localAccessibilityNodeInfoCompat.isChecked());
      onPopulateEventForVirtualView(paramInt1, localAccessibilityEvent);
      if ((localAccessibilityEvent.getText().isEmpty()) && (localAccessibilityEvent.getContentDescription() == null)) {
        throw new RuntimeException("Callbacks must add text or a content description in populateEventForVirtualViewId()");
      }
      break;
    case -1: 
      localAccessibilityEvent = AccessibilityEvent.obtain(paramInt2);
      ViewCompat.onInitializeAccessibilityEvent(this.h, localAccessibilityEvent);
      return localAccessibilityEvent;
    }
    localAccessibilityRecordCompat.setClassName(localAccessibilityNodeInfoCompat.getClassName());
    localAccessibilityRecordCompat.setSource(this.h, paramInt1);
    localAccessibilityEvent.setPackageName(this.h.getContext().getPackageName());
    return localAccessibilityEvent;
  }
  
  private boolean a(int paramInt, @Nullable Rect paramRect)
  {
    boolean bool = true;
    Object localObject = new ArrayList();
    getVisibleVirtualViews((List)localObject);
    SparseArrayCompat localSparseArrayCompat = new SparseArrayCompat();
    int i1 = 0;
    while (i1 < ((List)localObject).size())
    {
      localSparseArrayCompat.put(i1, c(i1));
      i1 += 1;
    }
    i1 = this.k;
    if (i1 == Integer.MIN_VALUE) {}
    for (localObject = null;; localObject = (AccessibilityNodeInfoCompat)localSparseArrayCompat.get(i1)) {
      switch (paramInt)
      {
      default: 
        throw new IllegalArgumentException("direction must be one of {FOCUS_FORWARD, FOCUS_BACKWARD, FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, FOCUS_RIGHT}.");
      }
    }
    if (ViewCompat.getLayoutDirection(this.h) == 1)
    {
      paramRect = (AccessibilityNodeInfoCompat)FocusStrategy.a(localSparseArrayCompat, n, m, localObject, paramInt, bool);
      if (paramRect != null) {
        break label395;
      }
    }
    label395:
    for (paramInt = Integer.MIN_VALUE;; paramInt = localSparseArrayCompat.keyAt(localSparseArrayCompat.indexOfValue(paramRect)))
    {
      return requestKeyboardFocusForVirtualView(paramInt);
      bool = false;
      break;
      Rect localRect = new Rect();
      if (this.k != Integer.MIN_VALUE) {
        a(this.k).getBoundsInParent(localRect);
      }
      for (;;)
      {
        paramRect = (AccessibilityNodeInfoCompat)FocusStrategy.a(localSparseArrayCompat, n, m, localObject, localRect, paramInt);
        break;
        if (paramRect != null)
        {
          localRect.set(paramRect);
        }
        else
        {
          paramRect = this.h;
          i1 = paramRect.getWidth();
          int i2 = paramRect.getHeight();
          switch (paramInt)
          {
          default: 
            throw new IllegalArgumentException("direction must be one of {FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, FOCUS_RIGHT}.");
          case 17: 
            localRect.set(i1, 0, i1, i2);
            break;
          case 33: 
            localRect.set(0, i2, i1, i2);
            break;
          case 66: 
            localRect.set(-1, 0, -1, i2);
            break;
          case 130: 
            localRect.set(0, -1, i1, -1);
          }
        }
      }
    }
  }
  
  private boolean a(Rect paramRect)
  {
    if ((paramRect == null) || (paramRect.isEmpty())) {
      return false;
    }
    if (this.h.getWindowVisibility() != 0) {
      return false;
    }
    for (paramRect = this.h.getParent(); (paramRect instanceof View); paramRect = paramRect.getParent())
    {
      paramRect = (View)paramRect;
      if ((ViewCompat.getAlpha(paramRect) <= 0.0F) || (paramRect.getVisibility() != 0)) {
        return false;
      }
    }
    return paramRect != null;
  }
  
  private void b(int paramInt)
  {
    if (this.l == paramInt) {
      return;
    }
    int i1 = this.l;
    this.l = paramInt;
    sendEventForVirtualView(paramInt, 128);
    sendEventForVirtualView(i1, 256);
  }
  
  @NonNull
  private AccessibilityNodeInfoCompat c(int paramInt)
  {
    AccessibilityNodeInfoCompat localAccessibilityNodeInfoCompat1 = AccessibilityNodeInfoCompat.obtain();
    localAccessibilityNodeInfoCompat1.setEnabled(true);
    localAccessibilityNodeInfoCompat1.setFocusable(true);
    localAccessibilityNodeInfoCompat1.setClassName("android.view.View");
    localAccessibilityNodeInfoCompat1.setBoundsInParent(a);
    localAccessibilityNodeInfoCompat1.setBoundsInScreen(a);
    localAccessibilityNodeInfoCompat1.setParent(this.h);
    onPopulateNodeForVirtualView(paramInt, localAccessibilityNodeInfoCompat1);
    if ((localAccessibilityNodeInfoCompat1.getText() == null) && (localAccessibilityNodeInfoCompat1.getContentDescription() == null)) {
      throw new RuntimeException("Callbacks must add text or a content description in populateNodeForVirtualViewId()");
    }
    localAccessibilityNodeInfoCompat1.getBoundsInParent(this.d);
    if (this.d.equals(a)) {
      throw new RuntimeException("Callbacks must set parent bounds in populateNodeForVirtualViewId()");
    }
    int i1 = localAccessibilityNodeInfoCompat1.getActions();
    if ((i1 & 0x40) != 0) {
      throw new RuntimeException("Callbacks must not add ACTION_ACCESSIBILITY_FOCUS in populateNodeForVirtualViewId()");
    }
    if ((i1 & 0x80) != 0) {
      throw new RuntimeException("Callbacks must not add ACTION_CLEAR_ACCESSIBILITY_FOCUS in populateNodeForVirtualViewId()");
    }
    localAccessibilityNodeInfoCompat1.setPackageName(this.h.getContext().getPackageName());
    localAccessibilityNodeInfoCompat1.setSource(this.h, paramInt);
    boolean bool;
    if (this.j == paramInt)
    {
      localAccessibilityNodeInfoCompat1.setAccessibilityFocused(true);
      localAccessibilityNodeInfoCompat1.addAction(128);
      if (this.k != paramInt) {
        break label380;
      }
      bool = true;
      label217:
      if (!bool) {
        break label385;
      }
      localAccessibilityNodeInfoCompat1.addAction(2);
    }
    AccessibilityNodeInfoCompat localAccessibilityNodeInfoCompat2;
    for (;;)
    {
      localAccessibilityNodeInfoCompat1.setFocused(bool);
      this.h.getLocationOnScreen(this.f);
      localAccessibilityNodeInfoCompat1.getBoundsInScreen(this.c);
      if (!this.c.equals(a)) {
        break label442;
      }
      localAccessibilityNodeInfoCompat1.getBoundsInParent(this.c);
      if (localAccessibilityNodeInfoCompat1.mParentVirtualDescendantId == -1) {
        break label407;
      }
      localAccessibilityNodeInfoCompat2 = AccessibilityNodeInfoCompat.obtain();
      for (paramInt = localAccessibilityNodeInfoCompat1.mParentVirtualDescendantId; paramInt != -1; paramInt = localAccessibilityNodeInfoCompat2.mParentVirtualDescendantId)
      {
        localAccessibilityNodeInfoCompat2.setParent(this.h, -1);
        localAccessibilityNodeInfoCompat2.setBoundsInParent(a);
        onPopulateNodeForVirtualView(paramInt, localAccessibilityNodeInfoCompat2);
        localAccessibilityNodeInfoCompat2.getBoundsInParent(this.d);
        this.c.offset(this.d.left, this.d.top);
      }
      localAccessibilityNodeInfoCompat1.setAccessibilityFocused(false);
      localAccessibilityNodeInfoCompat1.addAction(64);
      break;
      label380:
      bool = false;
      break label217;
      label385:
      if (localAccessibilityNodeInfoCompat1.isFocusable()) {
        localAccessibilityNodeInfoCompat1.addAction(1);
      }
    }
    localAccessibilityNodeInfoCompat2.recycle();
    label407:
    this.c.offset(this.f[0] - this.h.getScrollX(), this.f[1] - this.h.getScrollY());
    label442:
    if (this.h.getLocalVisibleRect(this.e))
    {
      this.e.offset(this.f[0] - this.h.getScrollX(), this.f[1] - this.h.getScrollY());
      this.c.intersect(this.e);
      localAccessibilityNodeInfoCompat1.setBoundsInScreen(this.c);
      if (a(this.c)) {
        localAccessibilityNodeInfoCompat1.setVisibleToUser(true);
      }
    }
    return localAccessibilityNodeInfoCompat1;
  }
  
  private boolean d(int paramInt)
  {
    if (this.j == paramInt)
    {
      this.j = Integer.MIN_VALUE;
      this.h.invalidate();
      sendEventForVirtualView(paramInt, 65536);
      return true;
    }
    return false;
  }
  
  @NonNull
  final AccessibilityNodeInfoCompat a(int paramInt)
  {
    if (paramInt == -1)
    {
      AccessibilityNodeInfoCompat localAccessibilityNodeInfoCompat = AccessibilityNodeInfoCompat.obtain(this.h);
      ViewCompat.onInitializeAccessibilityNodeInfo(this.h, localAccessibilityNodeInfoCompat);
      ArrayList localArrayList = new ArrayList();
      getVisibleVirtualViews(localArrayList);
      if ((localAccessibilityNodeInfoCompat.getChildCount() > 0) && (localArrayList.size() > 0)) {
        throw new RuntimeException("Views cannot have both real and virtual children");
      }
      int i1 = localArrayList.size();
      paramInt = 0;
      while (paramInt < i1)
      {
        localAccessibilityNodeInfoCompat.addChild(this.h, ((Integer)localArrayList.get(paramInt)).intValue());
        paramInt += 1;
      }
      return localAccessibilityNodeInfoCompat;
    }
    return c(paramInt);
  }
  
  final boolean a(int paramInt1, int paramInt2, Bundle paramBundle)
  {
    boolean bool2 = false;
    boolean bool1;
    switch (paramInt1)
    {
    default: 
      switch (paramInt2)
      {
      default: 
        bool1 = onPerformActionForVirtualView(paramInt1, paramInt2, paramBundle);
      }
      break;
    }
    do
    {
      do
      {
        do
        {
          return bool1;
          return ViewCompat.performAccessibilityAction(this.h, paramInt2, paramBundle);
          bool1 = bool2;
        } while (!this.g.isEnabled());
        bool1 = bool2;
      } while (!AccessibilityManagerCompat.isTouchExplorationEnabled(this.g));
      bool1 = bool2;
    } while (this.j == paramInt1);
    if (this.j != Integer.MIN_VALUE) {
      d(this.j);
    }
    this.j = paramInt1;
    this.h.invalidate();
    sendEventForVirtualView(paramInt1, 32768);
    return true;
    return d(paramInt1);
    return requestKeyboardFocusForVirtualView(paramInt1);
    return clearKeyboardFocusForVirtualView(paramInt1);
  }
  
  public final boolean clearKeyboardFocusForVirtualView(int paramInt)
  {
    if (this.k != paramInt) {
      return false;
    }
    this.k = Integer.MIN_VALUE;
    onVirtualViewKeyboardFocusChanged(paramInt, false);
    sendEventForVirtualView(paramInt, 8);
    return true;
  }
  
  public final boolean dispatchHoverEvent(@NonNull MotionEvent paramMotionEvent)
  {
    boolean bool = true;
    if ((!this.g.isEnabled()) || (!AccessibilityManagerCompat.isTouchExplorationEnabled(this.g))) {
      bool = false;
    }
    int i1;
    do
    {
      return bool;
      switch (paramMotionEvent.getAction())
      {
      case 8: 
      default: 
        return false;
      case 7: 
      case 9: 
        i1 = getVirtualViewAt(paramMotionEvent.getX(), paramMotionEvent.getY());
        b(i1);
      }
    } while (i1 != Integer.MIN_VALUE);
    return false;
    if (this.j != Integer.MIN_VALUE)
    {
      b(Integer.MIN_VALUE);
      return true;
    }
    return false;
  }
  
  public final boolean dispatchKeyEvent(@NonNull KeyEvent paramKeyEvent)
  {
    boolean bool = false;
    int i1;
    if (paramKeyEvent.getAction() != 1)
    {
      i1 = paramKeyEvent.getKeyCode();
      switch (i1)
      {
      }
    }
    do
    {
      do
      {
        do
        {
          return false;
        } while (!KeyEventCompat.hasNoModifiers(paramKeyEvent));
        switch (i1)
        {
        case 20: 
        default: 
          i1 = 130;
        }
        for (;;)
        {
          int i3 = paramKeyEvent.getRepeatCount();
          int i2 = 0;
          while ((i2 < i3 + 1) && (a(i1, null)))
          {
            i2 += 1;
            bool = true;
          }
          i1 = 17;
          continue;
          i1 = 33;
          continue;
          i1 = 66;
        }
        return bool;
      } while ((!KeyEventCompat.hasNoModifiers(paramKeyEvent)) || (paramKeyEvent.getRepeatCount() != 0));
      if (this.k != Integer.MIN_VALUE) {
        onPerformActionForVirtualView(this.k, 16, null);
      }
      return true;
      if (KeyEventCompat.hasNoModifiers(paramKeyEvent)) {
        return a(2, null);
      }
    } while (!KeyEventCompat.hasModifiers(paramKeyEvent, 1));
    return a(1, null);
  }
  
  public final int getAccessibilityFocusedVirtualViewId()
  {
    return this.j;
  }
  
  public AccessibilityNodeProviderCompat getAccessibilityNodeProvider(View paramView)
  {
    if (this.i == null) {
      this.i = new a();
    }
    return this.i;
  }
  
  @Deprecated
  public int getFocusedVirtualView()
  {
    return getAccessibilityFocusedVirtualViewId();
  }
  
  public final int getKeyboardFocusedVirtualViewId()
  {
    return this.k;
  }
  
  protected abstract int getVirtualViewAt(float paramFloat1, float paramFloat2);
  
  protected abstract void getVisibleVirtualViews(List<Integer> paramList);
  
  public final void invalidateRoot()
  {
    invalidateVirtualView(-1, 1);
  }
  
  public final void invalidateVirtualView(int paramInt)
  {
    invalidateVirtualView(paramInt, 0);
  }
  
  public final void invalidateVirtualView(int paramInt1, int paramInt2)
  {
    if ((paramInt1 != Integer.MIN_VALUE) && (this.g.isEnabled()))
    {
      ViewParent localViewParent = this.h.getParent();
      if (localViewParent != null)
      {
        AccessibilityEvent localAccessibilityEvent = a(paramInt1, 2048);
        AccessibilityEventCompat.setContentChangeTypes(localAccessibilityEvent, paramInt2);
        ViewParentCompat.requestSendAccessibilityEvent(localViewParent, this.h, localAccessibilityEvent);
      }
    }
  }
  
  public final void onFocusChanged(boolean paramBoolean, int paramInt, @Nullable Rect paramRect)
  {
    if (this.k != Integer.MIN_VALUE) {
      clearKeyboardFocusForVirtualView(this.k);
    }
    if (paramBoolean) {
      a(paramInt, paramRect);
    }
  }
  
  public void onInitializeAccessibilityEvent(View paramView, AccessibilityEvent paramAccessibilityEvent)
  {
    super.onInitializeAccessibilityEvent(paramView, paramAccessibilityEvent);
    onPopulateEventForHost(paramAccessibilityEvent);
  }
  
  public void onInitializeAccessibilityNodeInfo(View paramView, AccessibilityNodeInfoCompat paramAccessibilityNodeInfoCompat)
  {
    super.onInitializeAccessibilityNodeInfo(paramView, paramAccessibilityNodeInfoCompat);
    onPopulateNodeForHost(paramAccessibilityNodeInfoCompat);
  }
  
  protected abstract boolean onPerformActionForVirtualView(int paramInt1, int paramInt2, Bundle paramBundle);
  
  protected void onPopulateEventForHost(AccessibilityEvent paramAccessibilityEvent) {}
  
  protected void onPopulateEventForVirtualView(int paramInt, AccessibilityEvent paramAccessibilityEvent) {}
  
  protected void onPopulateNodeForHost(AccessibilityNodeInfoCompat paramAccessibilityNodeInfoCompat) {}
  
  protected abstract void onPopulateNodeForVirtualView(int paramInt, AccessibilityNodeInfoCompat paramAccessibilityNodeInfoCompat);
  
  protected void onVirtualViewKeyboardFocusChanged(int paramInt, boolean paramBoolean) {}
  
  public final boolean requestKeyboardFocusForVirtualView(int paramInt)
  {
    if ((!this.h.isFocused()) && (!this.h.requestFocus())) {}
    while (this.k == paramInt) {
      return false;
    }
    if (this.k != Integer.MIN_VALUE) {
      clearKeyboardFocusForVirtualView(this.k);
    }
    this.k = paramInt;
    onVirtualViewKeyboardFocusChanged(paramInt, true);
    sendEventForVirtualView(paramInt, 8);
    return true;
  }
  
  public final boolean sendEventForVirtualView(int paramInt1, int paramInt2)
  {
    if ((paramInt1 == Integer.MIN_VALUE) || (!this.g.isEnabled())) {}
    ViewParent localViewParent;
    do
    {
      return false;
      localViewParent = this.h.getParent();
    } while (localViewParent == null);
    AccessibilityEvent localAccessibilityEvent = a(paramInt1, paramInt2);
    return ViewParentCompat.requestSendAccessibilityEvent(localViewParent, this.h, localAccessibilityEvent);
  }
  
  final class a
    extends AccessibilityNodeProviderCompat
  {
    a() {}
    
    public final AccessibilityNodeInfoCompat createAccessibilityNodeInfo(int paramInt)
    {
      return AccessibilityNodeInfoCompat.obtain(ExploreByTouchHelper.this.a(paramInt));
    }
    
    public final AccessibilityNodeInfoCompat findFocus(int paramInt)
    {
      if (paramInt == 2) {}
      for (paramInt = ExploreByTouchHelper.a(ExploreByTouchHelper.this); paramInt == Integer.MIN_VALUE; paramInt = ExploreByTouchHelper.b(ExploreByTouchHelper.this)) {
        return null;
      }
      return createAccessibilityNodeInfo(paramInt);
    }
    
    public final boolean performAction(int paramInt1, int paramInt2, Bundle paramBundle)
    {
      return ExploreByTouchHelper.this.a(paramInt1, paramInt2, paramBundle);
    }
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/v4/widget/ExploreByTouchHelper.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */