Détection du sens de défilement dans l'adaptateur (haut / bas)

Je suis en train d'imiter l'application Google Plus dans mon projet, comme cela semble être la référence maintenant.

La listview effet lorsque le défilement est vraiment sympa et j'aimerais faire quelque chose de similaire.

J'ai commencé avec le LayoutAnimationController
http://android-er.blogspot.be/2009/10/listview-and-listactivity-layout.html

LayoutAnimationController controller 
   = AnimationUtils.loadLayoutAnimation(
     this, R.anim.list_layout_controller);
  getListView().setLayoutAnimation(controller);

et qui semble mauvais, car tous les éléments sont animés:

Donc j'ai fini par l'aide de la getView de l'adaptateur et de l'utilisation de ce:

        AnimationSet set = new AnimationSet(true);

        Animation animation = new AlphaAnimation(0.0f, 1.0f);
        animation.setDuration(800);
        set.addAnimation(animation);

        animation = new TranslateAnimation(
            Animation.RELATIVE_TO_SELF, 0.0f,Animation.RELATIVE_TO_SELF, 0.0f,
            Animation.RELATIVE_TO_SELF, 1.0f,Animation.RELATIVE_TO_SELF, 0.0f
        );
        animation.setDuration(600);
        set.addAnimation(animation);

        row.startAnimation(set);

Le résultat est génial et je suis vraiment heureux avec elle!

Malheureusement, il ne fonctionne que quand j'ai faites défiler de haut en bas de la liste!

Je veux le faire fonctionner lorsque le défilement de l'autre côté, j'ai besoin de changer un peu la TranslateAnimation.

Donc ma question, est-il un moyen de détecter si j'ai faites défiler vers le haut ou vers le bas dans ma carte?

source d'informationauteur Waza_Be

Attribuer une OnScrollListener à votre ListView. Créer un drapeau qui indique si l'utilisateur fait défiler vers le haut ou vers le bas. Définir une valeur appropriée pour le drapeau en vérifiant si le courant première élément visible de la position est égale à plus ou de moins que le précédent première élément visible de la position. Mettre à l'intérieur onScrollStateChanged().

Exemple de code:

private int mLastFirstVisibleItem;
private boolean mIsScrollingUp;

public void onScrollStateChanged(AbsListView view, int scrollState) {
    final ListView lw = getListView();

    if (view.getId() == lw.getId()) {
        final int currentFirstVisibleItem = lw.getFirstVisiblePosition();

        if (currentFirstVisibleItem > mLastFirstVisibleItem) {
            mIsScrollingUp = false;
        } else if (currentFirstVisibleItem < mLastFirstVisibleItem) {
            mIsScrollingUp = true;
        }

        mLastFirstVisibleItem = currentFirstVisibleItem;
    } 
}

Vérifier si mIsScrollingUp est vrai ou faux dans getView()et d'attribuer les animations en conséquence.

J'ai fini par le faire:

@Override
public View getView(int position, View convertView, ViewGroup parent) {
    Log.i("",position+" - "+lastposition);

    if (position >= lastposition)
        animation = new TranslateAnimation(Animation.RELATIVE_TO_SELF,
                0.0f, Animation.RELATIVE_TO_SELF, 0.0f,
                Animation.RELATIVE_TO_SELF, 1.0f,
                Animation.RELATIVE_TO_SELF, 0.0f);
    else
        animation = new TranslateAnimation(Animation.RELATIVE_TO_SELF,
                0.0f, Animation.RELATIVE_TO_SELF, 0.0f,
                Animation.RELATIVE_TO_SELF, -1.0f,
                Animation.RELATIVE_TO_SELF, 0.0f);

    animation.setDuration(600);
    set.addAnimation(animation);

    row.startAnimation(set);

    lastposition = position;

}

Plus complexe (solution de travail avec de longs articles à la hauteur dans listview)

Créer des listview

public class ScrollDetectingListView extends ListView {
    public ScrollDetectingListView(Context context) {
        super(context);
    }

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

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

    //we need this protected method for scroll detection
    public int getVerticalScrollOffset() {
        return computeVerticalScrollOffset();
    }
}

Remplacer onScroll

    listView.setOnScrollListener(new AbsListView.OnScrollListener() {

    private int mInitialScroll = 0;

    @Override
    public void onScrollStateChanged(AbsListView view, int scrollState) {

    }

    @Override
    public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
        int scrolledOffset = listView.getVerticalScrollOffset();
        if (scrolledOffset!=mInitialScroll) {
            //if scroll position changed
            boolean scrollUp = (scrolledOffset - mInitialScroll) < 0;
            mInitialScroll = scrolledOffset;
        }
    }
    });

Accepté la réponse n'a pas vraiment de "détecter" le défilement vers le haut ou vers le bas. Il ne fonctionnera pas si le courant élément visible est vraiment énorme. À l'aide de onTouchListener est le chemin à parcourir.

C'est l'extrait de code que j'ai utilisé:

listView.setOnTouchListener(new View.OnTouchListener() {
    float initialY, finalY;
    boolean isScrollingUp;

    @Override
    public boolean onTouch(View v, MotionEvent event) {
        int action = MotionEventCompat.getActionMasked(event);

        switch(action) {
            case (MotionEvent.ACTION_DOWN):
                initialY = event.getY();
            case (MotionEvent.ACTION_UP):
                finalY = event.getY();

                if (initialY < finalY) {
                    Log.d(TAG, "Scrolling up");
                    isScrollingUp = true;
                } else if (initialY > finalY) {
                    Log.d(TAG, "Scrolling down");
                    isScrollingUp = false;
                }
            default:
        }

        if (isScrollingUp) {
            //do animation for scrolling up
        } else {
            //do animation for scrolling down
        }

        return false; //has to be false, or it will freeze the listView
    }
});

De l'essayer . J'espère que cela vous aide . La Logique De @Gal Rom Réponse .

lv.setOnScrollListener(new OnScrollListener() {
        private int mLastFirstVisibleItem;

        @Override
        public void onScrollStateChanged(AbsListView view, int scrollState) {

        }

        @Override
        public void onScroll(AbsListView view, int firstVisibleItem,
                int visibleItemCount, int totalItemCount) {

            if(mLastFirstVisibleItem<firstVisibleItem)
            {
                Log.i("SCROLLING DOWN","TRUE");
            }
            if(mLastFirstVisibleItem>firstVisibleItem)
            {
                Log.i("SCROLLING UP","TRUE");
            }
            mLastFirstVisibleItem=firstVisibleItem;

        }
    });

2

Voici ma démarche: Il vous obtient plus de rétroaction immédiate sur la façon dont beaucoup vous avez fait défiler:
OnScrollvous pouvez juste obtenir la Top position du premier élément à votre liste. C'est assez fiable pour obtenir réelle de la position de défilement de l'information immédiatement.
```
listView.getChildAt(0).getTop()
```

J'ai utilisé cette solution beaucoup plus simple:

public class ScrollDetectingListView extends ListView

...

setOnScrollListener( new OnScrollListener() 
{

    private int mInitialScroll = 0;

    @Override
    public void onScroll(AbsListView view, int firstVisibleItem,
            int visibleItemCount, int totalItemCount) 
    {
        int scrolledOffset = computeVerticalScrollOffset();

        boolean scrollUp = scrolledOffset > mInitialScroll;
        mInitialScroll = scrolledOffset;
    }


    @Override
    public void onScrollStateChanged(AbsListView view, int scrollState) {


    }

}

list.setOnScrollListener(new OnScrollListener() {
        int last_item;
        @Override
        public void onScrollStateChanged(AbsListView view, int scrollState) {

        }

        @Override
        public void onScroll(AbsListView view, int firstVisibleItem,
                int visibleItemCount, int totalItemCount) {
            if(last_item<firstVisibleItem+visibleItemCount-1){
                System.out.println("List is scrolling upwards");
            }
            else if(last_item>firstVisibleItem+visibleItemCount-1){
                System.out.println("List is scrolling downwards");
            }
             last_item = firstVisibleItem+visibleItemCount-1;
        }
    });

Basé sur la position du dernier élément visible-je décider Listview est à la hausse ou à la baisse.

Vous devez vous connecter pour publier un commentaire.