ubscription এবং Disposable

RxJava-তে Subscription এবং Disposable হলো দুটি গুরুত্বপূর্ণ উপাদান যা Observable এবং Observer এর মধ্যে যোগাযোগ এবং রিসোর্স ব্যবস্থাপনা নিশ্চিত করে।

1. Subscription

Subscription হলো সেই প্রক্রিয়া যা Observer কে Observable-এ যুক্ত (subscribe) করে। যখন একটি Observer কোনো Observable-এ সাবস্ক্রাইব করে, তখন একটি Subscription তৈরি হয়, যা এই সংযোগ নিয়ন্ত্রণ করে।

উদাহরণ:

Observable<String> observable = Observable.just("Hello", "RxJava", "World");

// Subscription তৈরি
Subscription subscription = observable.subscribe(
    item -> System.out.println("Received: " + item),   // onNext
    error -> System.err.println("Error: " + error),   // onError
    () -> System.out.println("Completed!")           // onComplete
);

2. Disposable

Disposable হলো এমন একটি ইন্টারফেস যা Observable এবং Observer এর মধ্যে সংযোগ এবং রিসোর্স ব্যবস্থাপনা করে।

যখন একটি Observable সাবস্ক্রিপশন তৈরি করে, তখন এটি একটি Disposable অবজেক্ট ফেরত দেয়। এই Disposable এর মাধ্যমে আপনি সাবস্ক্রিপশনটি বাতিল (dispose) করতে পারেন এবং রিসোর্স মুক্ত করতে পারেন।

মূল পয়েন্ট:

• dispose() মেথড ব্যবহার করে একটি সাবস্ক্রিপশন বন্ধ করা যায়।
• এটি গুরুত্বপূর্ণ বিশেষ করে তখন, যখন আপনাকে নিশ্চিত করতে হয় যে অ্যাসিঙ্ক্রোনাস কাজ শেষ হওয়ার পর কোনো অপ্রয়োজনীয় রিসোর্স ব্যবহার না হয়।

উদাহরণ: Disposable ব্যবহার

import io.reactivex.Observable;
import io.reactivex.disposables.Disposable;

public class RxJavaDisposableExample {
    public static void main(String[] args) {
        Observable<String> observable = Observable.just("Hello", "RxJava", "World");

        // Disposable তৈরি
        Disposable disposable = observable.subscribe(
            item -> System.out.println("Received: " + item),   // onNext
            error -> System.err.println("Error: " + error),    // onError
            () -> System.out.println("Completed!")            // onComplete
        );

        // সাবস্ক্রিপশন বন্ধ করা
        if (!disposable.isDisposed()) {
            disposable.dispose();
            System.out.println("Subscription disposed!");
        }
    }
}

আউটপুট:

Received: Hello
Received: RxJava
Received: World
Completed!
Subscription disposed!

3. CompositeDisposable

যখন একাধিক Disposable এর ব্যবস্থাপনা প্রয়োজন হয়, তখন CompositeDisposable ব্যবহার করা হয়। এটি একাধিক Disposable একত্রে পরিচালনা করতে সাহায্য করে এবং সমস্ত সাবস্ক্রিপশন একবারে dispose() করার সুযোগ দেয়।

উদাহরণ: CompositeDisposable ব্যবহার

import io.reactivex.Observable;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.disposables.Disposable;

public class CompositeDisposableExample {
    public static void main(String[] args) {
        CompositeDisposable compositeDisposable = new CompositeDisposable();

        Observable<String> observable1 = Observable.just("Stream 1");
        Observable<String> observable2 = Observable.just("Stream 2");

        // প্রথম Disposable
        Disposable disposable1 = observable1.subscribe(item -> System.out.println("Received: " + item));

        // দ্বিতীয় Disposable
        Disposable disposable2 = observable2.subscribe(item -> System.out.println("Received: " + item));

        // CompositeDisposable-এ যোগ করা
        compositeDisposable.add(disposable1);
        compositeDisposable.add(disposable2);

        // সমস্ত সাবস্ক্রিপশন বন্ধ করা
        compositeDisposable.dispose();
        System.out.println("All subscriptions disposed!");
    }
}

আউটপুট:

Received: Stream 1
Received: Stream 2
All subscriptions disposed!

সংক্ষেপে:

• Subscription: Observer এবং Observable এর মধ্যে সংযোগ তৈরি করে।
• Disposable: এই সংযোগটি বন্ধ এবং রিসোর্স মুক্ত করতে ব্যবহৃত হয়।
• CompositeDisposable: একাধিক Disposable পরিচালনা করার জন্য একটি কনটেইনার।

RxJava-তে Subscription এবং Disposable ব্যবহারের গুরুত্ব:

1. মেমরি লিক এড়ানো: অপ্রয়োজনীয় কাজ চলতে থাকা থেকে রক্ষা করে।
2. রিসোর্স অপ্টিমাইজেশন: অ্যাপ্লিকেশনকে দ্রুত এবং কার্যকর করে তোলে।
3. ব্যবস্থাপনা সহজ: বিশেষ করে যখন অ্যাপ্লিকেশনে একাধিক ডেটা স্ট্রিম থাকে।

এটি একটি রিঅ্যাকটিভ প্রোগ্রামিংয়ের অপরিহার্য অংশ। 😊

Subscription RxJava-তে একটি প্রক্রিয়া বা মেকানিজম, যা Observable এবং Observer এর মধ্যে সংযোগ স্থাপন করে। এটি মূলত Observable থেকে emitted ডেটা Observer-এ পাঠানোর কাজটি সক্রিয় করে।

Subscription এর মাধ্যমে আপনি Observable এর ডেটা স্ট্রিম consume করতে পারেন এবং প্রয়োজন হলে ডেটা স্ট্রিম থেকে নিজেকে unsubscribe (detach) করতে পারেন, যা memory leaks প্রতিরোধে গুরুত্বপূর্ণ।

Subscription এর প্রয়োজনীয়তা

Subscription এর প্রয়োজনীয়তা বিভিন্ন দিক থেকে বোঝা যায়:

1. Observable এবং Observer এর মধ্যে লিঙ্ক স্থাপন:
   Subscription তৈরি না হলে Observable থেকে emitted ডেটা Observer-এ পৌঁছাবে না। Subscription কার্যকর করলে এটি সেই স্ট্রিমকে সক্রিয় করে।
2. Data Consumption Control:
   Subscription ব্যবহারের মাধ্যমে আপনি ডেটা স্ট্রিমের lifecycle এবং flow নিয়ন্ত্রণ করতে পারেন।
3. Unsubscribe করার সুবিধা:
   দীর্ঘমেয়াদী ডেটা স্ট্রিম বা asynchronous operations-এর ক্ষেত্রে, যখন Observable-এর আর প্রয়োজন নেই, তখন Subscription বন্ধ (unsubscribe/dispose) করা গুরুত্বপূর্ণ।
   এটি memory leaks রোধ করতে সহায়তা করে।
4. Multiple Subscribers এর সমর্থন:
   Subscription এর মাধ্যমে একটি Observable-এ একাধিক Observer যুক্ত হতে পারে এবং তারা আলাদাভাবে ডেটা consume করতে পারে।

Subscription এর কাজ করার পদ্ধতি

RxJava-তে Subscription সাধারণত Observable.subscribe() মেথড কল করার মাধ্যমে তৈরি হয়।

Observable<String> observable = Observable.just("Hello", "RxJava");
Disposable subscription = observable.subscribe(
    item -> System.out.println("Received: " + item), // onNext
    throwable -> System.err.println("Error: " + throwable), // onError
    () -> System.out.println("Completed!") // onComplete
);

Unsubscribe বা Dispose

RxJava-তে unsubscribe করার জন্য Disposable ইন্টারফেস ব্যবহার করা হয়। যখন আর Observable-এর প্রয়োজন নেই, তখন dispose() মেথড কল করে Subscription বন্ধ করতে পারেন।

উদাহরণ:

Disposable disposable = Observable.just("Data")
    .subscribe(
        data -> System.out.println("Received: " + data)
    );

// Unsubscribe to prevent memory leaks
disposable.dispose();

কেন Subscription গুরুত্বপূর্ণ?

1. Resource Management:
   Subscription বন্ধ (dispose) না করলে memory leaks হতে পারে। বিশেষ করে Android-এর মতো environment-এ যেখানে lifecycle পরিবর্তনশীল।
2. Lifecycle-aware Operations:
   Subscription ব্যবহার করে আপনি operations lifecycle-aware করতে পারেন।
   উদাহরণ: Activity destroy হলে Subscription dispose করা।
3. Error Management:
   Subscription এর মাধ্যমে error events handle করা সহজ।
4. Multiple Streams:
   Subscription-এর সাহায্যে একাধিক Observable-এর ডেটা পৃথকভাবে manage করা যায়।

CompositeDisposable:

যখন একাধিক Subscription থাকে, তখন তাদের collectively manage করার জন্য CompositeDisposable ব্যবহার করা হয়। এটি একবারেই সমস্ত Subscription dispose করতে সাহায্য করে।

CompositeDisposable compositeDisposable = new CompositeDisposable();

Disposable disposable1 = Observable.just("Data 1").subscribe();
Disposable disposable2 = Observable.just("Data 2").subscribe();

compositeDisposable.add(disposable1);
compositeDisposable.add(disposable2);

// Dispose all at once
compositeDisposable.dispose();

সংক্ষেপে:

Subscription RxJava-তে একটি গুরুত্বপূর্ণ উপাদান, যা Observable এবং Observer এর মধ্যে ডেটা স্ট্রিম সক্রিয় করে এবং নিয়ন্ত্রণ করতে সাহায্য করে। এটি ডেটা ব্যবস্থাপনা, resource cleanup, এবং error handling-এর জন্য অত্যন্ত প্রয়োজনীয়।

RxJava-তে Disposable হলো একটি ইন্টারফেস, যা Subscription পরিচালনা করতে সাহায্য করে। যখন একটি Observable এবং Observer-এর মধ্যে subscription হয়, তখন এটি asynchronous স্ট্রিম চালাতে শুরু করে। কোনো নির্দিষ্ট সময়ে subscription বন্ধ করার প্রয়োজন হতে পারে, যাতে memory leaks এড়ানো যায়। এই কাজটি Disposable-এর মাধ্যমে করা হয়।

Disposable-এর ভূমিকা:

1. Subscription বন্ধ করা:
   Subscription চালু থাকা অবস্থায় যখন আর প্রয়োজন নেই, তখন dispose() মেথডের মাধ্যমে subscription বন্ধ করা যায়।
2. Memory Leak এড়ানো:
   দীর্ঘ সময় ধরে subscription চালু থাকলে memory leak হতে পারে। Disposable ব্যবহার করে এ ধরনের সমস্যা এড়ানো যায়।
3. Lifecycle Management:
   Subscription বন্ধ করা lifecycle-এর একটি গুরুত্বপূর্ণ অংশ, বিশেষ করে Android অ্যাপ্লিকেশনে যেখানে Activity বা Fragment destroy হওয়ার সঙ্গে subscription বন্ধ করতে হয়।

Disposable-এর ব্যবহার:

সাধারণ উদাহরণ:

import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.disposables.Disposable;

public class DisposableExample {
    public static void main(String[] args) {
        // Observable তৈরি করা
        Observable<String> observable = Observable.just("Item 1", "Item 2", "Item 3");
        
        // Subscription এবং Disposable গ্রহণ করা
        Disposable disposable = observable.subscribe(
            item -> System.out.println("Received: " + item),  // onNext
            error -> System.err.println("Error: " + error),   // onError
            () -> System.out.println("Complete!")            // onComplete
        );

        // Subscription বন্ধ করা
        disposable.dispose();

        System.out.println("Is disposed: " + disposable.isDisposed());
    }
}

বর্ণনা:

• subscribe() মেথডের রিটার্ন টাইপ হলো Disposable।
• dispose() মেথডটি ডাকা হলে subscription বন্ধ হয়ে যায়।

CompositeDisposable:

একটি অ্যাপ্লিকেশনে অনেক Disposable থাকতে পারে। একাধিক subscription একসঙ্গে পরিচালনা করতে CompositeDisposable ব্যবহার করা হয়। এটি Disposable-এর একটি সংগ্রহ।

CompositeDisposable উদাহরণ:

import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.disposables.CompositeDisposable;
import io.reactivex.rxjava3.disposables.Disposable;

public class CompositeDisposableExample {
    public static void main(String[] args) {
        CompositeDisposable compositeDisposable = new CompositeDisposable();

        Observable<String> observable1 = Observable.just("Observable 1");
        Observable<String> observable2 = Observable.just("Observable 2");

        // প্রথম Disposable যোগ করা
        Disposable disposable1 = observable1.subscribe(
            item -> System.out.println("Received from observable1: " + item)
        );

        // দ্বিতীয় Disposable যোগ করা
        Disposable disposable2 = observable2.subscribe(
            item -> System.out.println("Received from observable2: " + item)
        );

        // CompositeDisposable-এ Disposable যোগ করা
        compositeDisposable.add(disposable1);
        compositeDisposable.add(disposable2);

        // সব Disposable বন্ধ করা
        compositeDisposable.dispose();

        System.out.println("Are all disposed: " + compositeDisposable.isDisposed());
    }
}

বর্ণনা:

• CompositeDisposable-এ একাধিক Disposable যোগ করা যায়।
• একবার dispose() কল করলে সব Disposable বন্ধ হয়ে যায়।

Android অ্যাপ্লিকেশনে Disposable-এর ব্যবহার:

Android অ্যাপে Activity বা Fragment destroy হওয়ার সময় subscription বন্ধ করা গুরুত্বপূর্ণ। Disposable এই কাজটি lifecycle-aware পদ্ধতিতে করতে সাহায্য করে।

Android উদাহরণ:

public class MainActivity extends AppCompatActivity {
    private CompositeDisposable compositeDisposable = new CompositeDisposable();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Observable<String> observable = Observable.just("Hello", "RxJava");

        // Subscription তৈরি এবং CompositeDisposable-এ যোগ করা
        Disposable disposable = observable
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(item -> Log.d("RxJava", "Received: " + item));

        compositeDisposable.add(disposable);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        // সমস্ত Disposable বন্ধ করা
        compositeDisposable.clear();
    }
}

বর্ণনা:

• onCreate()-এ subscription শুরু হয় এবং onDestroy()-এ subscription বন্ধ হয়।
• compositeDisposable.clear() ডাকা হলে সব Disposable বন্ধ হয়ে যায়।

Disposable ব্যবহারের সুবিধাসমূহ:

1. Memory Management: দীর্ঘ সময় ধরে চলা subscription-এর কারণে memory leak হওয়া প্রতিরোধ করে।
2. Lifecycle Management: Activity বা Fragment destroy হওয়ার সময় subscription বন্ধ করা সহজ হয়।
3. Concurrency Control: একাধিক subscription সহজে পরিচালনা করা যায়।
4. Readable Code: Disposable কোডের জটিলতা কমিয়ে পড়া এবং রক্ষণাবেক্ষণ সহজ করে।

RxJava-তে Disposable একটি গুরুত্বপূর্ণ উপাদান, বিশেষ করে asynchronous stream ব্যবস্থাপনার জন্য। এটি কোডকে আরও দক্ষ এবং পরিষ্কার করে তোলে।

RxJava-তে Multiple Subscription এবং Unsubscription গুরুত্বপূর্ণ বিষয়, বিশেষত যখন অ্যাপ্লিকেশন অ্যাসিনক্রোনাস কাজ এবং ডেটা স্ট্রিম পরিচালনা করে। এখানে এই দুইটি বিষয় বিস্তারিতভাবে আলোচনা করা হলো:

Multiple Subscription

RxJava-তে একই Observable-এ একাধিক Observer বা সাবস্ক্রাইবার সংযুক্ত হতে পারে।

উদাহরণ: Multiple Subscription

import io.reactivex.rxjava3.core.Observable;

public class MultipleSubscriptionExample {
    public static void main(String[] args) {
        Observable<String> observable = Observable.just("Hello", "RxJava!");

        // First Subscription
        observable.subscribe(data -> System.out.println("Subscriber 1: " + data));

        // Second Subscription
        observable.subscribe(data -> System.out.println("Subscriber 2: " + data));
    }
}

আউটপুট:

Subscriber 1: Hello  
Subscriber 1: RxJava!  
Subscriber 2: Hello  
Subscriber 2: RxJava!  

Multiple Subscription ব্যবহারের ক্ষেত্রে বিষয়সমূহ:

1. Cold Observable:
   • প্রতিটি সাবস্ক্রিপশন নতুনভাবে ডেটা স্ট্রিম তৈরি করে।
   • উদাহরণ: Observable.just() বা Observable.fromIterable()।
2. Hot Observable:
   • একই স্ট্রিম সকল সাবস্ক্রাইবার শেয়ার করে।
   • উদাহরণ: PublishSubject, BehaviorSubject।
   • Hot Observable ব্যবহার করলে সকল সাবস্ক্রাইবার একই ডেটা পায়।

Unsubscription

RxJava-তে Observer বা সাবস্ক্রাইবার একটি স্ট্রিমে সাবস্ক্রাইব করার পরে সেটি বন্ধ বা unsubscribe করা প্রয়োজন হতে পারে, বিশেষত রিসোর্স লিক এড়াতে।

Disposable:

RxJava Disposable ইন্টারফেস সরবরাহ করে, যা সাবস্ক্রিপশন বন্ধ করার জন্য ব্যবহৃত হয়।

উদাহরণ: Unsubscription

import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.disposables.Disposable;

public class UnsubscriptionExample {
    public static void main(String[] args) {
        Observable<Long> observable = Observable.create(emitter -> {
            for (long i = 0; i < 10; i++) {
                if (emitter.isDisposed()) {
                    return; // Stop emitting if unsubscribed
                }
                emitter.onNext(i);
                Thread.sleep(100); // Simulate delay
            }
            emitter.onComplete();
        });

        // Subscribe and get the Disposable
        Disposable disposable = observable.subscribe(
            data -> System.out.println("Received: " + data),
            Throwable::printStackTrace,
            () -> System.out.println("Completed!")
        );

        // Unsubscribe after some time
        try {
            Thread.sleep(300); // Allow some data to emit
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        disposable.dispose(); // Unsubscribe from the observable
        System.out.println("Unsubscribed!");
    }
}

আউটপুট:

Received: 0  
Received: 1  
Received: 2  
Unsubscribed!  

CompositeDisposable for Multiple Subscriptions

RxJava-তে যখন একাধিক Disposable থাকে, তখন তাদের ব্যবস্থাপনার জন্য CompositeDisposable ব্যবহার করা হয়। এটি একসাথে একাধিক সাবস্ক্রিপশন dispose করতে সাহায্য করে।

উদাহরণ: CompositeDisposable

import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.disposables.CompositeDisposable;
import io.reactivex.rxjava3.disposables.Disposable;

public class CompositeDisposableExample {
    public static void main(String[] args) {
        CompositeDisposable compositeDisposable = new CompositeDisposable();

        // First Observable
        Observable<String> observable1 = Observable.just("First Observable");
        Disposable disposable1 = observable1.subscribe(data -> System.out.println(data));

        // Second Observable
        Observable<String> observable2 = Observable.just("Second Observable");
        Disposable disposable2 = observable2.subscribe(data -> System.out.println(data));

        // Add to CompositeDisposable
        compositeDisposable.add(disposable1);
        compositeDisposable.add(disposable2);

        // Dispose all subscriptions
        compositeDisposable.dispose();
        System.out.println("All subscriptions disposed!");
    }
}

আউটপুট:

First Observable  
Second Observable  
All subscriptions disposed!  

Unsubscription ব্যবহারের সুবিধা:

1. মেমোরি লিক প্রতিরোধ:
   সাবস্ক্রিপশন বন্ধ করা না হলে অ্যাপ্লিকেশনে মেমোরি লিক হতে পারে।
2. রিসোর্স ব্যবস্থাপনা সহজ:
   Disposable বা CompositeDisposable ব্যবহার করে রিসোর্সগুলোর কার্যকর ব্যবস্থাপনা করা যায়।
3. থ্রেড ম্যানেজমেন্ট সহজ:
   সাবস্ক্রিপশন বন্ধ করলে থ্রেড বা ব্যাকগ্রাউন্ড কাজ বন্ধ হয়।

উপসংহার

RxJava-তে Multiple Subscription এবং Unsubscription ব্যবস্থাপনা সঠিকভাবে করা অত্যন্ত গুরুত্বপূর্ণ। Disposable এবং CompositeDisposable ব্যবহার করলে অ্যাপ্লিকেশন আরও কার্যকর, মেমোরি লিক মুক্ত এবং রিসোর্স ব্যবহারে দক্ষ হয়।

RxJava-তে Subscription এবং Disposable হল Observable এবং Observer-এর মধ্যে সম্পর্ক পরিচালনার জন্য ব্যবহৃত গুরুত্বপূর্ণ উপাদান।

Subscription:

Subscription হল Observable এবং Observer-এর সংযোগ। যখন একটি Observer একটি Observable-এ subscribe করে, তখন Subscription তৈরি হয়। এটি data stream গ্রহণ শুরু করার প্রক্রিয়া নির্দেশ করে।

Disposable:

Disposable হল একটি interface যা Subscription বন্ধ বা বাতিল করার জন্য ব্যবহৃত হয়। এটি memory leak এড়াতে ব্যবহৃত হয়, বিশেষ করে যখন Observable অনির্দিষ্টকালের জন্য data emit করতে পারে।

উদাহরণ:

নিচের উদাহরণে Subscription এবং Disposable এর ব্যবহার দেখানো হয়েছে:

import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.disposables.Disposable;

public class RxJavaSubscriptionExample {
    public static void main(String[] args) {
        // Create an Observable
        Observable<String> observable = Observable.create(emitter -> {
            emitter.onNext("Item 1");
            emitter.onNext("Item 2");
            emitter.onNext("Item 3");
            emitter.onComplete();
        });

        // Subscribe to the Observable and get the Disposable
        Disposable disposable = observable.subscribe(
            item -> System.out.println("Received: " + item),   // onNext
            error -> System.err.println("Error: " + error),    // onError
            () -> System.out.println("Stream complete!")       // onComplete
        );

        // Check if the subscription is still active
        if (!disposable.isDisposed()) {
            System.out.println("Subscription is active.");
        }

        // Dispose the subscription
        disposable.dispose();

        // Verify if the subscription has been disposed
        if (disposable.isDisposed()) {
            System.out.println("Subscription has been disposed.");
        }
    }
}

কোড ব্যাখ্যা:

1. Observable তৈরি করা:
   • Observable data emit করছে (onNext) এবং শেষে stream বন্ধ করছে (onComplete)।
2. Subscription:
   • observable.subscribe()-এ Observer এর জন্য onNext, onError, এবং onComplete হ্যান্ডলার পাস করা হয়েছে।
3. Disposable ব্যবহার:
   • Disposable disposable = observable.subscribe() ডিভাইসটি সংরক্ষণ করছে।
   • disposable.dispose() এর মাধ্যমে subscription বন্ধ করা হয়েছে।
   • isDisposed() এর মাধ্যমে subscription বন্ধ হয়েছে কিনা তা যাচাই করা হয়েছে।

Disposable-এর গুরুত্বপূর্ণ ব্যবহার:

1. Memory Leak এড়ানো:
   • Long-running Observables-এ subscription বন্ধ না করলে memory leak হতে পারে। Disposable ব্যবহার করে এটি এড়ানো যায়।
2. Android Context Management:
   • Activity বা Fragment ধ্বংস হওয়ার সময় (e.g., configuration change) subscription বন্ধ করার জন্য Disposable ব্যবহার করা হয়।

Android Context-এ Disposable-এর উদাহরণ:

import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.disposables.CompositeDisposable;

public class RxJavaAndroidExample {
    private CompositeDisposable compositeDisposable = new CompositeDisposable();

    public void fetchData() {
        Observable<String> observable = Observable.just("Data 1", "Data 2", "Data 3");

        // Add subscription to CompositeDisposable
        compositeDisposable.add(
            observable.subscribe(
                item -> System.out.println("Received: " + item),
                error -> System.err.println("Error: " + error),
                () -> System.out.println("Stream complete!")
            )
        );
    }

    public void onDestroy() {
        // Dispose all subscriptions when Activity or Fragment is destroyed
        compositeDisposable.clear();
    }
}

কোড ব্যাখ্যা:

1. CompositeDisposable:
   • একাধিক Disposable একত্রে পরিচালনা করতে ব্যবহৃত হয়।
2. onDestroy():
   • Activity বা Fragment ধ্বংস হওয়ার সময় compositeDisposable.clear() ডাকা হয়, যা সমস্ত subscription বন্ধ করে।

সারমর্ম:

• Subscription: Observable থেকে data stream পাওয়ার সংযোগ।
• Disposable: Subscription বন্ধ করার পদ্ধতি।
• CompositeDisposable: একাধিক subscription একত্রে পরিচালনা করার জন্য ব্যবহৃত।

Disposable এবং CompositeDisposable সঠিকভাবে ব্যবহার করা না হলে memory leak-এর ঝুঁকি থেকে যায়। তাই এগুলো ব্যবহারে সতর্ক থাকা উচিত।