फ़ोरग्राउंड सेवा लॉन्च करना

अपने ऐप्लिकेशन से फ़ोरग्राउंड सेवा लॉन्च करने के लिए, आपको दो चरण पूरे करने होंगे. सबसे पहले, आपको context.startForegroundService() को कॉल करके सेवा शुरू करनी होगी. इसके बाद, सेवा को ServiceCompat.startForeground() को कॉल करना होगा, ताकि वह फ़ोरग्राउंड सेवा के तौर पर प्रमोट हो सके.

ज़रूरी शर्तें

आपका ऐप्लिकेशन जिस एपीआई लेवल को टारगेट करता है उसके हिसाब से, इस बात पर कुछ पाबंदियां लागू होती हैं कि कोई ऐप्लिकेशन फ़ोरग्राउंड सेवा कब लॉन्च कर सकता है.

• Android 12 (एपीआई लेवल 31) या इसके बाद के वर्शन को टारगेट करने वाले ऐप्लिकेशन को, बैकग्राउंड में होने पर फ़ोरग्राउंड सेवा शुरू करने की अनुमति नहीं है. हालांकि, कुछ खास मामलों में ऐसा किया जा सकता है. ज़्यादा जानकारी के लिए और इस नियम के अपवादों के बारे में जानने के लिए, बैकग्राउंड से फ़ोरग्राउंड सेवा शुरू करने पर पाबंदियां लेख पढ़ें.

• Android 14 (एपीआई लेवल 34) या इसके बाद के वर्शन को टारगेट करने वाले ऐप्लिकेशन को, फ़ोरग्राउंड सेवा के टाइप के लिए सही अनुमतियों का अनुरोध करना होगा. जब ऐप्लिकेशन किसी सेवा को फ़ोरग्राउंड में प्रमोट करने की कोशिश करता है, तो सिस्टम सही अनुमतियों की जांच करता है. अगर ऐप्लिकेशन में कोई अनुमति मौजूद नहीं है, तो सिस्टम SecurityException दिखाता है. उदाहरण के लिए, अगर आपको location टाइप की फ़ोरग्राउंड सेवा लॉन्च करनी है, तो सिस्टम यह जांच करता है कि आपके ऐप्लिकेशन के पास पहले से ही ACCESS_COARSE_LOCATION या ACCESS_FINE_LOCATION की अनुमति है या नहीं. फ़ोरग्राउंड सेवा के टाइप के दस्तावेज़ में, हर फ़ोरग्राउंड सेवा के टाइप के लिए ज़रूरी शर्तें दी गई हैं.

कोई सेवा लॉन्च करना

फ़ोरग्राउंड सेवा लॉन्च करने के लिए, आपको पहले इसे सामान्य (नॉन-फ़ोरग्राउंड) सेवा के तौर पर लॉन्च करना होगा:

val intent = Intent(...) // Build the intent for the service
context.startForegroundService(intent)

Context context = getApplicationContext();
Intent intent = new Intent(...); // Build the intent for the service
context.startForegroundService(intent);

कोड के बारे में अहम जानकारी

• यह कोड स्निपेट, एक सेवा लॉन्च करता है. हालांकि, यह सेवा अब भी फ़ोरग्राउंड में नहीं चल रही है. सेवा के अंदर ही, आपको ServiceCompat.startForeground() को कॉल करना होगा, ताकि सेवा को फ़ोरग्राउंड सेवा के तौर पर प्रमोट किया जा सके.

किसी सेवा को फ़ोरग्राउंड में प्रमोट करना

कोई सेवा चालू होने के बाद, आपको ServiceCompat.startForeground() को कॉल करना होगा, ताकि सेवा फ़ोरग्राउंड में चल सके. आम तौर पर, इस तरीके को सेवा के onStartCommand() तरीके में कॉल किया जाता है.

ServiceCompat.startForeground() इन पैरामीटर का इस्तेमाल करता है:

• सेवा.
• यह एक पॉज़िटिव पूर्णांक होता है. यह स्टेटस बार में सेवा की सूचना की यूनीक तरीके से पहचान करता है.
• Notification ऑब्जेक्ट.
• फ़ोरग्राउंड सेवा का टाइप या टाइप जिससे सेवा के काम की पहचान होती है

फ़ोरग्राउंड सेवा के टाइप, startForeground() मेनिफ़ेस्ट में बताए गए टाइप से मेल खाने चाहिए. हालांकि, यह इस्तेमाल के उदाहरण पर निर्भर करता है. इसके बाद, अगर आपको और सेवा टाइप जोड़ने हैं, तो startForeground() को फिर से कॉल करें.

उदाहरण के लिए, मान लें कि कोई फ़िटनेस ऐप्लिकेशन, रनिंग-ट्रैकर सेवा चलाता है. इस सेवा को हमेशा location जानकारी की ज़रूरत होती है. हालांकि, हो सकता है कि इसे मीडिया चलाने की ज़रूरत हो या न हो. आपको मेनिफ़ेस्ट में location और mediaPlayback, दोनों के बारे में बताना होगा. अगर कोई उपयोगकर्ता दौड़ना शुरू करता है और उसे सिर्फ़ अपनी जगह की जानकारी ट्रैक करनी है, तो आपके ऐप्लिकेशन को startForeground() को कॉल करना चाहिए और सिर्फ़ ACCESS_FINE_LOCATION की अनुमति देनी चाहिए. इसके बाद, अगर उपयोगकर्ता को ऑडियो चलाना है, तो startForeground() को फिर से कॉल करें और फ़ोरग्राउंड सेवा के सभी टाइप का बिटवाइज़ कॉम्बिनेशन पास करें. इस मामले में, ACCESS_FINE_LOCATION|FOREGROUND_SERVICE_MEDIA_PLAYBACK.

यहां दिए गए उदाहरण में, वह कोड दिखाया गया है जिसका इस्तेमाल कैमरा सेवा, फ़ोरग्राउंड सेवा के तौर पर खुद का प्रमोशन करने के लिए करेगी:

class MyCameraService: Service() {

  private fun startForeground() {
    // Before starting the service as foreground check that the app has the
    // appropriate runtime permissions. In this case, verify that the user has
    // granted the CAMERA permission.
    val cameraPermission =
            PermissionChecker.checkSelfPermission(this, Manifest.permission.CAMERA)
    if (cameraPermission != PermissionChecker.PERMISSION_GRANTED) {
        // Without camera permissions the service cannot run in the foreground
        // Consider informing user or updating your app UI if visible.
        stopSelf()
        return
    }

    try {
        val notification = NotificationCompat.Builder(this, "CHANNEL_ID")
            // Create the notification to display while the service is running
            .build()
        ServiceCompat.startForeground(
            /* service = */ this,
            /* id = */ 100, // Cannot be 0
            /* notification = */ notification,
            /* foregroundServiceType = */
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
                ServiceInfo.FOREGROUND_SERVICE_TYPE_CAMERA
            } else {
                0
            },
        )
    } catch (e: Exception) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
                && e is ForegroundServiceStartNotAllowedException) {
            // App not in a valid state to start foreground service
            // (e.g. started from bg)
        }
        // ...
    }
  }
}

public class MyCameraService extends Service {

    private void startForeground() {
        // Before starting the service as foreground check that the app has the
        // appropriate runtime permissions. In this case, verify that the user
        // has granted the CAMERA permission.
        int cameraPermission =
            ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA);
        if (cameraPermission == PackageManager.PERMISSION_DENIED) {
            // Without camera permissions the service cannot run in the
            // foreground. Consider informing user or updating your app UI if
            // visible.
            stopSelf();
            return;
        }

        try {
            Notification notification =
                new NotificationCompat.Builder(this, "CHANNEL_ID")
                    // Create the notification to display while the service
                    // is running
                    .build();
            int type = 0;
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
                type = ServiceInfo.FOREGROUND_SERVICE_TYPE_CAMERA;
            }
            ServiceCompat.startForeground(
                    /* service = */ this,
                    /* id = */ 100, // Cannot be 0
                    /* notification = */ notification,
                    /* foregroundServiceType = */ type
            );
        } catch (Exception e) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S &&
                    e instanceof ForegroundServiceStartNotAllowedException
            ) {
                // App not in a valid state to start foreground service
                // (e.g started from bg)
            }
            // ...
        }
    }

    //...
}

कोड के बारे में अहम जानकारी

• ऐप्लिकेशन ने मेनिफ़ेस्ट में पहले ही यह जानकारी दे दी है कि उसे CAMERA अनुमति की ज़रूरत है. हालांकि, ऐप्लिकेशन को रनटाइम के दौरान भी यह जांच करनी होगी कि उपयोगकर्ता ने अनुमति दी है या नहीं. अगर ऐप्लिकेशन के पास सही अनुमतियां नहीं हैं, तो उसे उपयोगकर्ता को इस समस्या के बारे में बताना चाहिए.
• Android प्लैटफ़ॉर्म के अलग-अलग वर्शन के साथ, फ़ोरग्राउंड सेवा के अलग-अलग टाइप पेश किए गए थे. यह कोड यह पता लगाता है कि यह Android के किस वर्शन पर चल रहा है. साथ ही, यह ज़रूरी अनुमतियों का अनुरोध करता है.
• अगर कोड ऐसी स्थिति में फ़ोरग्राउंड सेवा शुरू करने की कोशिश कर रहा है जिसकी अनुमति नहीं है, तो वह ForegroundServiceStartNotAllowedException की जांच करता है. उदाहरण के लिए, अगर ऐप्लिकेशन बैकग्राउंड में होने के दौरान सेवा को फ़ोरग्राउंड में प्रमोट करने की कोशिश की जा रही है.