ऐप बंद होने पर भी एंड्रॉइड नोटिफिकेशन कैसे प्राप्त करें?

यह गाइड दर्शाता है कि **फोरग्राउंड सर्विस** और **WorkManager** का उपयोग करके ऐप पूरी तरह से बंद (स्वाइप करके हाल के ऐप्स से हटाए जाने) के बाद भी नोटिफिकेशन कैसे डिलीवर किए जाएँ।

दृष्टिकोण तुलना

विधि 1: WorkManager (आधुनिक, अनुशंसित)

गारंटीकृत निष्पादन के साथ आवधिक/विलंबित नोटिफिकेशन के लिए सर्वोत्तम।

निर्भरताएँ (build.gradle)

dependencies {
    implementation "androidx.work:work-runtime-ktx:2.9.0"
    // या Java के लिए: implementation "androidx.work:work-runtime:2.9.0"
}

NotificationWorker.java

package com.example.backgroundnotification;

import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.core.app.NotificationCompat;
import androidx.work.Worker;
import androidx.work.WorkerParameters;

public class NotificationWorker extends Worker {

    private static final String CHANNEL_ID = "background_channel";
    private static final String CHANNEL_NAME = "पृष्ठभूमि नोटिफिकेशन";

    public NotificationWorker(@NonNull Context context, @NonNull WorkerParameters params) {
        super(context, params);
    }

    @NonNull
    @Override
    public Result doWork() {
        showNotification();
        return Result.success();
    }

    private void showNotification() {
        createNotificationChannel();

        NotificationCompat.Builder builder = new NotificationCompat.Builder(getApplicationContext(), CHANNEL_ID)
            .setSmallIcon(R.drawable.ic_launcher_foreground)
            .setContentTitle("पृष्ठभूमि नोटिफिकेशन")
            .setContentText("ऐप बंद होने पर भी डिलीवर किया गया!")
            .setPriority(NotificationCompat.PRIORITY_HIGH)
            .setAutoCancel(true);

        NotificationManager manager = (NotificationManager) getApplicationContext()
            .getSystemService(Context.NOTIFICATION_SERVICE);
        manager.notify((int) System.currentTimeMillis(), builder.build());
    }

    private void createNotificationChannel() {
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
            NotificationChannel channel = new NotificationChannel(
                CHANNEL_ID, CHANNEL_NAME, NotificationManager.IMPORTANCE_HIGH);
            NotificationManager manager = getApplicationContext().getSystemService(NotificationManager.class);
            manager.createNotificationChannel(channel);
        }
    }
}

MainActivity.java - WorkManager शेड्यूल करना

package com.example.backgroundnotification;

import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import androidx.work.ExistingPeriodicWorkPolicy;
import androidx.work.PeriodicWorkRequest;
import androidx.work.WorkManager;
import java.util.concurrent.TimeUnit;

public class MainActivity extends AppCompatActivity {

    private static final String WORK_NAME = "periodic_notification_work";

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

        // ऐप बंद होने पर भी हर 30 मिनट में नोटिफिकेशन शेड्यूल करें
        findViewById(R.id.btnSchedule).setOnClickListener(v -> schedulePeriodicNotification());
        findViewById(R.id.btnCancel).setOnClickListener(v -> cancelPeriodicNotification());
    }

    private void schedulePeriodicNotification() {
        PeriodicWorkRequest workRequest = new PeriodicWorkRequest.Builder(
            NotificationWorker.class, 30, TimeUnit.MINUTES)
            .build();

        WorkManager.getInstance(this).enqueueUniquePeriodicWork(
            WORK_NAME, 
            ExistingPeriodicWorkPolicy.KEEP, 
            workRequest);
    }

    private void cancelPeriodicNotification() {
        WorkManager.getInstance(this).cancelUniqueWork(WORK_NAME);
    }
}

विधि 2: फोरग्राउंड सर्विस (निरंतर पृष्ठभूमि उपस्थिति)

जब ऐप को सक्रिय रूप से पृष्ठभूमि में कुछ करते रहने की आवश्यकता होती है (उदाहरण के लिए, संगीत प्लेबैक, स्थान ट्रैकिंग)।

NotificationService.java

package com.example.backgroundnotification;

import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import androidx.annotation.Nullable;
import androidx.core.app.NotificationCompat;

public class NotificationService extends Service {

    private static final String CHANNEL_ID = "foreground_service_channel";
    private static final int NOTIFICATION_ID = 1001;

    @Override
    public void onCreate() {
        super.onCreate();
        createNotificationChannel();
        startForeground(NOTIFICATION_ID, buildNotification());
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // पृष्ठभूमि कार्य यहाँ करें
        // समय-समय पर नोटिफिकेशन दिखाने के लिए टाइमर/हैंडलर शेड्यूल कर सकते हैं
        return START_STICKY; // मार दिए जाने पर पुनः आरंभ करता है
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    private Notification buildNotification() {
        return new NotificationCompat.Builder(this, CHANNEL_ID)
            .setSmallIcon(R.drawable.ic_launcher_foreground)
            .setContentTitle("फोरग्राउंड सर्विस सक्रिय")
            .setContentText("पृष्ठभूमि में चल रहा है - नोटिफिकेशन डिलीवर कर सकता है")
            .setPriority(NotificationCompat.PRIORITY_LOW) // कम प्राथमिकता = कम दखल देने वाला
            .setOngoing(true)
            .build();
    }

    private void createNotificationChannel() {
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
            NotificationChannel channel = new NotificationChannel(
                CHANNEL_ID, "फोरग्राउंड सर्विस", NotificationManager.IMPORTANCE_LOW);
            channel.setDescription("पृष्ठभूमि संचालन के लिए फोरग्राउंड सर्विस चैनल");
            NotificationManager manager = getSystemService(NotificationManager.class);
            manager.createNotificationChannel(channel);
        }
    }
}

सेवा शुरू करना (MainActivity से)

// फोरग्राउंड सर्विस शुरू करें (ऐप "बंद" होने पर भी चलती रहती है)
Intent serviceIntent = new Intent(this, NotificationService.class);
ContextCompat.startForegroundService(this, serviceIntent);

// बाद में रोकने के लिए:
stopService(new Intent(this, NotificationService.class));

AndroidManifest.xml - आवश्यक अनुमतियाँ और घोषणाएँ

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="https://schemas.android.com/apk/res/android"
    package="com.example.backgroundnotification">

    <!-- Android 13+ के लिए नोटिफिकेशन अनुमति -->
    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
    
    <!-- फोरग्राउंड सर्विस के लिए (Android 9+) -->
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.BackgroundNotification">

        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <!-- फोरग्राउंड सर्विस घोषणा -->
        <service
            android:name=".NotificationService"
            android:exported="false"
            android:foregroundServiceType="dataSync" />

        <!-- WorkManager स्वतः पंजीकृत होता है -->
    </application>
</manifest>

महत्वपूर्ण: Android 13+ (API 33) नोटिफिकेशन अनुमति

रनटाइम पर अनुरोध करना आवश्यक:

// एक्टिविटी में, नोटिफिकेशन दिखाने से पहले:
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
    if (checkSelfPermission(Manifest.permission.POST_NOTIFICATIONS) 
        != PackageManager.PERMISSION_GRANTED) {
        requestPermissions(new String[]{Manifest.permission.POST_NOTIFICATIONS}, 1001);
    }
}

सर्वोत्तम अभ्यास सारांश

1. WorkManager का उपयोग करें आवधिक/विलंबित नोटिफिकेशन के लिए - बैटरी-अनुकूलित, सिस्टम-प्रबंधित
2. फोरग्राउंड सर्विस का उपयोग करें निरंतर पृष्ठभूमि संचालन के लिए - दृश्यमान नोटिफिकेशन आवश्यक
3. FCM का उपयोग करें सर्वर-आरंभित पुश के लिए - सबसे विश्वसनीय डिलीवरी
4. POST_NOTIFICATIONS अनुमति Android 13+ पर रनटाइम पर अनुरोध करें
5. नोटिफिकेशन चैनल सभी Android 8.0+ नोटिफिकेशन के लिए बनाएँ

चेतावनी

बहुत अधिक पृष्ठभूमि नोटिफिकेशन भेजने से उपयोगकर्ता द्वारा ऐप अनइंस्टॉल किया जा सकता है या सिस्टम द्वारा प्रतिबंधित किया जा सकता है। Android के पावर प्रबंधन (डोज़, ऐप स्टैंडबाय) का सम्मान करें।