Android में Handler का उपयोग: बैकग्राउंड थ्रेड से UI अपडेट करना

Handler क्या है?

Android में Handler एक मैकेनिज्म है जो बैकग्राउंड थ्रेड से मेन (UI) थ्रेड पर मैसेज या रननेबल भेजने की अनुमति देता है। Android का सिंगल-थ्रेड मॉडल UI ऑपरेशन्स को केवल मेन थ्रेड पर चलाने की अनुमति देता है, इसलिए Handler थ्रेड्स के बीच संचार के लिए आवश्यक है।

Handler के दो मुख्य मेथड्स

• post(Runnable) - एक Runnable को मेन थ्रेड के मैसेज क्यू में पोस्ट करता है
• sendMessage(Message) - एक Message ऑब्जेक्ट भेजता है जिसे handleMessage() में प्रोसेस किया जाता है

उदाहरण: ProgressDialog के साथ Handler का उपयोग

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="https://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <Button
        android:id="@+id/startBtn"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="डाउनलोड शुरू करें"
        android:layout_gravity="center" />

</androidx.constraintlayout.widget.ConstraintLayout>

MainActivity.java

import android.app.ProgressDialog;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.view.View;
import android.widget.Button;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {
    private Handler mainHandler;
    private ProgressDialog progressDialog;

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

        // मेन थ्रेड के Looper से जुड़ा Handler बनाएं
        mainHandler = new Handler(Looper.getMainLooper());

        Button startBtn = findViewById(R.id.startBtn);
        startBtn.setOnClickListener(v -> startDownloadSimulation());
    }

    private void startDownloadSimulation() {
        progressDialog = new ProgressDialog(this);
        progressDialog.setTitle("डाउनलोड हो रहा है...");
        progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
        progressDialog.setMax(100);
        progressDialog.setCancelable(false);
        progressDialog.show();

        // बैकग्राउंड थ्रेड में काम करें
        new Thread(() -> {
            try {
                for (int progress = 0; progress <= 100; progress += 5) {
                    Thread.sleep(200); // नेटवर्क देरी का अनुकरण

                    final int currentProgress = progress;
                    // UI थ्रेड पर अपडेट करने के लिए Handler का उपयोग करें
                    mainHandler.post(() -> {
                        progressDialog.setProgress(currentProgress);
                    });
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                mainHandler.post(() -> {
                    if (progressDialog != null && progressDialog.isShowing()) {
                        progressDialog.dismiss();
                    }
                });
            }
        }).start();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // मेमोरी लीक से बचने के लिए कॉलबैक हटाएं
        mainHandler.removeCallbacksAndMessages(null);
    }
}

आधुनिक विकल्प (Kotlin Coroutines / RxJava / LiveData)

नए प्रोजेक्ट्स के लिए, Handler के बजाय इनका उपयोग करने की सिफारिश की जाती है:

• Kotlin Coroutines - withContext(Dispatchers.Main) के साथ
• Flow / LiveData - रिएक्टिव UI अपडेट के लिए
• ExecutorService - बैकग्राउंड कार्य के लिए

Handler के साथ सामान्य गलतियाँ

• मेमोरी लीक: एक्टिविटी नष्ट होने पर Handler में पेंडिंग मैसेज रहते हैं। removeCallbacksAndMessages(null) का उपयोग करें।
• गलत Looper: बैकग्राउंड थ्रेड पर new Handler() बनाने से वह उस थ्रेड के Looper से जुड़ जाता है। हमेशा new Handler(Looper.getMainLooper()) उपयोग करें।
• डिप्रिकेटेड कंस्ट्रक्टर: new Handler() API 30+ में डिप्रिकेटेड है।

सारांश

Handler Android में थ्रेड संचार का मूलभूत उपकरण है। हालांकि आधुनिक विकल्प मौजूद हैं, लीगेसी कोडबेस और सरल उपयोग के मामलों में यह अभी भी व्यापक रूप से उपयोग किया जाता है।