Android: jak sprawdzić, czy widok wewnątrz ScrollView jest widoczny?

168

Mam, ScrollViewktóry zawiera serię Views. Chciałbym móc określić, czy widok jest aktualnie widoczny (czy jakakolwiek jego część jest obecnie wyświetlana przez ScrollView). Spodziewałbym się, że poniższy kod to zrobi, o dziwo nie:

Rect bounds = new Rect();
view.getDrawingRect(bounds);

Rect scrollBounds = new Rect(scroll.getScrollX(), scroll.getScrollY(), 
        scroll.getScrollX() + scroll.getWidth(), scroll.getScrollY() + scroll.getHeight());

if(Rect.intersects(scrollBounds, bounds))
{
    //is  visible
}
ab11
źródło
Ciekaw jestem, jak to działa. Próbuję zrobić to samo, ale ScrollView może obsługiwać tylko 1 bezpośrednie dziecko. Czy Twoja „seria widoków” jest opakowana w inny układ wewnątrz ScrollView? Tak są ułożone moje, ale kiedy to robię, żadna z udzielonych tutaj odpowiedzi nie działa dla mnie.
Rooster242
1
Tak, moja seria widoków znajduje się wewnątrz LinearLayout, czyli 1 elementu podrzędnego ScrollView. Odpowiedź Qberticusa zadziałała dla mnie.
ab11

Odpowiedzi:

65

Użyj View#getHitRectzamiast View#getDrawingRectw widoku, który testujesz. Możesz użyć View#getDrawingRectna ScrollViewzamiast obliczania jawnie.

Kod od View#getDrawingRect:

 public void getDrawingRect(Rect outRect) {
        outRect.left = mScrollX;
        outRect.top = mScrollY;
        outRect.right = mScrollX + (mRight - mLeft);
        outRect.bottom = mScrollY + (mBottom - mTop);
 }

Kod od View#getHitRect:

public void getHitRect(Rect outRect) {
        outRect.set(mLeft, mTop, mRight, mBottom);
}
Rich Schuler
źródło
35
Gdzie mam wywołać te metody?
Tooto,
3
@Qberticus Jak wywołać metody? Używam go i zawsze zwraca fałsz. Daj mi znać
KK_07k11A0585
2
Dokładnie gdzie wywołać te metody?
zapalenie zema,
193

To działa:

Rect scrollBounds = new Rect();
scrollView.getHitRect(scrollBounds);
if (imageView.getLocalVisibleRect(scrollBounds)) {
    // Any portion of the imageView, even a single pixel, is within the visible window
} else {
    // NONE of the imageView is within the visible window
}
Bill Mote
źródło
1
Działa świetnie. Aby było jaśniej: zwraca wartość true, jeśli widok jest całkowicie lub częściowo widoczny; fałsz oznacza, że ​​widok jest całkowicie niewidoczny.
qwertzguy
1
[+1] Użyłem tego kodu do GridView/ ListView/ GridViewWithHeaderpracy z SwipeRefreshLayout.
Kartik
Czy mógłby ktoś wyjaśnić, dlaczego to działa? getHitRectzwraca prostokąt we współrzędnych nadrzędnych, ale getLocalVisibleRectzwraca prostokąt we współrzędnych lokalnych widoku przewijania, prawda?
Przypnij
3
Nie obejmuje to nakładania się, jeśli widok dziecka nakłada się na inny element podrzędny, nadal zwróci wartość „prawda”
Pradeep
1
Tak, potrzebujemy instancji Rect, ale czy jest to konieczne, aby uzyskaćHitRect. Czy jest inaczej, gdy używam Recta (0,0-0,0)? Widzimy wywołanie getLocalVisibleRect getGlobalVisibleRect, a Rect jest tutaj ustawiony r. Set (0, 0, width, height);. @ BillMote
chefish
56

Jeśli chcesz wykryć, że widok jest W PEŁNI widoczny:

private boolean isViewVisible(View view) {
    Rect scrollBounds = new Rect();
    mScrollView.getDrawingRect(scrollBounds);

    float top = view.getY();
    float bottom = top + view.getHeight();

    if (scrollBounds.top < top && scrollBounds.bottom > bottom) {
        return true;
    } else {
        return false;
    }
}
Denys Vasylenko
źródło
6
To jest poprawna odpowiedź =) W moim przypadku zmieniłem if w następujący sposób: scrollBounds.top <= top && scrollBounds.bottom => bottom
Helton Isac
2
+1 Helton, jeśli twój widok zostanie przesunięty do góry lub do dołu dla widoku przewijania, będziesz potrzebować odpowiednio <= lub> =
Joe Maher
Czy naprawdę to przetestowałeś? Zawsze zwraca false w najprostszym układzie ScrollView i TextView jako dziecko.
Farid
1
Jaka jest różnica między getHitRect () a getDrawingRect ()? Proszę o przewodnik
VVB
2
Ten kod działa tylko wtedy, gdy widok jest dodawany bezpośrednio do katalogu głównego kontenera ScrollView. Sprawdź odpowiedź Phana Van Linha, jeśli chcesz poradzić sobie z widokiem dziecka w widoku dziecka itp.
thijsonline
12

Moje rozwiązanie to użyj NestedScrollViewelementu przewijania:

    final Rect scrollBounds = new Rect();
    scroller.getHitRect(scrollBounds);

    scroller.setOnScrollChangeListener(new NestedScrollView.OnScrollChangeListener() {
        @Override
        public void onScrollChange(NestedScrollView v, int scrollX, int scrollY, int oldScrollX, int oldScrollY) {

            if (myBtn1 != null) {

                if (myBtn1.getLocalVisibleRect(scrollBounds)) {
                    if (!myBtn1.getLocalVisibleRect(scrollBounds)
                            || scrollBounds.height() < myBtn1.getHeight()) {
                        Log.i(TAG, "BTN APPEAR PARCIALY");
                    } else {
                        Log.i(TAG, "BTN APPEAR FULLY!!!");
                    }
                } else {
                    Log.i(TAG, "No");
                }
            }

        }
    });
}
Webserveis
źródło
wymaga API 23+
SolidSnake
@SolidSnake, nie musisz importować innej klasy, działa dobrze
Parth Anjaria
10

Aby nieco rozwinąć odpowiedź Billa Mote'a za pomocą getLocalVisibleRect, możesz sprawdzić, czy widok jest widoczny tylko częściowo:

Rect scrollBounds = new Rect();
scrollView.getHitRect(scrollBounds);
if (!imageView.getLocalVisibleRect(scrollBounds)
    || scrollBounds.height() < imageView.getHeight()) {
    // imageView is not within or only partially within the visible window
} else {
    // imageView is completely visible
}
Dandalf
źródło
6
To nie działa ... nawet częściowo widoczny widok jest klasyfikowany jako całkowicie widoczny
azfar
10

To rozszerzenie pomaga wykryć widok w pełni widoczny.
Działa również, jeśli jesteś Viewdzieckiem dziecka ... ScrollView(np .: ScrollView-> LinearLayout-> ContraintLayout-> ... -> YourView).

fun ScrollView.isViewVisible(view: View): Boolean {
    val scrollBounds = Rect()
    this.getDrawingRect(scrollBounds)
    var top = 0f
    var temp = view
    while (temp !is ScrollView){
        top += (temp).y
        temp = temp.parent as View
    }
    val bottom = top + view.height
    return scrollBounds.top < top && scrollBounds.bottom > bottom
}

Uwaga

1) view.getY()i view.getX()zwróć wartość x, y do FIRST PARENT .

2) Oto przykład, w jaki sposób getDrawingRectzwróci linkwprowadź opis obrazu tutaj

Phan Van Linh
źródło
Chciałem rozwiązania, w którym metoda powinna zwracać fałsz, jeśli widok jest ukryty pod klawiaturą i to spełnia swoje zadanie. Dzięki.
Rahul
8
public static int getVisiblePercent(View v) {
        if (v.isShown()) {
            Rect r = new Rect();
            v.getGlobalVisibleRect(r);
            double sVisible = r.width() * r.height();
            double sTotal = v.getWidth() * v.getHeight();
            return (int) (100 * sVisible / sTotal);
        } else {
            return -1;
        }
    }
yanchenko
źródło
2
Różni się to od tego, o co prosił ab11. isShown () sprawdza tylko flagę widoczności, a nie to, czy widok znajduje się w widocznym obszarze ekranu.
Romain Guy
4
@Romain Guy Kod nie zakrywa, gdy widok jest całkowicie przewijany poza ekran. Powinien to być` public static int getVisiblePercent (View v) {if (v.isShown ()) {Rect r = new Rect (); boolean isVisible = v.getGlobalVisibleRect (r); if (isVisible) {double sVisible = r.width () * r.height (); double sTotal = v.getWidth () * v.getHeight (); return (int) (100 * sVisible / sTotal); } else {powrót -1; }} else {powrót -1; }} `
chefish
6

Dzisiaj miałem ten sam problem. Podczas wyszukiwania w Google i czytania odniesień do Androida znalazłem ten post i metodę, której zamiast tego użyłem;

public final boolean getLocalVisibleRect (Rect r)

Fajnie z nich, że nie tylko zapewniają Rect, ale także boolean wskazujący, czy View w ogóle jest widoczny. Z drugiej strony ta metoda jest nieudokumentowana :(

harizm
źródło
1
Informuje tylko o tym, czy element jest ustawiony na widoczność (prawda). Nie informuje Cię, czy „widoczny” element jest rzeczywiście widoczny w widoku.
Bill Mote,
Kod dla getLocalVisibleRect nie obsługuje Twojego roszczenia: `public final boolean getLocalVisibleRect (Rect r) {final Point offset = mAttachInfo! = Null? mAttachInfo.mPoint: nowy Point (); if (getGlobalVisibleRect (r, offset)) {r.offset (-offset.x, -offset.y); // ustaw r local return na prawdę; } return false; } `
mbafford
6

Chcesz sprawdzić, czy Twój Viewjest w pełni visible, spróbuj tą metodą:

private boolean isViewVisible(View view) {
    Rect scrollBounds = new Rect();
    mScrollView.getDrawingRect(scrollBounds);
    float top = view.getY();
    float bottom = top + view.getHeight();
    if (scrollBounds.top < top && scrollBounds.bottom > bottom) {
        return true; //View is visible.
    } else {
        return false; //View is NOT visible.
    }
}

Ściśle mówiąc, możesz uzyskać widoczność widoku za pomocą:

if (myView.getVisibility() == View.VISIBLE) {
    //VISIBLE
} else {
    //INVISIBLE
}

Możliwe stałe wartości widoczności w Widoku to:

VISIBLE Ten widok jest widoczny. Używaj z setVisibility (int) i android: visibility.

INVISIBLE Ten widok jest niewidoczny, ale nadal zajmuje miejsce do celów układu. Używaj z setVisibility (int) i android: visibility.

GONE Ten widok jest niewidoczny i nie zajmuje miejsca do celów układu. Używaj z setVisibility (int) i android: visibility.

Jorgesys
źródło
3
powolne klaśnięcie. OP chciał wiedzieć, zakładając, że widoczność widoku to View # VISIBLE, czyli jak sprawdzić, czy sam widok jest widoczny w przewijanym widoku.
Joao Sousa
1
Właśnie sprawdziłem prosty projekt. Układ ma ScrollView i TextView jako element podrzędny; zawsze zwraca false, mimo że TextView jest w pełni widoczny.
Farid
Zwraca zawsze fałsz.
Rahul
3

Możesz użyć, FocusAwareScrollViewktóre powiadamia, gdy widok staje się widoczny:

FocusAwareScrollView focusAwareScrollView = (FocusAwareScrollView) findViewById(R.id.focusAwareScrollView);
    if (focusAwareScrollView != null) {

        ArrayList<View> viewList = new ArrayList<>();
        viewList.add(yourView1);
        viewList.add(yourView2);

        focusAwareScrollView.registerViewSeenCallBack(viewList, new FocusAwareScrollView.OnViewSeenListener() {

            @Override
            public void onViewSeen(View v, int percentageScrolled) {

                if (v == yourView1) {

                    // user have seen view1

                } else if (v == yourView2) {

                    // user have seen view2
                }
            }
        });

    }

Oto klasa:

import android.content.Context;
import android.graphics.Rect;
import android.support.v4.widget.NestedScrollView;
import android.util.AttributeSet;
import android.view.View;

import java.util.ArrayList;
import java.util.List;

public class FocusAwareScrollView extends NestedScrollView {

    private List<OnScrollViewListener> onScrollViewListeners = new ArrayList<>();

    public FocusAwareScrollView(Context context) {
        super(context);
    }

    public FocusAwareScrollView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public FocusAwareScrollView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    public interface OnScrollViewListener {
        void onScrollChanged(FocusAwareScrollView v, int l, int t, int oldl, int oldt);
    }

    public interface OnViewSeenListener {
        void onViewSeen(View v, int percentageScrolled);
    }

    public void addOnScrollListener(OnScrollViewListener l) {
        onScrollViewListeners.add(l);
    }

    public void removeOnScrollListener(OnScrollViewListener l) {
        onScrollViewListeners.remove(l);
    }

    protected void onScrollChanged(int l, int t, int oldl, int oldt) {
        for (int i = onScrollViewListeners.size() - 1; i >= 0; i--) {
            onScrollViewListeners.get(i).onScrollChanged(this, l, t, oldl, oldt);
        }
        super.onScrollChanged(l, t, oldl, oldt);
    }

    @Override
    public void requestChildFocus(View child, View focused) {
        super.requestChildFocus(child, focused);
    }

    private boolean handleViewSeenEvent(View view, int scrollBoundsBottom, int scrollYOffset,
                                        float minSeenPercentage, OnViewSeenListener onViewSeenListener) {
        int loc[] = new int[2];
        view.getLocationOnScreen(loc);
        int viewBottomPos = loc[1] - scrollYOffset + (int) (minSeenPercentage / 100 * view.getMeasuredHeight());
        if (viewBottomPos <= scrollBoundsBottom) {
            int scrollViewHeight = this.getChildAt(0).getHeight();
            int viewPosition = this.getScrollY() + view.getScrollY() + view.getHeight();
            int percentageSeen = (int) ((double) viewPosition / scrollViewHeight * 100);
            onViewSeenListener.onViewSeen(view, percentageSeen);
            return true;
        }
        return false;
    }

    public void registerViewSeenCallBack(final ArrayList<View> views, final OnViewSeenListener onViewSeenListener) {

        final boolean[] viewSeen = new boolean[views.size()];

        FocusAwareScrollView.this.postDelayed(new Runnable() {
            @Override
            public void run() {

                final Rect scrollBounds = new Rect();
                FocusAwareScrollView.this.getHitRect(scrollBounds);
                final int loc[] = new int[2];
                FocusAwareScrollView.this.getLocationOnScreen(loc);

                FocusAwareScrollView.this.setOnScrollChangeListener(new NestedScrollView.OnScrollChangeListener() {

                    boolean allViewsSeen = true;

                    @Override
                    public void onScrollChange(NestedScrollView v, int x, int y, int oldx, int oldy) {

                        for (int index = 0; index < views.size(); index++) {

                            //Change this to adjust criteria
                            float viewSeenPercent = 1;

                            if (!viewSeen[index])
                                viewSeen[index] = handleViewSeenEvent(views.get(index), scrollBounds.bottom, loc[1], viewSeenPercent, onViewSeenListener);

                            if (!viewSeen[index])
                                allViewsSeen = false;
                        }

                        //Remove this if you want continuous callbacks
                        if (allViewsSeen)
                            FocusAwareScrollView.this.setOnScrollChangeListener((NestedScrollView.OnScrollChangeListener) null);
                    }
                });
            }
        }, 500);
    }
}
Vaibhav Jani
źródło
1

Sposób Kotlina;

Rozszerzenie do wyświetlania przewijania widoku listy i wykonywania akcji, jeśli widok podrzędny jest widoczny na ekranie.

@SuppressLint("ClickableViewAccessibility")
fun View.setChildViewOnScreenListener(view: View, action: () -> Unit) {
    val visibleScreen = Rect()

    this.setOnTouchListener { _, motionEvent ->
        if (motionEvent.action == MotionEvent.ACTION_MOVE) {
            this.getDrawingRect(visibleScreen)

            if (view.getLocalVisibleRect(visibleScreen)) {
                action()
            }
        }

        false
    }
}

Użyj tej funkcji rozszerzenia dla dowolnego przewijalnego widoku

nestedScrollView.setChildViewOnScreenListener(childView) {
               action()
            }
Cafer Mert Ceyhan
źródło
0

Wiem, że jest bardzo późno. Ale mam dobre rozwiązanie. Poniżej znajduje się fragment kodu do uzyskiwania procentowej widoczności widoku w widoku przewijania.

Przede wszystkim ustaw odbiornik dotykowy w widoku przewijania, aby uzyskać oddzwonienie do zatrzymania przewijania.

@Override
public boolean onTouch(View v, MotionEvent event) {
    switch ( event.getAction( ) ) {
        case MotionEvent.ACTION_CANCEL:
        case MotionEvent.ACTION_UP:
            new Handler().postDelayed(new Runnable() {
                @Override
                public void run() {
                    if(mScrollView == null){
                        mScrollView = (ScrollView) findViewById(R.id.mScrollView);
                    }
                    int childCount = scrollViewRootChild.getChildCount();

                    //Scroll view location on screen
                    int[] scrollViewLocation = {0,0};
                    mScrollView.getLocationOnScreen(scrollViewLocation);

                    //Scroll view height
                    int scrollViewHeight = mScrollView.getHeight();
                    for (int i = 0; i < childCount; i++){
                        View child = scrollViewRootChild.getChildAt(i);
                        if(child != null && child.getVisibility() == View.VISIBLE){
                            int[] viewLocation = new int[2];
                            child.getLocationOnScreen(viewLocation);
                            int viewHeight = child.getHeight();
                            getViewVisibilityOnScrollStopped(scrollViewLocation, scrollViewHeight,
                                    viewLocation, viewHeight, (String) child.getTag(), (childCount - (i+1)));
                        }
                    }
                }
            }, 150);
            break;
    }
    return false;
}

W powyższym fragmencie kodu otrzymujemy wywołania zwrotne dla zdarzeń dotykowych widoku przewijania i publikujemy plik uruchamialny po 150 milisekundach (nieobowiązkowe) po zatrzymaniu wywołania zwrotnego przewijania. W tym runnable uzyskamy lokalizację widoku przewijania na ekranie i wysokość widoku przewijania. Następnie pobierz bezpośrednią instancję podrzędnej grupy widoków widoku przewijania i uzyskaj liczbę podrzędnych. W moim przypadku bezpośredniego dziecko widzenia przewijania jest LinearLayout nazwie scrollViewRootChild . Następnie wykonaj iterację wszystkich widoków podrzędnych scrollViewRootChild . W powyższym fragmencie kodu widać, że pobieram lokalizację dziecka na ekranie w tablicy liczb całkowitych o nazwie viewLocation , uzyskam wysokość widoku w zmiennej nazwa viewHeight . Następnie wywołałem metodę prywatną getViewVisibilityOnScrollStopped. Możesz zrozumieć wewnętrzne działanie tej metody, czytając dokumentację.

/**
 * getViewVisibilityOnScrollStopped
 * @param scrollViewLocation location of scroll view on screen
 * @param scrollViewHeight height of scroll view
 * @param viewLocation location of view on screen, you can use the method of view claas's getLocationOnScreen method.
 * @param viewHeight height of view
 * @param tag tag on view
 * @param childPending number of views pending for iteration.
 */
void getViewVisibilityOnScrollStopped(int[] scrollViewLocation, int scrollViewHeight, int[] viewLocation, int viewHeight, String tag, int childPending) {
    float visiblePercent = 0f;
    int viewBottom = viewHeight + viewLocation[1]; //Get the bottom of view.
    if(viewLocation[1] >= scrollViewLocation[1]) {  //if view's top is inside the scroll view.
        visiblePercent = 100;
        int scrollBottom = scrollViewHeight + scrollViewLocation[1];    //Get the bottom of scroll view 
        if (viewBottom >= scrollBottom) {   //If view's bottom is outside from scroll view
            int visiblePart = scrollBottom - viewLocation[1];  //Find the visible part of view by subtracting view's top from scrollview's bottom  
            visiblePercent = (float) visiblePart / viewHeight * 100;
        }
    }else{      //if view's top is outside the scroll view.
        if(viewBottom > scrollViewLocation[1]){ //if view's bottom is outside the scroll view
            int visiblePart = viewBottom - scrollViewLocation[1]; //Find the visible part of view by subtracting scroll view's top from view's bottom
            visiblePercent = (float) visiblePart / viewHeight * 100;
        }
    }
    if(visiblePercent > 0f){
        visibleWidgets.add(tag);        //List of visible view.
    }
    if(childPending == 0){
        //Do after iterating all children.
    }
}

Jeśli czujesz jakąkolwiek poprawę w tym kodzie, prosimy o wkład.

Himanshu
źródło
0

Skończyło się na zaimplementowaniu kombinacji dwóch odpowiedzi Java (@ bill-mote https://stackoverflow.com/a/12428154/3686125 i @ denys-vasylenko https://stackoverflow.com/a/25528434/3686125 ) w mój projekt jako zestaw rozszerzeń Kotlin, które obsługują standardowe kontrolki ScrollView w pionie lub HorizontalScrollView.

Właśnie wrzuciłem je do pliku Kotlin o nazwie Extensions.kt, bez klasy, tylko metody.

Użyłem ich do określenia, do którego elementu należy przyciągnąć, gdy użytkownik przestanie przewijać w różnych widokach przewijania w moim projekcie:

fun View.isPartiallyOrFullyVisible(horizontalScrollView: HorizontalScrollView) : Boolean {
    @Suppress("CanBeVal") var scrollBounds = Rect()
    horizontalScrollView.getHitRect(scrollBounds)
    return getLocalVisibleRect(scrollBounds)
}

fun View.isPartiallyOrFullyVisible(scrollView: ScrollView) : Boolean {
    @Suppress("CanBeVal") var scrollBounds = Rect()
    scrollView.getHitRect(scrollBounds)
    return getLocalVisibleRect(scrollBounds)
}

fun View.isFullyVisible(horizontalScrollView: HorizontalScrollView) : Boolean {
    @Suppress("CanBeVal") var scrollBounds = Rect()
    horizontalScrollView.getDrawingRect(scrollBounds)
    val left = x
    val right = left + width
    return scrollBounds.left < left && scrollBounds.right > right
}

fun View.isFullyVisible(scrollView: ScrollView) : Boolean {
    @Suppress("CanBeVal") var scrollBounds = Rect()
    scrollView.getDrawingRect(scrollBounds)
    val top = y
    val bottom = top + height
    return scrollBounds.top < top && scrollBounds.bottom > bottom
}

fun View.isPartiallyVisible(horizontalScrollView: HorizontalScrollView) : Boolean = isPartiallyOrFullyVisible(horizontalScrollView) && !isFullyVisible(horizontalScrollView)
fun View.isPartiallyVisible(scrollView: ScrollView) : Boolean = isPartiallyOrFullyVisible(scrollView) && !isFullyVisible(scrollView)

Przykładowe użycie, iteracja przez elementy potomne LinearLayout scrollview i wyniki logowania:

val linearLayoutChild: LinearLayout = getChildAt(0) as LinearLayout
val scrollView = findViewById(R.id.scroll_view) //Replace with your scrollview control or synthetic accessor
for (i in 0 until linearLayoutChild.childCount) {
    with (linearLayoutChild.getChildAt(i)) {
        Log.d("ScrollView", "child$i left=$left width=$width isPartiallyOrFullyVisible=${isPartiallyOrFullyVisible(scrollView)} isFullyVisible=${isFullyVisible(scrollView)} isPartiallyVisible=${isPartiallyVisible(scrollView)}")
    }
}
ChrisPrime
źródło
1
dlaczego używasz vari tłumisz podpowiedź ide?
Filipkowicz
-1

Korzystając z odpowiedzi @Qberticus, która była do rzeczy, ale przy okazji świetnie, skompilowałem kilka kodów, aby sprawdzić, czy za każdym razem, gdy wywoływany jest widok scrollview i jest przewijany, wywołuje odpowiedź @Qberticus i możesz robić, co chcesz, w moim przypadku mam sieć społecznościowa zawierająca filmy, więc kiedy widok jest rysowany na ekranie, odtwarzam ten sam pomysł, co Facebook i Instagram. Oto kod:

mainscrollview.getViewTreeObserver().addOnScrollChangedListener(new OnScrollChangedListener() {

                    @Override
                    public void onScrollChanged() {
                        //mainscrollview is my scrollview that have inside it a linearlayout containing many child views.
                        Rect bounds = new Rect();
                         for(int xx=1;xx<=postslayoutindex;xx++)
                         {

                          //postslayoutindex is the index of how many posts are read.
                          //postslayoutchild is the main layout for the posts.
                        if(postslayoutchild[xx]!=null){

                            postslayoutchild[xx].getHitRect(bounds);

                        Rect scrollBounds = new Rect();
                        mainscrollview.getDrawingRect(scrollBounds);

                        if(Rect.intersects(scrollBounds, bounds))
                        {
                            vidPreview[xx].startPlaywithoutstoppping();
                         //I made my own custom video player using textureview and initialized it globally in the class as an array so I can access it from anywhere.
                        }
                        else
                        {

                        }


                        }
                    }
                    }
                });
Haytham Osama
źródło