एंड्रॉइड पर व्यू बैकग्राउंड कलर का चेतन परिवर्तन


335

एंड्रॉइड पर एक दृश्य के पृष्ठभूमि रंग के परिवर्तन को आप कैसे चेतन करते हैं?

उदाहरण के लिए:

मेरा लाल पृष्ठभूमि रंग के साथ एक दृश्य है। दृश्य का पृष्ठभूमि रंग बदलकर नीला हो जाता है। मैं रंगों के बीच एक चिकनी संक्रमण कैसे कर सकता हूं?

यदि यह विचारों के साथ नहीं किया जा सकता है, तो एक विकल्प का स्वागत किया जाएगा।


11
एक उम्मीद करेगा कि एंड्रॉइड जैसे प्लेटफॉर्म के लिए रंगों के बीच एक चिकनी संक्रमण एक समस्या नहीं होनी चाहिए। हो सकता है कि विचार इसके लिए निर्मित न हों, हालाँकि। सवाल अभी भी खड़ा है।
hpique

जवाबों:


374

मैं इस समस्या के लिए एक (बहुत अच्छा) समाधान समझ रहा हूँ!

इसे पूरा करने के लिए आप एक TransDDrawable का उपयोग कर सकते हैं । उदाहरण के लिए, ड्रा करने योग्य फ़ोल्डर में XML फ़ाइल में आप कुछ ऐसा लिख ​​सकते हैं:

<?xml version="1.0" encoding="UTF-8"?>
<transition xmlns:android="http://schemas.android.com/apk/res/android">
    <!-- The drawables used here can be solid colors, gradients, shapes, images, etc. -->
    <item android:drawable="@drawable/original_state" />
    <item android:drawable="@drawable/new_state" />
</transition>

फिर, वास्तविक दृश्य के लिए अपने XML में आप इस संक्रमण का संदर्भ देंगे android:background विशेषता ।

इस बिंदु पर आप अपने कोड में आदेश द्वारा संक्रमण आरंभ कर सकते हैं:

TransitionDrawable transition = (TransitionDrawable) viewObj.getBackground();
transition.startTransition(transitionTime);

या कॉल करके संक्रमण को उल्टा चलाएं:

transition.reverseTransition(transitionTime);

प्रॉपर्टी एनिमेशन एपीआई का उपयोग करके एक और समाधान के लिए रोमन का जवाब देखें , जो उस समय उपलब्ध नहीं था जब यह उत्तर मूल रूप से पोस्ट किया गया था।


3
धन्यवाद mxrider! यह प्रश्न का उत्तर देता है। दुर्भाग्य से यह मेरे लिए काम नहीं करता है क्योंकि पृष्ठभूमि के रूप में ट्रांज़िशनड्रैबल को देखने के साथ-साथ एनिमेटेड भी होना पड़ता है, और ऐसा लगता है कि दृश्य एनीमेशन पृष्ठभूमि संक्रमण से आगे निकल जाता है। कोई विचार?
hpique

6
एनीमेशन को शुरू करके TransitionDrawable AFTER को शुरू करके इसे हल किया।
hpique

2
बहुत बढ़िया! मैं खुश हूं कि आपका यह चलने लगा! एंड्रॉइड के साथ xml में आप बहुत सारे शांत सामान कर सकते हैं - जिनमें से बहुत थोड़े डॉक्स में दफन हैं और मेरी राय में स्पष्ट नहीं हैं।
मूर्ति

4
स्पष्ट नहीं है। मुझे यह उल्लेख करना चाहिए कि मैं अपने मामले में xml का उपयोग नहीं कर रहा हूं, क्योंकि रंग गतिशील है। यदि आप कोड द्वारा TransitionDrawable बनाते हैं तो आपका समाधान भी काम करता है।
hpique

2
मुख्य कमियों में से एक यह है कि कोई भी एनीमेशन पूर्ण श्रोता नहीं है
लियो डायरोडोडर

511

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

int colorFrom = getResources().getColor(R.color.red);
int colorTo = getResources().getColor(R.color.blue);
ValueAnimator colorAnimation = ValueAnimator.ofObject(new ArgbEvaluator(), colorFrom, colorTo);
colorAnimation.setDuration(250); // milliseconds
colorAnimation.addUpdateListener(new AnimatorUpdateListener() {

    @Override
    public void onAnimationUpdate(ValueAnimator animator) {
        textView.setBackgroundColor((int) animator.getAnimatedValue());
    }

});
colorAnimation.start();

Android के साथ पिछड़े संगतता के लिए 2. जेक व्हार्टन से नौ पुराने एंड्रॉइड लाइब्रेरी का उपयोग करें ।

getColorविधि Android M में पदावनत किया गया था, तो आप दो विकल्प हैं:

  • यदि आप समर्थन लाइब्रेरी का उपयोग करते हैं, तो आपको getColorकॉल को इसके साथ बदलना होगा :

    ContextCompat.getColor(this, R.color.red);
  • यदि आप समर्थन लाइब्रेरी का उपयोग नहीं करते हैं, तो आपको getColorकॉल को बदलने की आवश्यकता है :

    getColor(R.color.red);

2
यदि आप संपत्ति एनीमेशन एपीआई (या NineOldAndroid) का उपयोग कर रहे हैं तो "मुस्तैद" समाधान। बहुत आसानी से एनिमेटेड।
दिमित्री ज़ेत्सेव

1
क्या इस तरह से संक्रमण की अवधि निर्धारित करने का कोई तरीका है?
IGio90

159
@ iGio90 हाँ, आप इसे मानने वाले नहीं हैं, लेकिन विधि कॉल सेटिडेशन () :)
रोमन माइनोक

6
ValueAnimator.ofArgb(colorFrom, colorTo)इस बिंदु पर अधिक दिखता है, लेकिन दुख की बात है कि यह नया है।
TWStStrrob

1
सुंदर समाधान! धन्यवाद।
स्टीव फ़ॉली

137

यह देखने पर निर्भर करता है कि आपके दृश्य का रंग कैसा है और आपको अपना लक्ष्य रंग कैसे मिलता है, इसके लिए कई अलग-अलग तरीके हैं।

पहले दो Android संपत्ति एनीमेशन ढांचे का उपयोग करता है ।

एक ऑब्जेक्ट एनिमेटर का उपयोग करें यदि:

  • आपके विचार argbका एक xml फ़ाइल में मान के रूप में इसकी पृष्ठभूमि का रंग है ।
  • आपके विचार में पहले इसका रंग निर्धारित किया गया था view.setBackgroundColor()
  • आपके विचार में इसका बैकग्राउंड रंग एक ड्रिबल में परिभाषित किया गया है जो स्ट्रोक या कॉर्नर रेडियस जैसी किसी भी अतिरिक्त गुण को परिभाषित नहीं करता है।
  • आपके विचार में इसकी पृष्ठभूमि का रंग एक ड्रॉबल में परिभाषित किया गया है और आप स्ट्रोक या कॉर्नर त्रिज्या जैसे किसी भी अतिरिक्त गुण को हटाना चाहते हैं, ध्यान रखें कि अतिरिक्त गुणों को हटाने से एनिमेटेड नहीं होगा।

ऑब्जेक्ट एनिमेटर कॉल करके काम करता है view.setBackgroundColorजो परिभाषित ड्रॉबल को बदल देता है जब तक कि यह एक उदाहरण नहीं है ColorDrawable, जो कि यह शायद ही कभी होता है। इसका मतलब यह है कि स्ट्रोक या कोनों जैसे एक ड्रॉबल से किसी भी अतिरिक्त पृष्ठभूमि गुणों को हटा दिया जाएगा।

मान एनिमेटर का उपयोग करें यदि:

  • आपके विचार में इसका बैकग्राउंड कलर एक ड्रिबल में परिभाषित किया गया है जो स्ट्रोक या कॉर्नर रेडियस की तरह गुणों को भी सेट करता है और आप इसे एक नए रंग में बदलना चाहते हैं जो रन करते समय तय किया जाता है।

यदि ड्रा करने योग्य परिवर्तन का उपयोग करें :

  • आपका दृष्टिकोण दो ड्रॉएबल के बीच स्विच करना चाहिए जो कि परिनियोजन से पहले परिभाषित किया गया है।

मेरे पास ट्रांज़िशन ड्रॉबल्स के साथ कुछ प्रदर्शन के मुद्दे हैं जो एक ड्रॉयरलैट को खोलते समय चलता है जिसे मैं हल करने में सक्षम नहीं हूं, इसलिए यदि आप किसी भी अप्रत्याशित हकलाना का सामना करते हैं तो आप उसी बग में भाग सकते हैं जैसे मेरे पास है।

आप आप एक उपयोग करना चाहते हैं मूल्य एनिमेटर उदाहरण को संशोधित करना होगा drawable StateLists या एक LayerLists drawable अन्यथा उस पर दुर्घटना होगा, final GradientDrawable background = (GradientDrawable) view.getBackground();लाइन।

ऑब्जेक्ट एनिमेटर :

देखें परिभाषा:

<View
    android:background="#FFFF0000"
    android:layout_width="50dp"
    android:layout_height="50dp"/>

ObjectAnimatorइस तरह बनाएं और उपयोग करें।

final ObjectAnimator backgroundColorAnimator = ObjectAnimator.ofObject(view,
                                                                       "backgroundColor",
                                                                       new ArgbEvaluator(),
                                                                       0xFFFFFFFF,
                                                                       0xff78c5f9);
backgroundColorAnimator.setDuration(300);
backgroundColorAnimator.start();

आप एनीमेशन को एक xml से एनीमेशन परिभाषा में भी लोड कर सकते हैं जैसे कि ऐनिमेटर इनफ्लैटर का उपयोग करता है जैसे कि एंड्रॉइड ऑब्जेक्ट में एक्समाइट करता है। एनीमेटर एनिमेटिंग बैकग्राउंड ऑफ लेआउट

मूल्य एनीमेटर :

देखें परिभाषा:

<View
    android:background="@drawable/example"
    android:layout_width="50dp"
    android:layout_height="50dp"/>

ड्रा करने योग्य परिभाषा:

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android">
    <solid android:color="#FFFFFF"/>
    <stroke
        android:color="#edf0f6"
        android:width="1dp"/>
    <corners android:radius="3dp"/>

</shape>

इस तरह एक वैल्यूएनीमेटर बनाएँ और उसका उपयोग करें:

final ValueAnimator valueAnimator = ValueAnimator.ofObject(new ArgbEvaluator(),
                                                           0xFFFFFFFF,
                                                           0xff78c5f9);

final GradientDrawable background = (GradientDrawable) view.getBackground();
currentAnimation.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

    @Override
    public void onAnimationUpdate(final ValueAnimator animator) {
        background.setColor((Integer) animator.getAnimatedValue());
    }

});
currentAnimation.setDuration(300);
currentAnimation.start();

परिवर्तन करने योग्य :

देखें परिभाषा:

<View
    android:background="@drawable/example"
    android:layout_width="50dp"
    android:layout_height="50dp"/>

ड्रा करने योग्य परिभाषा:

<?xml version="1.0" encoding="utf-8"?>
<transition xmlns:android="http://schemas.android.com/apk/res/android">
    <item>
        <shape>
            <solid android:color="#FFFFFF"/>
            <stroke
                android:color="#edf0f6"
                android:width="1dp"/>
            <corners android:radius="3dp"/>
        </shape>
    </item>

    <item>
        <shape>
            <solid android:color="#78c5f9"/>
            <stroke
                android:color="#68aff4"
                android:width="1dp"/>
            <corners android:radius="3dp"/>
        </shape>
    </item>
</transition>

ट्रांज़िशनड्राइव का उपयोग इस तरह करें:

final TransitionDrawable background = (TransitionDrawable) view.getBackground();
background.startTransition(300);

आप .reverse()एनिमेशन उदाहरण पर कॉल करके एनिमेशन को उल्टा कर सकते हैं ।

एनिमेशन करने के कुछ और तरीके भी हैं लेकिन ये तीन शायद सबसे आम हैं। मैं आम तौर पर एक ValueAnimator का उपयोग करता हूं।


वास्तव में कोड में TransitionDrawable को परिभाषित करना और उपयोग करना संभव है, लेकिन किसी कारण से, यह दूसरी बार काम नहीं करता है। अजीब।
एंड्रॉइड डेवलपर

मैं ऑब्जेक्ट एनिमेटर का उपयोग तब भी कर पा रहा हूं, जब मेरे विचार में ColorDrawable सेट है। मैं इसे स्थानीय चर में सहेजता हूं, इसे शून्य पर सेट करता हूं और जब एनीमेशन समाप्त हो जाता है, तो मूल ColorDrawable वापस सेट करें।
मिलो .ernilovský

55

आप ऑब्जेक्ट एनिमेटर बना सकते हैं। उदाहरण के लिए, मेरे पास एक लक्षित दृश्य है और मैं आपकी पृष्ठभूमि का रंग बदलना चाहता हूं:

int colorFrom = Color.RED;
int colorTo = Color.GREEN;
int duration = 1000;
ObjectAnimator.ofObject(targetView, "backgroundColor", new ArgbEvaluator(), colorFrom, colorTo)
    .setDuration(duration)
    .start();

2
एपीआई 21 से, आप उपयोग कर सकते हैं ofArgb(targetView, "backgroundColor", colorFrom, colorTo)। इसका कार्यान्वयन सिर्फ है ofInt(...).setEvaluator(new ArgbEvaluator())
ypresto

20

यदि आप इस तरह से रंग एनीमेशन चाहते हैं,

यहां छवि विवरण दर्ज करें

यह कोड आपकी सहायता करेगा:

ValueAnimator anim = ValueAnimator.ofFloat(0, 1);   
anim.setDuration(2000);

float[] hsv;
int runColor;
int hue = 0;
hsv = new float[3]; // Transition color
hsv[1] = 1;
hsv[2] = 1;
anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

    @Override
    public void onAnimationUpdate(ValueAnimator animation) {

        hsv[0] = 360 * animation.getAnimatedFraction();

        runColor = Color.HSVToColor(hsv);
        yourView.setBackgroundColor(runColor);
    }
});

anim.setRepeatCount(Animation.INFINITE);

anim.start();

9
जब ऐनिमेटेड वैरिएबल को इनिशियलाइज़ किया जाता है तो वह भाग कहाँ है ?
VoW

@VoW, यह सिर्फ ValueAnimator का उदाहरण है।
RBK

यह anim.setRepeatCount(ValueAnimator.INFINITE);एनिमेशन नहीं होना चाहिए। अभी के लिए यह एक ही है, लेकिन हमारे पास कोई गारंटी नहीं है
मिखाइल क्रिशटॉप

@MikhailKrishtop एनिमेशन में क्या गलत है। INFINITE? डेवलपर
RBK

14

सबसे अच्छा तरीका है ValueAnimator और का उपयोग करनाColorUtils.blendARGB

 ValueAnimator valueAnimator = ValueAnimator.ofFloat(0.0f, 1.0f);
 valueAnimator.setDuration(325);
 valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator valueAnimator) {

              float fractionAnim = (float) valueAnimator.getAnimatedValue();

              view.setBackgroundColor(ColorUtils.blendARGB(Color.parseColor("#FFFFFF")
                                    , Color.parseColor("#000000")
                                    , fractionAnim));
        }
});
valueAnimator.start();

12

इसे प्राप्त करने का एक और आसान तरीका है, अल्फाएनीमेशन का उपयोग करके फीका प्रदर्शन करना।

  1. अपने दृश्य को एक व्यूग्रुप बनाएं
  2. Index_parent लेआउट आयामों के साथ इसे 0 पर एक बच्चा दृश्य जोड़ें
  3. अपने बच्चे को कंटेनर के समान पृष्ठभूमि दें
  4. कंटेनर की पृष्ठभूमि को लक्ष्य रंग में बदलें
  5. अल्फाएनीमेशन का उपयोग करके बच्चे को बाहर निकाल दें।
  6. एनिमेशन पूरा होने पर बच्चे को निकालें (एक एनिमेशनलिस्ट का उपयोग करके)

9

यह वह तरीका है जिसका उपयोग मैं आधार गतिविधि में पृष्ठभूमि बदलने के लिए करता हूं। मैं कोड में उत्पन्न ग्रेडिएंड्रैबल्स का उपयोग कर रहा हूं, लेकिन इसे सूट करने के लिए अनुकूलित किया जा सकता है।

    protected void setPageBackground(View root, int type){
        if (root!=null) {
            Drawable currentBG = root.getBackground();
            //add your own logic here to determine the newBG 
            Drawable newBG = Utils.createGradientDrawable(type); 
            if (currentBG==null) {
                if(Build.VERSION.SDK_INT<Build.VERSION_CODES.JELLY_BEAN){
                    root.setBackgroundDrawable(newBG);
                }else{
                    root.setBackground(newBG);
                }
            }else{
                TransitionDrawable transitionDrawable = new TransitionDrawable(new Drawable[]{currentBG, newBG});
                transitionDrawable.setCrossFadeEnabled(true);
                if(Build.VERSION.SDK_INT<Build.VERSION_CODES.JELLY_BEAN){
                     root.setBackgroundDrawable(transitionDrawable);
                }else{
                    root.setBackground(transitionDrawable);
                }
                transitionDrawable.startTransition(400);
            }
        }
    }

अद्यतन: अगर कोई भी उसी मुद्दे पर चलता है जो मैंने पाया है, तो एंड्रॉइड पर किसी कारण से <4.3 setCrossFadeEnabled(true)एक अवांछनीय सफेद आउट प्रभाव का उपयोग करता है इसलिए मुझे <4.3 के लिए एक ठोस रंग पर स्विच करना पड़ा @ रुमेन मिनोक वैल्यूएनिमेटर विधि ऊपर उल्लेखित है।


यही वह है जिसकी तलाश में मैं हूं। धन्यवाद! :)
साइबर 3

7

उत्तर कई तरीकों से दिया जाता है। तुम भी उपयोग कर सकते हैं ofArgb(startColor,endColor)की ValueAnimator

API के लिए> 21:

int cyanColorBg = ContextCompat.getColor(this,R.color.cyan_bg);
int purpleColorBg = ContextCompat.getColor(this,R.color.purple_bg);

ValueAnimator valueAnimator = ValueAnimator.ofArgb(cyanColorBg,purpleColorBg);
        valueAnimator.setDuration(500);
        valueAnimator.setInterpolator(new LinearInterpolator());
        valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
              @Override
              public void onAnimationUpdate(ValueAnimator valueAnimator) {
                   relativeLayout.setBackgroundColor((Integer)valueAnimator.getAnimatedValue());
              }
        });
        valueAnimator.start();

7

XML संचालित एनिमेशन पर प्रलेखन भयानक है। आप उपयोग कर सकते हैं: मैं घंटे के आसपास बस एक बटन की पृष्ठभूमि का रंग चेतन करने के लिए जब दबाने ... दुखद बात है कि एनीमेशन केवल एक विशेषता की दूरी पर है खोज की है exitFadeDurationमें selector:

<selector xmlns:android="http://schemas.android.com/apk/res/android"
    android:exitFadeDuration="200">

    <item android:state_pressed="true">
        <shape android:tint="#3F51B5" />
    </item>

    <item>
        <shape android:tint="#F44336" />
    </item>

</selector>

तो बस इसे backgroundअपने विचार के रूप में उपयोग करें। कोई जावा / कोटलिन कोड की आवश्यकता नहीं है।


आपने मेरा दिन बचाया। धन्यवाद।
फेडरिको हेइलैंड

1
बहुत बढ़िया जवाब। ध्यान दें कि आपको आवश्यकता हो सकती है android:enterFadeDuration; मेरा अनुभव यह था कि, इसके बिना, मेरा एनीमेशन दूसरी बार काम नहीं करता था।
स्ट्रिंग

7

यहाँ एक अच्छा कार्य है जो यह अनुमति देता है:

public static void animateBetweenColors(final @NonNull View viewToAnimateItsBackground, final int colorFrom,
                                        final int colorTo, final int durationInMs) {
    final ColorDrawable colorDrawable = new ColorDrawable(durationInMs > 0 ? colorFrom : colorTo);
    ViewCompat.setBackground(viewToAnimateItsBackground, colorDrawable);
    if (durationInMs > 0) {
        final ValueAnimator colorAnimation = ValueAnimator.ofObject(new ArgbEvaluator(), colorFrom, colorTo);
        colorAnimation.addUpdateListener(animator -> {
            colorDrawable.setColor((Integer) animator.getAnimatedValue());
            ViewCompat.setBackground(viewToAnimateItsBackground, colorDrawable);
        });
        colorAnimation.setDuration(durationInMs);
        colorAnimation.start();
    }
}

और कोटलिन में:

@JvmStatic
fun animateBetweenColors(viewToAnimateItsBackground: View, colorFrom: Int, colorTo: Int, durationInMs: Int) {
    val colorDrawable = ColorDrawable(if (durationInMs > 0) colorFrom else colorTo)
    ViewCompat.setBackground(viewToAnimateItsBackground, colorDrawable)
    if (durationInMs > 0) {
        val colorAnimation = ValueAnimator.ofObject(ArgbEvaluator(), colorFrom, colorTo)
        colorAnimation.addUpdateListener { animator: ValueAnimator ->
            colorDrawable.color = (animator.animatedValue as Int)
            ViewCompat.setBackground(viewToAnimateItsBackground, colorDrawable)
        }
        colorAnimation.duration = durationInMs.toLong()
        colorAnimation.start()
    }
}

यह कम अंत संस्करण फोन का समर्थन नहीं करता है
कार्तिक के

2
@ Kartheeks आप Android 10 और नीचे का मतलब है? यदि हां, तो आप आसानी से इसका समर्थन करने के लिए एक "नौOldAndroids" लाइब्रेरी का उपयोग कर सकते हैं: 9oldandroids.com । वाक्य-विन्यास लगभग समान है।
एंड्रॉयड डेवलपर

निम्न संस्करण के लिए colorAnimation.addUpdateListener (new ValueAnimator.AnimatorUpdateListener) () {@Override public void onAnimationUpdate (ValueAnimator एनीमेशन) {colorDrawable.setColor ((पूर्णांक) एनीमेशन। ;
महबूबुर्रहमान खान

5

Res फ़ोल्डर में एक फ़ोल्डर एनिमेटर जोड़ें । (नाम एनिमेटर होना चाहिए )। एक एनिमेटर संसाधन फ़ाइल जोड़ें। उदाहरण के लिए res / animator / fade.xml

<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
    <objectAnimator
        android:propertyName="backgroundColor"
        android:duration="1000"
        android:valueFrom="#000000"
        android:valueTo="#FFFFFF"
        android:startOffset="0"
        android:repeatCount="-1"
        android:repeatMode="reverse" />
</set>

गतिविधि जावा फ़ाइल के अंदर, इसे कॉल करें

View v = getWindow().getDecorView().findViewById(android.R.id.content);
AnimatorSet set = (AnimatorSet) AnimatorInflater.loadAnimator(this, R.animator.fade);
set.setTarget(v);
set.start();

3

कोटलिन के लिए नीचे दिए गए फ़ंक्शन का उपयोग करें:

private fun animateColorValue(view: View) {
    val colorAnimation =
        ValueAnimator.ofObject(ArgbEvaluator(), Color.GRAY, Color.CYAN)
    colorAnimation.duration = 500L
    colorAnimation.addUpdateListener { animator -> view.setBackgroundColor(animator.animatedValue as Int) }
    colorAnimation.start()
}

जो भी आप रंग बदलना चाहते हैं उसे पास करें।


2

मैंने पाया है कि कार्यान्वयन द्वारा उपयोग किया जाता है ArgbEvaluator एंड्रॉइड सोर्स कोड रंगों को परिवर्तित करने में सबसे अच्छा काम करता है। एचएसवी का उपयोग करते समय, दो रंगों के आधार पर, संक्रमण मेरे लिए बहुत अधिक संकेत के माध्यम से कूद रहा था। लेकिन यह तरीका नहीं है।

आप बस चेतन करने की कोशिश कर रहे हैं, तो उपयोग ArgbEvaluatorके साथ ValueAnimatorके रूप में सुझाव यहाँ :

ValueAnimator colorAnimation = ValueAnimator.ofObject(new ArgbEvaluator(), colorFrom, colorTo);
colorAnimation.addUpdateListener(new AnimatorUpdateListener() {

    @Override
    public void onAnimationUpdate(ValueAnimator animator) {
        view.setBackgroundColor((int) animator.getAnimatedValue());
    }

});
colorAnimation.start();

हालाँकि, यदि आप मेरे जैसे हैं और किसी इनपुट से पारित उपयोगकर्ता के इशारे या अन्य मूल्य के साथ अपने संक्रमण को बाँधना चाहते हैं, तो ValueAnimatorबहुत अधिक मदद नहीं मिलती है (जब तक कि आप एपीआई 22 और उससे अधिक के लिए लक्षित नहीं होते हैं, उस स्थिति में आप ValueAnimator.setCurrentFraction()विधि का उपयोग कर सकते हैं )। एपीआई 22 से नीचे लक्ष्य करते समय, ArgbEvaluatorस्रोत कोड में पाए गए कोड को अपनी विधि में लपेटें , जैसा कि नीचे दिखाया गया है:

public static int interpolateColor(float fraction, int startValue, int endValue) {
    int startA = (startValue >> 24) & 0xff;
    int startR = (startValue >> 16) & 0xff;
    int startG = (startValue >> 8) & 0xff;
    int startB = startValue & 0xff;
    int endA = (endValue >> 24) & 0xff;
    int endR = (endValue >> 16) & 0xff;
    int endG = (endValue >> 8) & 0xff;
    int endB = endValue & 0xff;
    return ((startA + (int) (fraction * (endA - startA))) << 24) |
            ((startR + (int) (fraction * (endR - startR))) << 16) |
            ((startG + (int) (fraction * (endG - startG))) << 8) |
            ((startB + (int) (fraction * (endB - startB))));
}

और इसका उपयोग आप चाहें तो करें।


0

Ademar111190 के उत्तर के आधार पर , मैंने इस विधि को किसी भी दो रंगों के बीच एक दृश्य की पृष्ठभूमि रंग को स्पंदित किया है:

private void animateBackground(View view, int colorFrom, int colorTo, int duration) {


    ObjectAnimator objectAnimator = ObjectAnimator.ofObject(view, "backgroundColor", new ArgbEvaluator(), colorFrom, colorTo);
    objectAnimator.setDuration(duration);
    //objectAnimator.setRepeatCount(Animation.INFINITE);
    objectAnimator.addListener(new Animator.AnimatorListener() {
        @Override
        public void onAnimationStart(Animator animation) {

        }

        @Override
        public void onAnimationEnd(Animator animation) {
            // Call this method again, but with the two colors switched around.
            animateBackground(view, colorTo, colorFrom, duration);
        }

        @Override
        public void onAnimationCancel(Animator animation) {

        }

        @Override
        public void onAnimationRepeat(Animator animation) {

        }
    });
    objectAnimator.start();
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.