J'utilise le bibliothèque de Parallaxscroll . Très facile à utiliser, de bons échantillons et bien documenté.

Ce qui suit contient un exemple d'application publié par l'auteur de paralloïde :

https://github.com/chrisjenx/paralloid/tree/master/paralloidexample p>

de la page GITHUB sous la section "Mise en route": P>

Layout h1>

ScrollView strong> p>

Ceci est un exemple, veuillez vous reporter à l'application Paralloidexample pour complète code. p>

//...
FrameLayout topContent = (FrameLayout) rootView.findViewById(R.id.top_content);
ScrollView scrollView = (ScrollView) rootView.findViewById(R.id.scroll_view);
if (scrollView instanceof Parallaxor) {
        ((Parallaxor) scrollView).parallaxViewBy(topContent, 0.5f);
}
// TODO: add content to top/scroll content

L'API Android ne supporte pas beaucoup d'outils concrets pour cela que vous avez probablement remarqué. Dans API 20, ils ont ajouté une élévation qui est un attribut pour la profondeur. Cela ne supporte pas la mise en page de parallaxe elle-même mais je dirais que c'est une étape par Google pour faciliter ce type de travail. Si vous voulez une supposition sauvage sur Si et quand je dirais que, je dirais que les utilitaires de parallaxe pourraient être ajoutés avant la publication de l'API 25, en fonction de la dernière mise à jour et de la progression de l'efficacité de la batterie.

Pour l'instant Tout ce dont vous avez besoin est d'écouter une sorte de mouvement et modifier les positions de vues basées sur une valeur représentant une élévation. P>

Votre question m'a fait mettre à niveau mon propre projet et c'est ainsi que je l'ai fait à l'aide de ViewdragHelper à l'intérieur d'un fragment. P>

public class MainFragment extends Fragment implements View.OnTouchListener {
    private ImageView mDecor, mBamboo, mBackgroundBamboo;
    private RelativeLayout mRootLayout;
    private ViewDragHelper mDragHelper;

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                         Bundle savedInstanceState) {
        mRootLayout = (RelativeLayout) inflater.inflate(R.layout.fragment_main, container, false);
        mRootLayout.setOnTouchListener(this);
        mDecor = (ImageView) mRootLayout.findViewById(R.id.decor);
        mBamboo = (ImageView) mRootLayout.findViewById(R.id.bamboo);
        mBackgroundBamboo = (ImageView) mRootLayout.findViewById(R.id.backround_bamboo);

        mDragHelper = ViewDragHelper.create(mRootLayout, 1.0f, new ViewDragHelper.Callback() {
            private final float MAX_LEFT = -0;
            private final float MAX_TOP = -20;
            private final float MAX_RIGHT = 50;
            private final float MAX_BOTTOM = 10;

            private final float MULTIPLIER = 0.1f;

            private final int DECOR_ELEVATION = 3;
            private final int FRONT_BAMBOO_ELEVATION = 6;
            private final int BACKGROUND_BAMBOO_ELEVATION = 1;

            private float mLeft = 0;
            private float mTop = 0;

            @Override
            public boolean tryCaptureView(View view, int i) {
                return true;
            }

            @Override
            public int clampViewPositionVertical(View child, int top, int dy) {
                mTop += dy * MULTIPLIER;
                mTop = mTop > MAX_BOTTOM ? MAX_BOTTOM : mTop < MAX_TOP ? MAX_TOP : mTop;

                mDecor.setTranslationY(mTop * DECOR_ELEVATION);
                mBamboo.setTranslationY(mTop * FRONT_BAMBOO_ELEVATION);
                mBackgroundBamboo.setTranslationY(mTop * BACKGROUND_BAMBOO_ELEVATION);
                return 0;
            }

            @Override
            public int clampViewPositionHorizontal(View child, int left, int dx) {
                mLeft += dx * MULTIPLIER;
                mLeft = mLeft < MAX_LEFT ? MAX_LEFT : mLeft > MAX_RIGHT ? MAX_RIGHT : mLeft;

                mDecor.setTranslationX(mLeft * DECOR_ELEVATION);
                mBamboo.setTranslationX(mLeft * FRONT_BAMBOO_ELEVATION);
                mBackgroundBamboo.setTranslationX(mLeft * BACKGROUND_BAMBOO_ELEVATION);
                return 0;
            }

            @Override
            public void onViewPositionChanged(View changedView, int left, int top, int dx, int dy){
                mRootLayout.requestLayout();
            }
        });
        return mRootLayout;
    }



    @Override
    public boolean onTouch(View view, MotionEvent motionEvent) {
        mDragHelper.processTouchEvent(motionEvent);
        // you can still use this touch listener for buttons etc.
        return true;
    }
}

C'est ce que vous pouvez faire:

dans votre fichier d'activité / fragment Fichier Spécifiez 2 ScrollView's (disons fond_sv et content_sv). p> xxx pré>

Ajouter une vue factice dans Le contenu ScrollView de la hauteur de l'arrière-plan et le rendra transparent. Maintenant, joignez un auditeur de défilement sur le contenu_sv. Lorsque le contenu ScrollView est défilé, appelez P>

package com.example.parallax;

// imports;

public class ParallaxActivity extends Activity implements ScrollViewListener {

    private MyScrollView mBgScrollView;
    private MyScrollView mContentScrollView;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        mBgScrollView = findViewById(R.id.background_sv);
        mContentScrollView = findViewById(R.id.content_sv);
        mContentScrollView.setOnScrollListener(this);
    }

    // this is method for onScrollListener put values according to your need
    @Override
    public void onScrollChanged(MyScrollView scrollView, int x, int y, int oldx, int oldy) {
        super.onScrollChanged(scrollView, x, y, oldx, oldy);
        // when the content scrollview will scroll by say 100px, 
        // the background scrollview will scroll by 50px. It will 
        // look like a parallax effect where the background is 
        // scrolling with a different speed then the content scrollview.
        mBgScrollView.scrollTo(0, (int)(y / 2f));
    }
}

Je pense que la question n'est pas claire, ce n'est donc pas vraiment une réponse tant qu'une tentative de clarifier avec plus de détails que je pouvais inclure dans un commentaire.

Ma question concerne quel type d'effet de parallaxe que vous souhaitez réaliser. Compte tenu de ces trois exemples (ce sont des applications de démonstration que vous pouvez installer depuis le magasin de jeu), ce qui a le type d'effet de parallaxe que vous souhaitez? S'il vous plaît répondre dans un commentaire.

• Démo paralloïde < / p>

• Démo de défilement Parallaxe

• application Google io

  Étant donné une réponse, nous aurons tous plus facile d'aider. Si vous modifiez votre question pour inclure ces informations, elle sera améliorée.

Voici comment cela peut être fait en utilisant ScrollView et son image de fond. J'ai commis le code dans Github .

Vous devez prolonger le ScrollView Code> et classes digues code>. p>

1. Par défaut, la hauteur de fond ScrollView sera identique à la hauteur de la fenêtre. Pour atteindre l'effet de parallaxe, la hauteur des antécédents doit être plus grande et doit être basée sur la hauteur d'enfant ScrollView et le facteur de défilement de fond que nous voulons imposer. Facteur de défilement de l'arrière-plan de 1 Indique, la hauteur de l'arrière-plan est identique à celle de ScrollView Hauteur de la taille de l'enfant et d'où l'arrière-plan fera défiler avec le même décalage que le défilement de l'enfant. 0.5 Indique que la hauteur de fond est de 0,5 fois ScrollView Child Hauteur étendue et défiler 50% plus lentement par rapport au contenu de l'enfant. Cela apporte efficacement l'effet de défilement de parallaxe. LI> ol>

   Appelez la méthode suivante de ScrollView Constructor: P>

   <manish.com.parallax.ParallaxScrollView
           xmlns:android="http://schemas.android.com/apk/res/android"
           android:id="@+id/sv"
           android:layout_width="match_parent"
           android:layout_height="match_parent" >
   
           <LinearLayout
               android:layout_width="match_parent"
               android:layout_height="match_parent"
               android:orientation="vertical">
   
               <TextView
                   android:id="@+id/tv"
                   android:layout_width="wrap_content"
                   android:layout_height="wrap_content"
                   android:textColor="#fff"
                   android:text="@string/text" />
   
               <View
                   android:layout_width="match_parent"
                   android:layout_height="5dp" />
               ...
           </LinearLayout>
   </manish.com.parallax.ParallaxScrollView>
   

hi Vous pouvez utiliser le code ci-dessous pour la classe ParallaxView Classe

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import java.util.ArrayList;

public class ParallaxView extends SurfaceView implements Runnable {

    private volatile boolean running;
    private Thread gameThread = null;

    // For drawing
    private Paint paint;
    private Canvas canvas;
    private SurfaceHolder ourHolder;

    // Holds a reference to the Activity
    Context context;

    // Control the fps
    long fps =60;

    // Screen resolution
    int screenWidth;
    int screenHeight;

    ParallaxView(Context context, int screenWidth, int screenHeight) {
        super(context);

        this.context = context;

        this.screenWidth = screenWidth;
        this.screenHeight = screenHeight;

        // Initialize our drawing objects
        ourHolder = getHolder();
        paint = new Paint();

    }

    @Override
    public void run() {

        while (running) {
            long startFrameTime = System.currentTimeMillis();

            update();

            draw();

            // Calculate the fps this frame
            long timeThisFrame = System.currentTimeMillis() - startFrameTime;
            if (timeThisFrame >= 1) {
                fps = 1000 / timeThisFrame;
            }
        }
    }

    private void update() {
        // Update all the background positions

    }

    private void draw() {

        if (ourHolder.getSurface().isValid()) {
            //First we lock the area of memory we will be drawing to
            canvas = ourHolder.lockCanvas();

            //draw a background color
            canvas.drawColor(Color.argb(255, 0, 3, 70));

            // Draw the background parallax

            // Draw the rest of the game
            paint.setTextSize(60);
            paint.setColor(Color.argb(255, 255, 255, 255));
            canvas.drawText("I am a plane", 350, screenHeight / 100 * 5, paint);
            paint.setTextSize(220);
            canvas.drawText("I'm a train", 50, screenHeight / 100*80, paint);

            // Draw the foreground parallax

            // Unlock and draw the scene
            ourHolder.unlockCanvasAndPost(canvas);
        }
    }

    // Clean up our thread if the game is stopped
    public void pause() {
        running = false;
        try {
            gameThread.join();
        } catch (InterruptedException e) {
            // Error
        }
    }

    // Make a new thread and start it
    // Execution moves to our run method
    public void resume() {
        running = true;
        gameThread = new Thread(this);
        gameThread.start();
    }

}// End of ParallaxView

• ici LI> ul>

  **: http: / /gamecodeschool.com/android/coding-a-parallax-scrolling-background-forroïdroid/ p> p>