Paralax effet, en application d'arrière-plan

C'est ce que vous pouvez faire:

Dans votre activité fragment ou un fichier de mise en page spécifier 2 ScrollView (dire background_sv et content_sv).

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <com.example.parallax.MyScrollView
        android:id="@+id/background_sv"
        android:layout_width="match_parent"
        android:layout_height="match_parent" >

            <ImageView
                android:id="@+id/parallax_bg"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:background="..." />
    </com.example.parallax.MyScrollView>

    <com.example.parallax.MyScrollView
        android:id="@+id/content_sv"
        android:layout_width="match_parent"
        android:layout_height="match_parent" >

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical" >
        </LinearLayout>
    </com.example.parallax.MyScrollView>

</RelativeLayout>

Ajouter un mannequin vue dans le contenu scrollview de la hauteur de l'arrière-plan et de le rendre transparent. Maintenant, fixez un défilement de l'auditeur à l'content_sv. Lorsque le contenu scrollview défile, appel

mBgScrollView.scrollTo(0, (int)(y /*scroll Of content_sv*/ / 2f));

L'API existantes n'ont pas le soutien pour obtenir le défilement des événements.
Par conséquent, nous devons créer un ScrollView, afin de fournir les ScrollViewListener.

package com.example.parallax;

//imports;

public class MyScrollView extends ScrollView {

    public interface ScrollViewListener {
        void onScrollChanged(MyScrollView scrollView, int x, int y, int oldx, int oldy);
    }

    private ScrollViewListener scrollViewListener = null;

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

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

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

    public void setScrollViewListener(ScrollViewListener scrollViewListener) {
        this.scrollViewListener = scrollViewListener;
    }

    @Override
    protected void onScrollChanged(int x, int y, int oldx, int oldy) {
        super.onScrollChanged(x, y, oldx, oldy);
        if(scrollViewListener != null) {
            scrollViewListener.onScrollChanged(this, x, y, oldx, oldy);
        }
    }
}

Ici est l'activité qui héberge à la fois le contenu ScrollView de fond et de la ScrollView

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));
    }
}

OriginalL'auteur Sagar Waghmare

Le texte qui suit contient un exemple d'application publiés par l'auteur de Paralloid:

https://github.com/chrisjenx/Paralloid/tree/master/paralloidexample

À partir de la page GitHub sous le "guide de démarrage" section:

Disposition

ScrollView

C'est un exemple, reportez-vous à la paralloidexample Application de plein
code.

<FrameLayout ..>
<FrameLayout
        android:id="@+id/top_content"
            android:layout_width="match_parent"
            android:layout_height="192dp"/>

<uk.co.chrisjenx.paralloid.views.ParallaxScrollView
        android:id="@+id/scroll_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:fillViewport="true">

    <LinearLayout
        android:id="@+id/scroll_content"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical"
            android:paddingTop="192dp"/>

</uk.co.chrisjenx.paralloid.views.ParallaxScrollView>
</FrameLayout>

Fragment

À l'intérieur de votre onViewCreated() ou onCreateView().

//...
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

Thats it!

Ont un look à la Parallaxor interface pour la Parallaxe
des méthodes.

Espérons que cette aide!

Aussi, ici est un lien vers Google "démarrer" de la page pour android.

Aussi, ici est un lien vers un "java tutoriel pour débutants'.

Ainsi que lien à une partie de la documentation sur les modèles qui définissent la structure visuelle pour une interface utilisateur".

Cela étant dit, vous devez utiliser la mise en page pour définir ce que l'interface ressemble à et l'utilisation subséquente d'un exemple de code pour définir ce qui se passe lorsque vous interagissez avec elle.

P. S. Vous pouvez voir l'application en action ici

OriginalL'auteur Drew

Ici est de savoir comment il peut être fait en utilisant le ScrollView et c'est l'image de fond. J'ai commis le code dans github.

Vous avez besoin d'étendre la ScrollView et Drawable classes.

1. Par défaut, le ScrollView fond de la hauteur sera la même que la hauteur de la fenêtre d'affichage. Pour atteindre l'effet de parallaxe, le fond de hauteur doit être plus grande, et doit être fondée sur la ScrollView enfant de la hauteur et de l'arrière-plan de défilement facteur que nous voulons imposer.
   Arrière-plan de défilement facteur de 1 indique, le fond, la hauteur est la même que le ScrollView enfant de la hauteur et donc arrière-plan de défilement avec le même décalage que l'enfant commence à défiler.
   0,5 indique, le fond, la hauteur est de 0,5 fois le ScrollView enfant étendue de la hauteur et faites défiler jusqu'à 50% plus lent par rapport à l'enfant contenu. Cela réduit l'effet de défilement parallaxe.

Appel en suivant la méthode de ScrollView constructeur:

void init() {
    //Calculate background drawable size before first draw of scrollview
    getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
        @Override
        public boolean onPreDraw() {
            //Remove the listener
            getViewTreeObserver().removeOnPreDrawListener(this);

            mDrawable = (ParallaxDrawable) getBackground();

            if(mDrawable != null && mDrawable instanceof ParallaxDrawable) {
                //Get the only child of scrollview
                View child = getChildAt(0);
                int width = child.getWidth();
                //calculate height of background based on child height and scroll factor
                int height = (int) (getHeight() + (child.getHeight() - getHeight()) * mScrollFactor);
                mDrawable.setSize(width, height);
            }       

            return true;
        }       
    });     
}

1. Lorsque le ScrollView défile, prendre en considération le défilement de décalage, tandis que le dessin de l'arrière-plan. Ce essentiellement atteint l'effet de parallaxe.

ParallaxScrollView:

protected void onScrollChanged(int x, int y, int oldX, int oldY) {
   if(mDrawable != null && mDrawable instanceof ParallaxDrawable) {
       //set the scroll offset for the background drawable.
       mDrawable.setScrollOffset(x*mScrollFactor, y*mScrollFactor);
   }
} 

ParallaxDrawable:

@Override
public void draw(Canvas canvas) {
    //To move the background up, translate canvas by negative offset
    canvas.translate(-mScrollXOffset, -mScrollYOffset);
    mDrawable.draw(canvas);
    canvas.translate(mScrollXOffset, mScrollYOffset);
}


protected void onBoundsChange(Rect bounds) {
    //This sets the size of background drawable.
    mDrawable.setBounds(new Rect(bounds.top, bounds.left, bounds.left + mWidth, bounds.top + mHeight));
}

Utilisation de ParallaxScrollView et ParallaxDrawable:

public class MyActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.parallax_layout);

        final ParallaxScrollView scrollView = (ParallaxScrollView) findViewById(R.id.sv);
        ParallaxDrawable drawable = new ParallaxDrawable(getResources().getDrawable(R.drawable.bg));
        scrollView.setBackground( drawable, 0.2f );
    }
}

parallax_layout.xml:

<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>

OriginalL'auteur Manish Mulimani

Bonjour, Vous pouvez aller avec le sous-code donné pour 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

Pour en savoir plus, vous pouvez aller **

• ici

**: http://gamecodeschool.com/android/coding-a-parallax-scrolling-background-for-android/

OriginalL'auteur Vijay Singh Khatri