CoordinatorLayout all'interno di un altro CoordinatorLayout

Question

CorodinatorLayout all'interno di un altro CoordinatorLayout tale che lo scorrimento della vista figlio dovrebbe anche scorrere il Parent CoordinatorLayout.

Ho un coordinatorLayout con ViewPager che contiene diverse Fragment tale che il Scroll nasconderà il tabLayout

ho un altro coordinatorLayout che ha un viewPager. Questo fragment viene gonfiato in ViewPager del frammento padre (genitore Coordinator layout).

Il problema è onScrolling il frammento bambino in childViewpager riflette solo in coordinator layout del bambino fragment e non nella controllante coordinator layout che ho bisogno di fare per nascondere il tablayout.

la struttura è:

CoordinatorLayout(p) ->(tablayout(p) & ViewPager(p) -> CoordinatorLayout(c) ->(tablayout(c) & ViewPAger(c) ->recyclerView(cc))) 

p -> parent; 

c -> child; cc -> child to child 

Come fare a scorrimento vista riciclatore interesserà entrambi i layout coordinatore in modo che il tablayout barra degli strumenti (p) sarà ottenere pelli.

Answer 1

Sfortunatamente, questo non è supportato da CoordinatorLayout.

Controllare il codice in NestedScrollingChildHelper.startNestedScroll() e CoordinatorLayout.onStartNestedScroll(), l'evento di scorrimento nidificato viene "consumata" Se uno di Behavior s del vostro interiore CoordinatorLayout consuma, e non saranno ulteriormente propagate.

Answer 2

È necessario personalizzare il Coordinatore CHILD, implementare NestedScrollingChild (ori coordinatorlayout non lo ha implementato) e sovrascrivere alcune funzioni per abilitare l'invio di eventi di scorrimento annidati al proprio Coordinatore di PARENT.

Answer 3

Ecco una semplice implementazione di un layout di coordinatore nidificato.

/** 
* This variation of CoordinatorLayout also serves as a nested scrolling child, 
* which supports passing nested scrolling operations to it's parent when it's 
* own nested scrolling is locked. 
*/ 
public class NestedCoordinatorLayout extends CoordinatorLayout implements NestedScrollingChild { 

    private NestedScrollingChildHelper mChildHelper; 
    private volatile boolean mPassToParent; 

    public NestedCoordinatorLayout(Context context) { 
     super(context); 
     mChildHelper = new NestedScrollingChildHelper(this); 
     setNestedScrollingEnabled(true); 
    } 

    public NestedCoordinatorLayout(Context context, AttributeSet attrs) { 
     super(context, attrs); 
     mChildHelper = new NestedScrollingChildHelper(this); 
     setNestedScrollingEnabled(true); 
    } 

    public NestedCoordinatorLayout(Context context, AttributeSet attrs, int defStyleAttr) { 
     super(context, attrs, defStyleAttr); 
     mChildHelper = new NestedScrollingChildHelper(this); 
     setNestedScrollingEnabled(true); 
    } 

    /** 
    * Locks the nested scrolling. Further scroll events will 
    * be passed to the nested scrolling parent. 
    */ 
    public void lockNestedScrolling() { 
     mPassToParent = true; 
    } 

    /** 
    * Unlocks the nested scrolling. Further scroll events will 
    * be dispatched to this layout's own scrolling children. 
    */ 
    public void unlockNestedScrolling() { 
     mPassToParent = false; 
    } 

    /* 
    * NestedScrollingParent implementation 
    */ 

    @Override 
    public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes) { 
     /* Enable the scrolling behavior of our own children */ 
     super.onStartNestedScroll(child, target, nestedScrollAxes); 
     /* Enable the scrolling behavior of the parent's other children */ 
     startNestedScroll(nestedScrollAxes); 
     /* Start tracking the current scroll */ 
     return true; 
    } 

    @Override 
    public void onStopNestedScroll(View target) { 
     /* Disable the scrolling behavior of our own children */ 
     super.onStopNestedScroll(target); 
     /* Disable the scrolling behavior of the parent's other children */ 
     stopNestedScroll(); 
    } 

    @Override 
    public void onNestedPreScroll(View target, int dx, int dy, int[] consumed) { 
     if (mPassToParent) { 
      dispatchNestedPreScroll(dx, dy, consumed, null); 
     } else { 
      super.onNestedPreScroll(target, dx, dy, consumed); 
     } 
    } 

    @Override 
    public void onNestedScroll(View target, int dxConsumed, int dyConsumed, 
           int dxUnconsumed, int dyUnconsumed) { 
     if (mPassToParent) { 
      dispatchNestedScroll(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, null); 
     } else { 
      super.onNestedScroll(target, dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed); 
     } 
    } 

    @Override 
    public boolean onNestedPreFling(View target, float velocityX, float velocityY) { 
     if (mPassToParent) { 
      return dispatchNestedPreFling(velocityX, velocityY); 
     } else { 
      return super.onNestedPreFling(target, velocityX, velocityY); 
     } 
    } 

    @Override 
    public boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed) { 
     if (mPassToParent) { 
      return dispatchNestedFling(velocityX, velocityY, consumed); 
     } else { 
      return super.onNestedFling(target, velocityX, velocityY, consumed); 
     } 
    } 

    /* 
    * NestedScrollingChild implementation 
    */ 

    @Override 
    public void setNestedScrollingEnabled(boolean enabled) { 
     mChildHelper.setNestedScrollingEnabled(enabled); 
    } 

    @Override 
    public boolean isNestedScrollingEnabled() { 
     return mChildHelper.isNestedScrollingEnabled(); 
    } 

    @Override 
    public boolean startNestedScroll(int axes) { 
     return mChildHelper.startNestedScroll(axes); 
    } 

    @Override 
    public void stopNestedScroll() { 
     mChildHelper.stopNestedScroll(); 
    } 

    @Override 
    public boolean hasNestedScrollingParent() { 
     return mChildHelper.hasNestedScrollingParent(); 
    } 

    @Override 
    public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed, 
             int dyUnconsumed, int[] offsetInWindow) { 
     return mChildHelper.dispatchNestedScroll(dxConsumed, dyConsumed, dxUnconsumed, 
       dyUnconsumed, offsetInWindow); 
    } 

    @Override 
    public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow) { 
     return mChildHelper.dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow); 
    } 

    @Override 
    public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed) { 
     return mChildHelper.dispatchNestedFling(velocityX, velocityY, consumed); 
    } 

    @Override 
    public boolean dispatchNestedPreFling(float velocityX, float velocityY) { 
     return mChildHelper.dispatchNestedPreFling(velocityX, velocityY); 
    } 
} 

Answer 4

So che è una vecchia domanda. Ma ho cercato a lungo di includere un CoordinatorLayout in un frammento, che è in un altro CoordinatorLayout.

Ho modificato la risposta di dev.bmax un po 'per chiamare entrambi i layout del coordinatore e chiamare i comportamenti collegati di entrambi i layout.

Quindi ecco la mia soluzione.

@SuppressWarnings("unused") 
public class NestedCoordinatorLayout extends CoordinatorLayout implements NestedScrollingChild { 

    private NestedScrollingChildHelper mChildHelper; 

    public NestedCoordinatorLayout(Context context) { 
     super(context); 
     mChildHelper = new NestedScrollingChildHelper(this); 
     setNestedScrollingEnabled(true); 
    } 

    public NestedCoordinatorLayout(Context context, AttributeSet attrs) { 
     super(context, attrs); 
     mChildHelper = new NestedScrollingChildHelper(this); 
     setNestedScrollingEnabled(true); 
    } 

    public NestedCoordinatorLayout(Context context, AttributeSet attrs, int defStyleAttr) { 
     super(context, attrs, defStyleAttr); 
     mChildHelper = new NestedScrollingChildHelper(this); 
     setNestedScrollingEnabled(true); 
    } 

    @Override 
    public boolean onStartNestedScroll(View child, View target, int  nestedScrollAxes) { 
     /* Enable the scrolling behavior of our own children */ 
     boolean tHandled = super.onStartNestedScroll(child, target, nestedScrollAxes); 
     /* Enable the scrolling behavior of the parent's other children */ 
     return startNestedScroll(nestedScrollAxes) || tHandled; 
    } 

    @Override 
    public void onStopNestedScroll(View target) { 
     /* Disable the scrolling behavior of our own children */ 
     super.onStopNestedScroll(target); 
     /* Disable the scrolling behavior of the parent's other children */ 
     stopNestedScroll(); 
    } 

    @Override 
    public void onNestedPreScroll(View target, int dx, int dy, int[] consumed) { 
     int[][] tConsumed = new int[2][2]; 
     super.onNestedPreScroll(target, dx, dy, tConsumed[0]); 
     dispatchNestedPreScroll(dx, dy, tConsumed[1], null); 
     consumed[0] = tConsumed[0][0] + tConsumed[1][0]; 
     consumed[1] = tConsumed[0][1] + tConsumed[1][1]; 
    } 

    @Override 
    public void onNestedScroll(View target, int dxConsumed, int dyConsumed, 
          int dxUnconsumed, int dyUnconsumed) { 
     super.onNestedScroll(target, dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed); 
     dispatchNestedScroll(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, null); 
    } 

    @Override 
    public boolean onNestedPreFling(View target, float velocityX, float velocityY) { 
     boolean tHandled = super.onNestedPreFling(target, velocityX, velocityY); 
     return dispatchNestedPreFling(velocityX, velocityY) || tHandled; 
    } 

    @Override 
    public boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed) { 
     boolean tHandled = super.onNestedFling(target, velocityX, velocityY, consumed); 
     return dispatchNestedFling(velocityX, velocityY, consumed) || tHandled; 
    } 

    @Override 
    public void setNestedScrollingEnabled(boolean enabled) { 
     mChildHelper.setNestedScrollingEnabled(enabled); 
    } 

    @Override 
    public boolean isNestedScrollingEnabled() { 
     return mChildHelper.isNestedScrollingEnabled(); 
    } 

    @Override 
    public boolean startNestedScroll(int axes) { 
     return mChildHelper.startNestedScroll(axes); 
    } 

    @Override 
    public void stopNestedScroll() { 
     mChildHelper.stopNestedScroll(); 
    } 

    @Override 
    public boolean hasNestedScrollingParent() { 
     return mChildHelper.hasNestedScrollingParent(); 
    } 

    @Override 
    public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed, 
            int dyUnconsumed, int[] offsetInWindow) { 
     return mChildHelper.dispatchNestedScroll(dxConsumed, dyConsumed, dxUnconsumed, 
       dyUnconsumed, offsetInWindow); 
    } 

    @Override 
    public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow) { 
     return mChildHelper.dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow); 
    } 

    @Override 
    public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed) { 
     return mChildHelper.dispatchNestedFling(velocityX, velocityY, consumed); 
    } 

    @Override 
    public boolean dispatchNestedPreFling(float velocityX, float velocityY) { 
     return mChildHelper.dispatchNestedPreFling(velocityX, velocityY); 
    } 
} 

Answer 5

Ho fatto questo una biblioteca, vederlo on GitHub.

È sufficiente utilizzare <NestedScrollCoordinatorLayout> nel layout.