Android se desvanece y se desvanece con ImageView

animation fadein

Question

Estoy teniendo problemas con una presentación de diapositivas que estoy construyendo.

He creado 2 animaciones en xml para fundido de entrada y salida:

fadein.xml

 <?xml version="1.0" encoding="UTF-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
<alpha android:fromAlpha="0.0" android:toAlpha="1.0"
android:interpolator="@android:anim/accelerate_interpolator"
android:duration="2000"/>
</set>

fadeout.xml

 <?xml version="1.0" encoding="UTF-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
<alpha android:fromAlpha="1.0" android:toAlpha="0.0"
android:interpolator="@android:anim/accelerate_interpolator"
android:duration="2000"/>
</set>

Lo que estoy intentando hacer es cambiar las imágenes de un ImageView usando el efecto de fundido, de modo que la imagen que se muestra se desvanecerá y otra se desvanecerá. Teniendo en cuenta que ya tengo una imagen configurada, puedo desvanecer esta imagen sin problema, con esto:

 Animation fadeInAnimation = AnimationUtils.loadAnimation(this, R.anim.your_fade_in_anim);
imageView.startAnimation(fadeoutAnim);

Pero luego, configuro la siguiente imagen para mostrar:

 imageView.setImageBitmap(secondImage);

Simplemente aparece en el imageView, y cuando configuro la animación, oculta la imagen, la desvanece ... ¿Hay alguna manera de arreglar eso, quiero decir, cuando hago imageView.setImageBitmap (secondImage); comando, la imagen no aparece inmediatamente, y solo cuando se ejecuta el desvanecimiento en la animación?

Answer 1

¿Has pensado en utilizar TransitionDrawable en lugar de animaciones personalizadas? https://developer.android.com/reference/android/graphics/drawable/TransitionDrawable.html

Una forma de lograr lo que estás buscando es:

// create the transition layers
Drawable[] layers = new Drawable[2];
layers[0] = new BitmapDrawable(getResources(), firstBitmap);
layers[1] = new BitmapDrawable(getResources(), secondBitmap);
TransitionDrawable transitionDrawable = new TransitionDrawable(layers);
imageView.setImageDrawable(transitionDrawable);
transitionDrawable.startTransition(FADE_DURATION);

Answer 2

Basado en la solución de Aladin Q, aquí hay una función auxiliar que escribí, que cambiará la imagen en una vista de imagen mientras se ejecuta un pequeño fundido de salida / fundido en la animación:

public static void ImageViewAnimatedChange(Context c, final ImageView v, final Bitmap new_image) {
final Animation anim_out = AnimationUtils.loadAnimation(c, android.R.anim.fade_out);
final Animation anim_in = AnimationUtils.loadAnimation(c, android.R.anim.fade_in);
anim_out.setAnimationListener(new AnimationListener()
{
@Override public void onAnimationStart(Animation animation) {}
@Override public void onAnimationRepeat(Animation animation) {}
@Override public void onAnimationEnd(Animation animation)
{
v.setImageBitmap(new_image);
anim_in.setAnimationListener(new AnimationListener() {
@Override public void onAnimationStart(Animation animation) {}
@Override public void onAnimationRepeat(Animation animation) {}
@Override public void onAnimationEnd(Animation animation) {}
});
v.startAnimation(anim_in);
}
});
v.startAnimation(anim_out);
}

Answer 3

Esta es probablemente la mejor solución que obtendrá. Simple y fácil. Lo aprendí en udemy. Supongamos que tiene dos imágenes con identificador de imagen id1 e id2 respectivamente y actualmente la vista de imagen está configurada como id1 y desea cambiarla a la otra imagen cada vez que alguien hace clic. Así que este es el código básico en MainActivity.java File

int clickNum=0;
public void click(View view){
clickNum++;
ImageView a=(ImageView)findViewById(R.id.id1);
ImageView b=(ImageView)findViewById(R.id.id2);
if(clickNum%2==1){
a.animate().alpha(0f).setDuration(2000); //alpha controls the transpiracy
}
else if(clickNum%2==0){
b.animate().alpha(0f).setDuration(2000); //alpha controls the transpiracy
}
}

Espero que esto seguramente ayude

Answer 4

Estoy usando este tipo de rutina para encadenamiento programático de animaciones.

 final Animation anim_out = AnimationUtils.loadAnimation(context, android.R.anim.fade_out);
final Animation anim_in = AnimationUtils.loadAnimation(context, android.R.anim.fade_in);
anim_out.setAnimationListener(new AnimationListener()
{
@Override
public void onAnimationStart(Animation animation) {}
@Override
public void onAnimationRepeat(Animation animation) {}
@Override
public void onAnimationEnd(Animation animation)
{
////////////////////////////////////////
// HERE YOU CHANGE YOUR IMAGE CONTENT //
////////////////////////////////////////
//ui_image.setImage...
anim_in.setAnimationListener(new AnimationListener()
{
@Override
public void onAnimationStart(Animation animation) {}
@Override
public void onAnimationRepeat(Animation animation) {}
@Override
public void onAnimationEnd(Animation animation) {}
});
ui_image.startAnimation(anim_in);
}
});
ui_image.startAnimation(anim_out);

Answer 5

La mejor y más fácil manera, para mí fue esto ...

-> Simplemente crea un hilo con Handler que contiene sleep ().

private ImageView myImageView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_shape_count); myImageView= (ImageView)findViewById(R.id.shape1);
Animation myFadeInAnimation = AnimationUtils.loadAnimation(this, R.anim.fadein);
myImageView.startAnimation(myFadeInAnimation);
new Thread(new Runnable() {
private Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
Log.w("hendler", "recived");
Animation myFadeOutAnimation = AnimationUtils.loadAnimation(getBaseContext(), R.anim.fadeout);
myImageView.startAnimation(myFadeOutAnimation);
myImageView.setVisibility(View.INVISIBLE);
}
};
@Override
public void run() {
try{
Thread.sleep(2000); // your fadein duration
}catch (Exception e){
}
handler.sendEmptyMessage(1);
}
}).start();
}

Answer 6

Para implementar esto de la manera que ha comenzado, deberá agregar un AnimationListener para que pueda detectar el comienzo y el final de una animación. Cuando se llama a OnAnimationEnd () para el fundido de salida, puede establecer la visibilidad de su objeto ImageView en View.INVISIBLE, cambiar las imágenes y comenzar su fundido de animación; también necesitará otro AnimationListener aquí. Cuando recibe OnAnimationEnd () para su desvanecimiento en la animación, configure el ImageView para que sea View.VISIBLE y eso debería darle el efecto que está buscando.

Implementé un efecto similar anteriormente, pero utilicé un ViewSwitcher con 2 ImageViews en lugar de un solo ImageView. Puede configurar las animaciones "in" y "out" para ViewSwitcher con su fundido de entrada y salida para que pueda administrar la implementación de AnimationListener. Entonces todo lo que tiene que hacer es alternar entre las 2 ImageViews.

Editar: para ser un poco más útil, aquí hay un ejemplo rápido de cómo usar ViewSwitcher. He incluido la fuente completa en https://github.com/aldryd/imageswitcher .

activity_main.xml

 <ViewSwitcher
android:id="@+id/switcher"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:layout_centerHorizontal="true"
android:inAnimation="@anim/fade_in"
android:outAnimation="@anim/fade_out" >
<ImageView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:scaleType="fitCenter"
android:src="@drawable/sunset" />
<ImageView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:scaleType="fitCenter"
android:src="@drawable/clouds" />
</ViewSwitcher>

MainActivity.java

 // Let the ViewSwitcher do the animation listening for you
((ViewSwitcher) findViewById(R.id.switcher)).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
ViewSwitcher switcher = (ViewSwitcher) v;
if (switcher.getDisplayedChild() == 0) {
switcher.showNext();
} else {
switcher.showPrevious();
}
}
});

Answer 7

Quería lograr el mismo objetivo que tú, así que escribí el siguiente método, que hace exactamente eso si le pasas un ImageView y una lista de referencias a los dibujos imprimibles.

ImageView demoImage = (ImageView) findViewById(R.id.DemoImage);
int imagesToShow[] = { R.drawable.image1, R.drawable.image2,R.drawable.image3 };
animate(demoImage, imagesToShow, 0,false);
private void animate(final ImageView imageView, final int images[], final int imageIndex, final boolean forever) {
//imageView <-- The View which displays the images
//images[] <-- Holds R references to the images to display
//imageIndex <-- index of the first image to show in images[]
//forever <-- If equals true then after the last image it starts all over again with the first image resulting in an infinite loop. You have been warned.
int fadeInDuration = 500; // Configure time values here
int timeBetween = 3000;
int fadeOutDuration = 1000;
imageView.setVisibility(View.INVISIBLE); //Visible or invisible by default - this will apply when the animation ends
imageView.setImageResource(images[imageIndex]);
Animation fadeIn = new AlphaAnimation(0, 1);
fadeIn.setInterpolator(new DecelerateInterpolator()); // add this
fadeIn.setDuration(fadeInDuration);
Animation fadeOut = new AlphaAnimation(1, 0);
fadeOut.setInterpolator(new AccelerateInterpolator()); // and this
fadeOut.setStartOffset(fadeInDuration + timeBetween);
fadeOut.setDuration(fadeOutDuration);
AnimationSet animation = new AnimationSet(false); // change to false
animation.addAnimation(fadeIn);
animation.addAnimation(fadeOut);
animation.setRepeatCount(1);
imageView.setAnimation(animation);
animation.setAnimationListener(new AnimationListener() {
public void onAnimationEnd(Animation animation) {
if (images.length - 1 > imageIndex) {
animate(imageView, images, imageIndex + 1,forever); //Calls itself until it gets to the end of the array
}
else {
if (forever){
animate(imageView, images, 0,forever); //Calls itself to start the animation all over again in a loop if forever = true
}
}
}
public void onAnimationRepeat(Animation animation) {
// TODO Auto-generated method stub
}
public void onAnimationStart(Animation animation) {
// TODO Auto-generated method stub
}
});
}

Answer 8

Utilicé la animación de fadeIn utilizada para reemplazar una imagen nueva por la anterior

ObjectAnimator.ofFloat(imageView, View.ALPHA, 0.2f, 1.0f).setDuration(1000).start();

Answer 9

puedes hacerlo por dos puntos simples y cambiar tu código

1.En su xml en la carpeta anim de su proyecto, establezca el tiempo de fundido de entrada y salida de fundido no igual

2.En tu clase java antes del inicio de la animación de fundido de salida, establece la segunda visibilidad de imageView Gone luego de que la animación de fundido comience a configurar la segunda visibilidad de imageView que quieras fundir en visible

fadeout.xml

<alpha
android:duration="4000"
android:fromAlpha="1.0"
android:interpolator="@android:anim/accelerate_interpolator"
android:toAlpha="0.0" />

fadein.xml

<alpha
android:duration="6000"
android:fromAlpha="0.0"
android:interpolator="@android:anim/accelerate_interpolator"
android:toAlpha="1.0" />

En tu clase java

Animation animFadeOut = AnimationUtils.loadAnimation(this, R.anim.fade_out);
ImageView iv = (ImageView) findViewById(R.id.imageView1);
ImageView iv2 = (ImageView) findViewById(R.id.imageView2);
iv.setVisibility(View.VISIBLE);
iv2.setVisibility(View.GONE);
animFadeOut.reset();
iv.clearAnimation();
iv.startAnimation(animFadeOut);
Animation animFadeIn = AnimationUtils.loadAnimation(this, R.anim.fade_in);
iv2.setVisibility(View.VISIBLE);
animFadeIn.reset();
iv2.clearAnimation();
iv2.startAnimation(animFadeIn);