Android में देरी कैसे सेट करें?

Question

public void onClick(View v) {
        // TODO Auto-generated method stub
        switch(v.getId()){
        case R.id.rollDice:
            Random ranNum = new Random();
            int number = ranNum.nextInt(6) + 1;
            diceNum.setText(""+number);
            sum = sum + number;
            for(i=0;i<8;i++){
                for(j=0;j<8;j++){

                    int value =(Integer)buttons[i][j].getTag();
                    if(value==sum){
                        inew=i;
                        jnew=j;

                        buttons[inew][jnew].setBackgroundColor(Color.BLACK);
                                                //I want to insert a delay here
                        buttons[inew][jnew].setBackgroundColor(Color.WHITE);
                         break;                     
                    }
                }
            }


            break;

        }
    }

मैं पृष्ठभूमि बदलने के बीच कमांड के बीच देरी सेट करना चाहता हूं। मैंने थ्रेड टाइमर का उपयोग करके रन और कैच का उपयोग करने की कोशिश की। लेकिन यह काम नहीं कर रहा है। मैंने यह कोशिश की

 Thread timer = new Thread() {
            public void run(){
                try {
                                buttons[inew][jnew].setBackgroundColor(Color.BLACK);
                    sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

             }
           };
    timer.start();
   buttons[inew][jnew].setBackgroundColor(Color.WHITE);

लेकिन यह केवल काले रंग में परिवर्तित हो रहा है।

Answer 1

इस कोड को आज़माएं:

import android.os.Handler;
...
final Handler handler = new Handler();
handler.postDelayed(new Runnable() {
    @Override
    public void run() {
        // Do something after 5s = 5000ms
        buttons[inew][jnew].setBackgroundColor(Color.BLACK);
    }
}, 5000);

Comments

इस समाधान ने उन सभी सवालों को समझाया जो कोड की कुछ पंक्तियों में हैंडलर के पास थे।

— सिरिसीमो

मैं हमेशा इस पद पर वापस आता हूं क्योंकि मैं हर बार इसे लिखने के लिए बहुत आलसी हूं। धन्यवाद।

— यूजीन एच

अच्छी तरह से यह अच्छा है, लेकिन मैं बहुत से संदेश के लिए प्रतीक्षा करने के लिए फिर दिखाने के लिए है। इसलिए बहुस्तरीय समस्याएँ समस्याएँ देती हैं। कैसे कई समस्याएँ हल कर सकते हैं

— mehmet

यह समाधान एक मेमोरी रिसाव पैदा करता है क्योंकि यह एक गैर-स्थैतिक आंतरिक और अनाम वर्ग का उपयोग करता है जो स्पष्ट रूप से अपने बाहरी वर्ग, गतिविधि का संदर्भ रखता है। बेहतर समाधान के लिए stackoverflow.com/questions/1520887/… देखें ।

— ट्रॉनमैन 15

@EugeneH आसान जीवन के लिए लाइव टेम्पलेट्स का उपयोग करें stackoverflow.com/a/16870791/4565796

— सईद अर्यानमनेश

Answer 2

आप उपयोग कर सकते हैं CountDownTimerजो पोस्ट किए गए किसी भी अन्य समाधान की तुलना में बहुत अधिक कुशल है। तुम भी अपने का उपयोग कर रास्ते के अंतराल पर नियमित रूप से सूचनाओं का उत्पादन कर सकते onTick(long)विधि

इस उदाहरण पर एक नज़र डालें जो 30 सेकंड की उलटी गिनती दिखा रहा है

   new CountDownTimer(30000, 1000) {
         public void onFinish() {
             // When timer is finished 
             // Execute your code here
     }

     public void onTick(long millisUntilFinished) {
              // millisUntilFinished    The amount of time until finished.
     }
   }.start();

Answer 3

यदि आप अपने ऐप में अक्सर देरी का उपयोग करते हैं, तो इस उपयोगिता वर्ग का उपयोग करें

import android.os.Handler;


public class Utils {

    // Delay mechanism

    public interface DelayCallback{
        void afterDelay();
    }

    public static void delay(int secs, final DelayCallback delayCallback){
        Handler handler = new Handler();
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                delayCallback.afterDelay();
            }
        }, secs * 1000); // afterDelay will be executed after (secs*1000) milliseconds.
    }
}

उपयोग:

// Call this method directly from java file

int secs = 2; // Delay in seconds

Utils.delay(secs, new Utils.DelayCallback() {
    @Override
    public void afterDelay() {
        // Do something after delay

    }
});

Comments

क्यों ? यह शुद्ध उपरि और जटिलता है ... कुछ भी नहीं के लिए

— juloo65

यदि हम बार-बार देरी का उपयोग करते हैं, तो देरी के लिए एक निश्चित प्रारूप होना ठीक है। मुझे नहीं लगता कि एक अतिरिक्त इंटरफ़ेस और एक विधि के कारण बहुत अधिक ओवरहेड है।

— अरुण

Answer 4

Thread.sleep(millis)विधि का उपयोग करना ।

Comments

UI थ्रेड पर ऐसा न करें - अन्य तत्व भी प्रतिक्रिया देना बंद कर सकते हैं और बाद में अप्रत्याशित व्यवहार कर सकते हैं

— 1923

चेतावनी के लिए धन्यवाद। UI थ्रेड को विलंबित करने के लिए वास्तव में वही चाहिए जो मुझे चाहिए। मेरी जरूरतों के लिए एकदम सही जवाब। धन्यवाद।

— बजे

Answer 5

यदि आप नियमित समय अंतराल पर यूआई में कुछ करना चाहते हैं तो काउंटडाउनटिमर का उपयोग करना बहुत अच्छा विकल्प है:

new CountDownTimer(30000, 1000) {

     public void onTick(long millisUntilFinished) {
         mTextField.setText("seconds remaining: " + millisUntilFinished / 1000);
     }

     public void onFinish() {
         mTextField.setText("done!");
     }
  }.start();

Comments

यह हैंडलर से ज्यादा साफ है ।

— अहसन

Answer 6

कोटलिन में हैंडलर का जवाब:

1 - एक फ़ाइल के अंदर एक शीर्ष-स्तरीय फ़ंक्शन बनाएं (उदाहरण के लिए एक फ़ाइल जिसमें आपके सभी शीर्ष-स्तरीय फ़ंक्शन शामिल हैं):

fun delayFunction(function: ()-> Unit, delay: Long) {
    Handler().postDelayed(function, delay)
}

2 - फिर इसे कहीं भी कॉल करें आपको इसकी आवश्यकता है:

delayFunction({ myDelayedFunction() }, 300)

Answer 7

आप इसका उपयोग कर सकते हैं:

import java.util.Timer;

और देरी के लिए, जोड़ें:

 new Timer().schedule(
                    new TimerTask(){
                
                        @Override
                        public void run(){
                            
                        //if you need some code to run when the delay expires
                        }
                        
                    }, delay);

जहां delayचर मिलीसेकंड में है; उदाहरण के delayलिए 5 सेकंड की देरी के लिए 5000 पर सेट करें।

Answer 8

यहां एक उदाहरण है जहां मैं 2 सेकंड की अल्फा फीका देरी के साथ पृष्ठभूमि की छवि को एक से दूसरे में बदल देता हूं - मूल छवि के 2 एस फीते को 2 एस में दूसरी छवि में फीका कर देता है।

    public void fadeImageFunction(View view) {

    backgroundImage = (ImageView) findViewById(R.id.imageViewBackground);
    backgroundImage.animate().alpha(0f).setDuration(2000);

    // A new thread with a 2-second delay before changing the background image
    new Timer().schedule(
            new TimerTask(){
                @Override
                public void run(){
                    // you cannot touch the UI from another thread. This thread now calls a function on the main thread
                    changeBackgroundImage();
                }
            }, 2000);
   }

// this function runs on the main ui thread
private void changeBackgroundImage(){
    runOnUiThread(new Runnable() {
        @Override
        public void run() {
            backgroundImage = (ImageView) findViewById(R.id.imageViewBackground);
            backgroundImage.setImageResource(R.drawable.supes);
            backgroundImage.animate().alpha(1f).setDuration(2000);
        }
    });
}