जावा में फीका इन आउट आउट एंड्रॉइड एनिमेशन

Question

मैं एक ImageView का 2 सेकंड का एनीमेशन रखना चाहता हूं जो 1000ms को लुप्त होने में खर्च करता है और फिर 1000ms को लुप्त होती है।

यहाँ मैं अपने ImageView निर्माता में अब तक क्या है:

Animation fadeIn = new AlphaAnimation(0, 1);
fadeIn.setDuration(1000);

Animation fadeOut = new AlphaAnimation(1, 0);
fadeOut.setStartOffset(1000);
fadeOut.setDuration(1000);

AnimationSet animation = new AnimationSet(true);
animation.addAnimation(fadeIn);
animation.addAnimation(fadeOut);
this.setAnimation(animation);

जब मैं उस एनीमेशन को चलाता हूं, तो कुछ भी नहीं दिखता है। हालांकि, जब मैं अल्फा एनिमेशन में से एक को हटाता हूं, तो व्यवहार अपेक्षित रूप से काम करता है।

चीजें जो मैंने पहले ही आज़मा ली हैं:

• के , और setFillBefore, के हर बोधगम्य संयोजन ।setFillAftersetFillEnabled
• LinearInterpolatorकरने के लिए एक जोड़ने AnimationSet।

Comments

हाँ, आप छवियों को अंदर और बाहर फीका कर सकते हैं! इस ट्यूटोरियल को ट्रिक करना चाहिए। sankarganesh-info-exchange.blogspot.com/2011/04/…

— एडम स्टॉर्म

वह ट्यूटोरियल XML का उपयोग करते हुए एक विधि का वर्णन करता है। क्या आप जानते हैं कि जावा का उपयोग करके उसी चीज़ को कैसे प्राप्त किया जा सकता है?

— प्लवमान

ठीक है, Im मेरे प्रोग्रामिंग कंप्यूटर के बगल में नहीं है इसलिए मैं इस कोड का परीक्षण नहीं कर सकता, लेकिन आप जावा में xml विशेषताएँ सेट कर सकते हैं। यह मूल कोड है: Android: interpolator = "@ android: anim / acceler_interpolator" Android: fromAlpha = "0.0" android: toAlpha = "1.0" android: period = "300" /> n तो आप शायद MyTween.setDurationg कर सकते हैं (300) MyTween.fromAlpha (0.0) MyTween (1.0)

— एडम स्ट्रॉम

Answer 1

मेरी अपनी समस्या का पता लगाया। अंतःप्रणालकों में आधारित होने के कारण समाधान समाप्त हो गया।

Animation fadeIn = new AlphaAnimation(0, 1);
fadeIn.setInterpolator(new DecelerateInterpolator()); //add this
fadeIn.setDuration(1000);

Animation fadeOut = new AlphaAnimation(1, 0);
fadeOut.setInterpolator(new AccelerateInterpolator()); //and this
fadeOut.setStartOffset(1000);
fadeOut.setDuration(1000);

AnimationSet animation = new AnimationSet(false); //change to false
animation.addAnimation(fadeIn);
animation.addAnimation(fadeOut);
this.setAnimation(animation);

यदि आप कोटलिन का उपयोग कर रहे हैं

val fadeIn = AlphaAnimation(0f, 1f)
fadeIn.interpolator = DecelerateInterpolator() //add this
fadeIn.duration = 1000

val fadeOut = AlphaAnimation(1f, 0f)
fadeOut.interpolator = AccelerateInterpolator() //and this
fadeOut.startOffset = 1000
fadeOut.duration = 1000

val animation = AnimationSet(false) //change to false
animation.addAnimation(fadeIn)
animation.addAnimation(fadeOut)
this.setAnimation(animation)

Comments

क्या होगा यदि आप प्रत्येक के लिए 100 जैसी वास्तव में छोटी देरी के साथ 5 या 6 लुप्त होती / बाहर करना चाहते हैं, तो क्या आप ऐसा कुछ उपयोग कर सकते हैं? मैंने कोशिश की लेकिन यह वास्तव में तरल नहीं है। उद्देश्य उदाहरण के लिए अनुकरण करना था एक बल्ब जो ठीक से काम नहीं करेगा, और ट्विंकल।

— चय्य

कोशिश करें और इस कॉल को शुरू करें। एक लूप में शुरुआत

— जोनाथन

मैं सोच रहा था कि मैं अंतिम bg img और वर्तमान एक में सनक से बाहर हो जाऊं, लेकिन यह उत्तर मुझे प्रेरित करता है कि मुझे केवल वर्तमान bg img में फीका करने और वर्तमान एक को फीका करने की आवश्यकता है, क्योंकि AlphaAnimation दो अलग-अलग img नहीं कर सकता / बाहर कर सकता है ।

— macio.Jun

मुझे नहीं लगता कि आपके पास दो स्वतंत्र एनिमेशन होने की आवश्यकता है ... मुझे लगता है कि आपके पास एक एकल एनीमेशन हो सकता है और पैरामीटर सेट कर सकता है: fadeInOut.setRepeatMode (एनिमेशन.REVERSE);

— राउंडस्पारो हिल्टैक्स

दूसरा: यदि आप दोहराना चाहते थे, तो @jonney ने कहा कि लूप में कॉल करने की कोई आवश्यकता नहीं है। fadeInOut.setRepeatCount (6) का उपयोग करें - 6 को बदलें कि आप इसे दोहराना चाहते हैं। एंड्रॉइड में देशी C ++ कोड को जावा लूप में कॉल करने के बजाय यह सब करने के लिए बहुत कम ओवरहेड।

— राउंडस्पारो हिल्टैक्स

Answer 2

मुझे पता है कि यह पहले से ही उत्तर दिया गया है लेकिन .....

<?xml version="1.0" encoding="utf-8"?> 
<alpha xmlns:android="http://schemas.android.com/apk/res/android"
    android:fromAlpha="1.0" 
    android:toAlpha="0.0" 
    android:duration="1000"    
    android:repeatCount="infinite" 
    android:repeatMode="reverse"
    />

त्वरित और आसान तरीका जल्दी से एक सेल्फ रिपीट के साथ अंदर और बाहर एक फीका करना है। का आनंद लें

संपादित करें : अपनी गतिविधि में इसे जोड़ें:

yourView.startAnimation(AnimationUtils.loadAnimation(co‌​ntext, R.anim.yourAnimation));

Comments

+1 क्योंकि इस उत्तर के साथ मैं फीका पड़ना, फीका पड़ना और फीका पड़ना (बस रिपीटेशन = "2" सेट करना) कर सकता था। जैसा कि स्वीकृत उत्तर का प्रस्ताव है, मैं एनिमेशन को संक्षिप्त नहीं कर सकता।

— एलियनटेड

इस alphaसंसाधन को घोषित करने के बाद मैं इसका उपयोग कैसे कर सकता हूं? धन्यवाद

— zozelfelfo

zozelfelfo यह सिर्फ एक एनीमेशन xml है, इसलिए इसे कोड में लोड करें और फिर जो भी आप इसे प्रभावित करना चाहते हैं, उसे देखें।

— कोनराड विंकोवस्की

@KonradWinkowski startAnimation विधि में तर्क के रूप में एनिमेशन ऑब्जेक्ट की आवश्यकता है! मुझे इसे पास क्या करना चाहिए?

— अहमद वटानी

अधिक पूर्ण उत्तर की तलाश करने वालों के लिए: viewToAnimate.startAnimation(AnimationUtils.loadAnimation(context, R.anim.fade_in_out)जहाँ res के तहत ऐनिमेटेड फ़ोल्डर में fade_in_out.xml फ़ाइल है।

— क्रिस नाइट

Answer 3

viewToAnimate.animate().alpha(1).setDuration(1000).setInterpolator(new DecelerateInterpolator()).withEndAction(new Runnable() {
    @Override
    public void run() {
        viewToAnimate.animate().alpha(0).setDuration(1000).setInterpolator(new AccelerateInterpolator()).start();
    }
}).start();

Comments

मार्शमैलो के लिए एलिगेंट!

— 17

Answer 4

यहाँ मेरा समाधान AnimatorSet का उपयोग कर रहा है जो एनिमेशनसेट की तुलना में थोड़ा अधिक विश्वसनीय लगता है।

// Custom animation on image
ImageView myView = (ImageView)splashDialog.findViewById(R.id.splashscreenImage);

ObjectAnimator fadeOut = ObjectAnimator.ofFloat(myView, "alpha",  1f, .3f);
fadeOut.setDuration(2000);
ObjectAnimator fadeIn = ObjectAnimator.ofFloat(myView, "alpha", .3f, 1f);
fadeIn.setDuration(2000);

final AnimatorSet mAnimationSet = new AnimatorSet();

mAnimationSet.play(fadeIn).after(fadeOut);

mAnimationSet.addListener(new AnimatorListenerAdapter() {
    @Override
    public void onAnimationEnd(Animator animation) {
        super.onAnimationEnd(animation);
        mAnimationSet.start();
    }
});
mAnimationSet.start();

Comments

मुझे काम करने का समाधान पाने के लिए एक एनीमेशन के बजाय एक ObjectAimimator का उपयोग करना पड़ा क्योंकि किसी कारण से, जब भी मैंने एक अल्फाएनीमेशन शुरू किया, यह दो बार चला और कुछ अजीब टिमटिमाया।

— एंड्रयू ओरोबेटर

सुरुचिपूर्ण समाधान

— व्लाद

खैर, इसकी बहुत देर हो चुकी है, लेकिन मुझे लगता है कि यह कुछ मदद कर सकता है, कृपया इसे देखने से पहले इसे फिर से उपयोग करने से पहले स्पष्ट एनीमेशन ..

— भावेश मोरदिया

Answer 5

एक अन्य विकल्प:

FadeIn और fadeOut के लिए 2 एनीमेशन को परिभाषित करने की आवश्यकता नहीं है । fadeOut के विपरीत है fadein ।

तो तुम साथ ऐसा कर सकते Animation.REVERSE इस तरह:

AlphaAnimation alphaAnimation = new AlphaAnimation(0.0f, 1.0f);
alphaAnimation.setDuration(1000);
alphaAnimation.setRepeatCount(1);
alphaAnimation.setRepeatMode(Animation.REVERSE);
view.findViewById(R.id.imageview_logo).startAnimation(alphaAnimation);

तो onAnimationEnd :

alphaAnimation.setAnimationListener(new Animation.AnimationListener() {
    @Override
        public void onAnimationStart(Animation animation) {
            //TODO: Run when animation start
        }

        @Override
        public void onAnimationEnd(Animation animation) {
            //TODO: Run when animation end
        }

        @Override
        public void onAnimationRepeat(Animation animation) {
            //TODO: Run when animation repeat
        }
    });

Answer 6

जैसा कि मैं XML (लेआउट के लिए) की शक्ति में विश्वास करता हूं, यह स्वीकृत उत्तर के लिए बराबर है , लेकिन विशुद्ध रूप से एक एनीमेशन संसाधन के रूप में:

<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android"
    android:interpolator="@android:interpolator/accelerate_decelerate"
    android:fillAfter="true">
    <alpha
        android:fromAlpha="0"
        android:toAlpha="1"
        android:duration="1000" />
    <alpha
        android:fromAlpha="1"
        android:toAlpha="0"
        android:duration="1000"
        android:startOffset="1000"/>
</set>

fillAfterफीका एनीमेशन पूरा करने के बाद रहने के लिए के लिए है। interpolatorहैंडल प्रक्षेप , एनिमेशन के रूप में आप अनुमान लगा सकते हैं। आप अन्य प्रकार के प्रक्षेपकों का भी उपयोग कर सकते हैं, जैसे कि रैखिक या ओवरशूट।

अपने दृश्य पर अपना एनीमेशन शुरू करना सुनिश्चित करें:

yourView.startAnimation(AnimationUtils.loadAnimation(co‌​ntext, R.anim.fade));

Comments

@KGCybeX कोई समस्या नहीं, खुशी है कि मैं मदद कर सकता हूं :)

— डार्ककाइग्नस

बहुत मददगार और साफ। मेरे लिए पूरी तरह से काम करता है।

— फर्नांडो बारबोसा

Answer 7

यहाँ मैं / बाहर दृश्य में फीका करने के लिए इस्तेमाल किया है, उम्मीद है कि यह किसी की मदद करता है।

private void crossFadeAnimation(final View fadeInTarget, final View fadeOutTarget, long duration){
    AnimatorSet mAnimationSet = new AnimatorSet();
    ObjectAnimator fadeOut = ObjectAnimator.ofFloat(fadeOutTarget, View.ALPHA,  1f, 0f);
    fadeOut.addListener(new Animator.AnimatorListener() {
        @Override
        public void onAnimationStart(Animator animation) {
        }

        @Override
        public void onAnimationEnd(Animator animation) {
            fadeOutTarget.setVisibility(View.GONE);
        }

        @Override
        public void onAnimationCancel(Animator animation) {
        }

        @Override
        public void onAnimationRepeat(Animator animation) {
        }
    });
    fadeOut.setInterpolator(new LinearInterpolator());

    ObjectAnimator fadeIn = ObjectAnimator.ofFloat(fadeInTarget, View.ALPHA, 0f, 1f);
    fadeIn.addListener(new Animator.AnimatorListener() {
        @Override
        public void onAnimationStart(Animator animation) {
            fadeInTarget.setVisibility(View.VISIBLE);
        }

        @Override
        public void onAnimationEnd(Animator animation) {}

        @Override
        public void onAnimationCancel(Animator animation) {}

        @Override
        public void onAnimationRepeat(Animator animation) {}
    });
    fadeIn.setInterpolator(new LinearInterpolator());
    mAnimationSet.setDuration(duration);
    mAnimationSet.playTogether(fadeOut, fadeIn);
    mAnimationSet.start();
}

Comments

किसी तरह यह एकमात्र उत्तर है जिसमें दृश्यता सेट करना शामिल है, अच्छा है

— ल्यूक

Answer 8

ऐनिमेशनसेट्स अपेक्षा के अनुरूप काम नहीं करते हैं। अंत में मैंने हार मान ली और एनिमेशन के अनुक्रम के लिए हैंडलर क्लास के पोस्टडेलिड () का उपयोग किया।

Answer 9

यदि आप एनीमेशन बनाने के लिए एनिमेटर का उपयोग करते हैं तो आप कर सकते हैं

anim (निर्देशिका) -> fade_out.xml

<?xml version="1.0" encoding="UTF-8"?>
<objectAnimator
    android:propertyName="alpha"
    android:valueFrom="0"
    android:valueTo="1"
    xmlns:android="http://schemas.android.com/apk/res/android"/>

जावा में

Animator animator = AnimatorInflater.loadAnimator(context, R.animator.fade_out);
animator.setTarget(the_view_you_want_to_animation);
animator.setDuration(1000);
animator.start();

केवल जावा कोड के साथ एनीमेशन फीका करने का दूसरा तरीका है

ObjectAnimator fadeOut = ObjectAnimator.ofFloat(the_view_you_want_to_animation, "alpha",  1f, 0);
fadeOut.setDuration(2000);
fadeOut.start();

Comments

डायरेक्टरी एनिमेशन में * एनिमेटर नहीं

— कोसस

Answer 10

आप इस तरह से कुछ एनीमेशन एनीमेशन का उपयोग कर सकते हैं:

fadeIn.setAnimationListener(new AnimationListener() {
    @Override
    public void onAnimationEnd(Animation animation) {
        this.startAnimation(fadeout);
    }
});

Answer 11

मैं वास्तव में विटाली ज़िनचेनकोस समाधान पसंद करता हूं क्योंकि यह छोटा था।

यहाँ एक सरल फीका बाहर के लिए कोटलिन में एक भी संक्षिप्त संस्करण है

viewToAnimate?.alpha = 1f
viewToAnimate?.animate()
             ?.alpha(0f)
             ?.setDuration(1000)
             ?.setInterpolator(DecelerateInterpolator())
             ?.start()