गतिविधि की पहचान करने की सुविधा के ट्रांज़िशन एपीआई का कोडलैब

1. शुरुआती जानकारी

हम फ़ोन को हर जगह अपने साथ ले जाते हैं. हालांकि, अब तक ऐप्लिकेशन के लिए, उपयोगकर्ता के लगातार बदलते माहौल और गतिविधि के हिसाब से अपने अनुभव को अडजस्ट करना मुश्किल रहा है.

पहले, डेवलपर को इंजीनियरिंग में काफ़ी समय लगता था. वे अलग-अलग सिग्नल (जगह की जानकारी, सेंसर वगैरह) को मिलाकर यह पता लगाते थे कि पैदल चलने या गाड़ी चलाने जैसी कोई गतिविधि कब शुरू हुई या कब खत्म हुई. इससे भी बुरी बात यह है कि जब ऐप्लिकेशन, उपयोगकर्ता की गतिविधि में होने वाले बदलावों की लगातार जांच करते हैं, तो बैटरी लाइफ़ पर असर पड़ता है.

Activity Recognition Transition API इन समस्याओं को हल करता है. यह एक आसान एपीआई उपलब्ध कराता है, जो आपके लिए सभी प्रोसेसिंग करता है. साथ ही, आपको सिर्फ़ यह बताता है कि उपयोगकर्ता की गतिविधि कब बदली है. आपका ऐप्लिकेशन, आपकी दिलचस्पी वाली गतिविधियों में होने वाले बदलावों की सूचना पाने के लिए सदस्यता लेता है. इसके बाद, एपीआई आपको बदलावों के बारे में सूचना देता है

उदाहरण के लिए, कोई मैसेजिंग ऐप्लिकेशन, "मुझे बताओ कि उपयोगकर्ता ने वाहन में कब प्रवेश किया या उससे कब बाहर निकला", ताकि उपयोगकर्ता की स्थिति को व्यस्त के तौर पर सेट किया जा सके. इसी तरह, पार्किंग की जगह का पता लगाने वाला ऐप्लिकेशन,उपयोगकर्ता की पार्किंग की जगह सेव करने के लिए, "मुझे बताओ कि उपयोगकर्ता ने वाहन से उतरकर चलना कब शुरू किया" कह सकता है.

इस कोडलैब में, आपको Activity Recognition Transition API का इस्तेमाल करने का तरीका बताया जाएगा. इससे यह पता लगाया जा सकता है कि कोई उपयोगकर्ता कब चलना या दौड़ना शुरू करता है या बंद करता है.

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

Android डेवलपमेंट और कॉलबैक के बारे में कुछ जानकारी होनी चाहिए.

आपको क्या सीखने को मिलेगा

गतिविधि ट्रांज़िशन के लिए रजिस्टर करना
उन इवेंट को प्रोसेस करना
जब गतिविधि में बदलाव की ज़रूरत न हो, तब उसके लिए रजिस्टर न करना

आपको इन चीज़ों की ज़रूरत होगी

Android Studio Bumblebee
Android डिवाइस या एम्युलेटर

2. शुरू करें

स्टार्टर प्रोजेक्ट रेपो का क्लोन बनाना

हम चाहते हैं कि आप जल्द से जल्द शुरुआत कर सकें. इसलिए, हमने आपके लिए एक शुरुआती प्रोजेक्ट तैयार किया है. अगर आपने git इंस्टॉल किया है, तो नीचे दिए गए निर्देश को चलाएं. (टर्मिनल / कमांड लाइन में git --version टाइप करके देखा जा सकता है कि यह सही तरीके से काम कर रहा है या नहीं.)

 git clone https://github.com/android/codelab-activity_transitionapi

अगर आपके पास git नहीं है, तो प्रोजेक्ट को zip फ़ाइल के तौर पर डाउनलोड किया जा सकता है:

प्रोजेक्ट इंपोर्ट करना

Android Studio शुरू करें. इसके बाद, वेलकम स्क्रीन पर "Open an existing Android Studio project" को चुनें और प्रोजेक्ट डायरेक्ट्री खोलें.

प्रोजेक्ट लोड होने के बाद, आपको यह सूचना भी दिख सकती है कि Git आपके सभी लोकल बदलावों को ट्रैक नहीं कर रहा है. इसके लिए, ऊपर दाईं ओर मौजूद "अनदेखा करें" या "X" पर क्लिक करें. (Git रेपो में कोई भी बदलाव वापस नहीं भेजा जाएगा.)

अगर आप Android व्यू में हैं, तो आपको प्रोजेक्ट विंडो के ऊपरी-बाएं कोने में, नीचे दी गई इमेज जैसा कुछ दिखेगा. (अगर आप प्रोजेक्ट व्यू में हैं, तो आपको प्रोजेक्ट को बड़ा करके देखना होगा.)

यहां दो फ़ोल्डर आइकॉन (base और complete) दिए गए हैं. इनमें से हर एक को "मॉड्यूल" कहा जाता है.

कृपया ध्यान दें कि Android Studio को पहली बार बैकग्राउंड में प्रोजेक्ट को कंपाइल करने में कुछ सेकंड लग सकते हैं. इस दौरान, आपको Android Studio में सबसे नीचे मौजूद स्टेटस बार में एक स्पिनर दिखेगा:

हमारा सुझाव है कि कोड में बदलाव करने से पहले, इस प्रोसेस के पूरा होने का इंतज़ार करें. इससे Android Studio को सभी ज़रूरी कॉम्पोनेंट डाउनलोड करने की अनुमति मिल जाएगी.

इसके अलावा, अगर आपको "भाषा बदलने के लिए, क्या आपको पेज को फिर से लोड करना है?" या इससे मिलता-जुलता कोई प्रॉम्प्ट मिलता है, तो "हाँ" को चुनें.

स्टार्टर प्रोजेक्ट के बारे में जानकारी

ठीक है, आपने सेटअप कर लिया है. अब गतिविधि पहचानने की सुविधा जोड़ी जा सकती है. हम base मॉड्यूल का इस्तेमाल करेंगे. यह इस कोडलैब का शुरुआती पॉइंट है. दूसरे शब्दों में कहें, तो आपको हर चरण का कोड base में जोड़ना होगा.

complete मॉड्यूल का इस्तेमाल, अपने काम की जांच करने के लिए किया जा सकता है. इसके अलावा, अगर आपको कोई समस्या आती है, तो इसका इस्तेमाल रेफ़रंस के तौर पर भी किया जा सकता है.

मुख्य कॉम्पोनेंट की खास जानकारी:

MainActivity: इसमें गतिविधि पहचानने के लिए ज़रूरी सभी कोड शामिल होते हैं.

इम्यूलेटर सेटअप

अगर आपको Android एम्युलेटर सेट अप करने में मदद चाहिए, तो अपना ऐप्लिकेशन चलाएं लेख पढ़ें.

स्टार्टर प्रोजेक्ट चलाना

चलिए, अब हम अपना ऐप्लिकेशन चलाते हैं.

अपने Android डिवाइस को कंप्यूटर से कनेक्ट करें या एम्युलेटर शुरू करें.
टूलबार में, ड्रॉप-डाउन सिलेक्टर से base कॉन्फ़िगरेशन चुनें. इसके बाद, उसके बगल में मौजूद हरे रंग के त्रिकोण (चलाएं) बटन पर क्लिक करें:

आपको यहां ऐप्लिकेशन दिखेगा:

अब यह ऐप्लिकेशन, मैसेज प्रिंट करने के अलावा और कुछ नहीं करता. अब हम गतिविधि की पहचान करने की सुविधा जोड़ेंगे.

खास जानकारी

इस चरण में, आपने इनके बारे में सीखा:

कोड लैब के लिए सामान्य सेटअप.
हमारे ऐप्लिकेशन के बारे में बुनियादी जानकारी.
ऐप्लिकेशन को डिप्लॉय करने का तरीका.

3. लाइब्रेरी की समीक्षा करें और मेनिफ़ेस्ट में अनुमति जोड़ें

अपने ऐप्लिकेशन में Transition API का इस्तेमाल करने के लिए, आपको Google Location and Activity Recognition API के लिए डिपेंडेंसी का एलान करना होगा. साथ ही, ऐप्लिकेशन मेनिफ़ेस्ट में com.google.android.gms.permission.ACTIVITY_RECOGNITION अनुमति के बारे में बताना होगा.

build.gradle फ़ाइल में, TODO: Review play services library required for activity recognition खोजें. इस चरण (पहला चरण) के लिए, आपको कोई कार्रवाई करने की ज़रूरत नहीं है. बस, उस डिपेंडेंसी की समीक्षा करें जिसके बारे में हमने बताया है. यह ऐसा दिखना चाहिए:

    // TODO: Review play services library required for activity recognition.
    implementation 'com.google.android.gms:play-services-location:19.0.1'

base मॉड्यूल में, AndroidManifest.xml में TODO: Add both activity recognition permissions to the manifest खोजें. इसके बाद, नीचे दिए गए कोड को <manifest> एलिमेंट में जोड़ें.

<!-- TODO: Add both activity recognition permissions to the manifest. -->
<!-- Required for 28 and below. -->
<uses-permission android:name="com.google.android.gms.permission.ACTIVITY_RECOGNITION" />
<!-- Required for 29+. -->
<uses-permission android:name="android.permission.ACTIVITY_RECOGNITION" />

आपका कोड अब कुछ ऐसा दिखना चाहिए:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
         package="com.example.myapp">
<!-- TODO: Add both activity recognition permissions to the manifest. -->
<!-- Required for 28 and below. -->
<uses-permission android:name="com.google.android.gms.permission.ACTIVITY_RECOGNITION" />
<!-- Required for 29+. -->
<uses-permission android:name="android.permission.ACTIVITY_RECOGNITION" />

  ...
</manifest>

टिप्पणियों से पता चलता है कि Android 10 के लिए, आपको दूसरी अनुमति जोड़नी होगी. यह एपीआई वर्शन 29 में जोड़ी गई रनटाइम अनुमति के लिए ज़रूरी है.

हो गया! आपका ऐप्लिकेशन अब गतिविधि पहचानने की सुविधा के साथ काम कर सकता है. इसके लिए, हमें सिर्फ़ कोड जोड़ना होगा.

ऐप्लिकेशन चलाएं

Android Studio से अपना ऐप्लिकेशन चलाएं. यह बिलकुल वैसा ही दिखना चाहिए. हमने ट्रांज़िशन को ट्रैक करने के लिए, अभी तक कोई कोड नहीं जोड़ा है. यह अगले सेक्शन में होगा.

4. Android में रनटाइम अनुमतियों की जांच करना/अनुरोध करना

एपीआई वर्शन 28 और इससे पहले के वर्शन के लिए, हमारे पास अनुमति है. हालांकि, हमें एपीआई वर्शन 29 और इसके बाद के वर्शन में रनटाइम अनुमतियों का इस्तेमाल करना होगा:

MainActivity.java में, हम यह देखेंगे कि उपयोगकर्ता Android 10 (29) या इसके बाद के वर्शन का इस्तेमाल कर रहा है या नहीं. अगर वह इसका इस्तेमाल कर रहा है, तो हम गतिविधि पहचानने की अनुमतियों की जांच करेंगे.
अगर अनुमतियां नहीं दी जाती हैं, तो हम उपयोगकर्ता को स्प्लैश स्क्रीन (PermissionRationalActivity.java) पर भेजेंगे. इस स्क्रीन पर यह बताया जाएगा कि ऐप्लिकेशन को अनुमति की ज़रूरत क्यों है. साथ ही, उपयोगकर्ता को अनुमति देने का विकल्प भी मिलेगा.

Android वर्शन की जांच करने वाले कोड की समीक्षा करना

base मॉड्यूल में, MainActivity.java में जाकर TODO: Review check for devices with Android 10 (29+) खोजें. आपको यह कोड स्निपेट दिखेगा.

ध्यान दें, इस सेक्शन के लिए कोई कार्रवाई नहीं की गई है.

// TODO: Review check for devices with Android 10 (29+).
private boolean runningQOrLater =
    android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.Q;

जैसा कि पहले बताया गया है, Android 10 और इसके बाद के वर्शन में, आपको रनटाइम की अनुमति android.permission.ACTIVITY_RECOGNITION के लिए मंज़ूरी लेनी होगी. हम इस आसान जांच का इस्तेमाल यह तय करने के लिए करते हैं कि हमें रनटाइम की अनुमतियों की जांच करनी है या नहीं.

ज़रूरत पड़ने पर, गतिविधि की पहचान करने की सुविधा के लिए रनटाइम अनुमति की जांच करें

base मॉड्यूल में, MainActivity.java में जाकर TODO: Review permission check for 29+ खोजें. आपको यह कोड स्निपेट दिखेगा.

ध्यान दें, इस सेक्शन के लिए कोई कार्रवाई नहीं की गई है.

// TODO: Review permission check for 29+.
if (runningQOrLater) {

   return PackageManager.PERMISSION_GRANTED == ActivityCompat.checkSelfPermission(
           this,
           Manifest.permission.ACTIVITY_RECOGNITION
   );
} else {
   return true;
}

हम पिछले चरण में बनाए गए वैरिएबल का इस्तेमाल यह देखने के लिए करते हैं कि हमें रनटाइम की अनुमतियों की जांच करनी है या नहीं.

Android Q और इसके बाद के वर्शन के लिए, हम रनटाइम अनुमति की जांच करते हैं और उसका नतीजा दिखाते हैं. यह activityRecognitionPermissionApproved() नाम के बड़े तरीके का हिस्सा है. इससे डेवलपर को एक ही कॉल में पता चल जाता है कि हमें अनुमति का अनुरोध करना है या नहीं.

रनटाइम अनुमतियों का अनुरोध करना और गतिविधि की पहचान करने की सुविधा को चालू/बंद करना

base मॉड्यूल में, MainActivity.java में जाकर TODO: Enable/Disable activity tracking and ask for permissions if needed खोजें. टिप्पणी के बाद, यहां दिया गया कोड जोड़ें.

// TODO: Enable/Disable activity tracking and ask for permissions if needed.
if (activityRecognitionPermissionApproved()) {

   if (activityTrackingEnabled) {
      disableActivityTransitions();

   } else {
      enableActivityTransitions();
   }

} else {  
   // Request permission and start activity for result. If the permission is approved, we
   // want to make sure we start activity recognition tracking.
   Intent startIntent = new Intent(this, PermissionRationalActivity.class);
   startActivityForResult(startIntent, 0);

}

यहां हम पूछते हैं कि क्या गतिविधि पहचानने की सुविधा को अनुमति दी गई है. अगर ऐसा है और गतिविधि पहचानने की सुविधा पहले से चालू है, तो हम इसे बंद कर देते हैं. अगर ऐसा नहीं होता है, तो हम इसे चालू कर देते हैं.

अगर अनुमति नहीं दी जाती है, तो हम उपयोगकर्ता को स्प्लैश स्क्रीन वाली गतिविधि पर भेजते हैं. इसमें बताया जाता है कि हमें अनुमति क्यों चाहिए. साथ ही, उन्हें इसे चालू करने की अनुमति दी जाती है.

अनुमति के अनुरोध वाले कोड की समीक्षा करना

base मॉड्यूल में, PermissionRationalActivity.java में जाकर TODO: Review permission request for activity recognition खोजें. आपको यह कोड स्निपेट दिखेगा.

ध्यान दें, इस सेक्शन के लिए कोई कार्रवाई नहीं की गई है.

// TODO: Review permission request for activity recognition.
ActivityCompat.requestPermissions(
             this,
             new String[]{Manifest.permission.ACTIVITY_RECOGNITION},
             PERMISSION_REQUEST_ACTIVITY_RECOGNITION)

यह गतिविधि का सबसे अहम हिस्सा है और इसकी समीक्षा करना ज़रूरी है. जब उपयोगकर्ता अनुमति का अनुरोध करता है, तब कोड अनुमति के लिए अनुरोध ट्रिगर करता है.

इसके अलावा, PermissionRationalActivity.java क्लास में यह बताया जाता है कि उपयोगकर्ता को गतिविधि पहचानने की अनुमति क्यों देनी चाहिए (सबसे सही तरीका). उपयोगकर्ता, अभी नहीं बटन या जारी रखें बटन पर क्लिक कर सकता है. जारी रखें बटन पर क्लिक करने से, ऊपर दिया गया कोड ट्रिगर होता है.

अगर आपको ज़्यादा जानकारी चाहिए, तो फ़ाइल देखें.

5. गतिविधि में बदलावों के लिए रिसीवर को रजिस्टर/अनरजिस्टर करें

हम गतिविधि पहचानने वाले कोड को सेट अप करने से पहले, यह पक्का करना चाहते हैं कि हमारी गतिविधि, सिस्टम की ओर से की गई ट्रांज़िशन कार्रवाइयों को मैनेज कर सकती है.

ट्रांज़िशन के लिए BroadcastReceiver बनाना

base मॉड्यूल में, MainActivity.java में TODO: Create a BroadcastReceiver to listen for activity transitions खोजें. नीचे दिए गए स्निपेट को चिपकाएं.

// TODO: Create a BroadcastReceiver to listen for activity transitions.
// The receiver listens for the PendingIntent above that is triggered by the system when an
// activity transition occurs.
mTransitionsReceiver = new TransitionsReceiver();

ट्रांज़िशन के लिए BroadcastReceiver रजिस्टर करना

base मॉड्यूल में, MainActivity.java में TODO: Register a BroadcastReceiver to listen for activity transitions खोजें. (यह onStart() में है). नीचे दिए गए स्निपेट को चिपकाएं.

// TODO: Register a BroadcastReceiver to listen for activity transitions.
registerReceiver(mTransitionsReceiver, new IntentFilter(TRANSITIONS_RECEIVER_ACTION));

अब हमारे पास अपडेट पाने का एक तरीका है. इससे PendingIntent के ज़रिए गतिविधि के ट्रांज़िशन की जानकारी मिलती है.

Unregister BroadcastReceiver

base मॉड्यूल में, MainActivity.java में जाकर Unregister activity transition receiver when user leaves the app खोजें. (यह onStop() में है).नीचे दिए गए स्निपेट को चिपकाएं.

// TODO: Unregister activity transition receiver when user leaves the app.
unregisterReceiver(mTransitionsReceiver);

Activity बंद होने पर, रिसीवर को अनरजिस्टर करना सबसे सही तरीका है.

6. गतिविधि में बदलाव होने पर सूचना पाने की सुविधा सेट अप करना और अपडेट का अनुरोध करना

गतिविधि में बदलाव होने पर अपडेट पाने के लिए, आपको ये लागू करने होंगे:

ActivityTransitionRequest ऑब्जेक्ट, जो गतिविधि और ट्रांज़िशन के टाइप के बारे में बताता है.
PendingIntent कॉलबैक, जहां आपके ऐप्लिकेशन को सूचनाएं मिलती हैं. ज़्यादा जानकारी के लिए, pending intent का इस्तेमाल करना लेख पढ़ें.

फ़ॉलो करने के लिए, ActivitiyTransitions की सूची बनाएं

ActivityTransitionRequest ऑब्जेक्ट बनाने के लिए, आपको ActivityTransition ऑब्जेक्ट की एक सूची बनानी होगी. यह सूची, उस ट्रांज़िशन को दिखाती है जिसे आपको ट्रैक करना है. ActivityTransition ऑब्जेक्ट में यह डेटा शामिल होता है:

गतिविधि का टाइप, जिसे DetectedActivity क्लास से दिखाया जाता है. Transition API की मदद से ये काम किए जा सकते हैं:

यह ट्रांज़िशन का एक टाइप है. इसे ActivityTransition क्लास से दिखाया जाता है. ट्रांज़िशन के टाइप ये हैं:

base मॉड्यूल में, MainActivity.java में जाकर TODO: Add activity transitions to track खोजें. टिप्पणी के बाद, यहां दिया गया कोड जोड़ें.

// TODO: Add activity transitions to track.
activityTransitionList.add(new ActivityTransition.Builder()
        .setActivityType(DetectedActivity.WALKING)
        .setActivityTransition(ActivityTransition.ACTIVITY_TRANSITION_ENTER)
        .build());
activityTransitionList.add(new ActivityTransition.Builder()
        .setActivityType(DetectedActivity.WALKING)
        .setActivityTransition(ActivityTransition.ACTIVITY_TRANSITION_EXIT)
        .build());
activityTransitionList.add(new ActivityTransition.Builder()
        .setActivityType(DetectedActivity.STILL)
        .setActivityTransition(ActivityTransition.ACTIVITY_TRANSITION_ENTER)
        .build());
activityTransitionList.add(new ActivityTransition.Builder()
        .setActivityType(DetectedActivity.STILL)
        .setActivityTransition(ActivityTransition.ACTIVITY_TRANSITION_EXIT)
        .build());

यह कोड, उन ट्रांज़िशन को जोड़ता है जिन्हें हमें ट्रैक करना है. इन्हें पहले से मौजूद खाली सूची में जोड़ा जाता है.

PendingIntent बनाना

जैसा कि पहले बताया गया है, अगर हमें ActivityTransitionRequest में हुए किसी भी बदलाव के बारे में सूचना चाहिए, तो हमें PendingIntent की ज़रूरत होगी. इसलिए, ActivityTransitionRequest सेट अप करने से पहले, हमें PendingIntent बनाना होगा.

base मॉड्यूल में, MainActivity.java में मौजूद TODO: Initialize PendingIntent that will be triggered when a activity transition occurs को खोजें. टिप्पणी के बाद, यहां दिया गया कोड जोड़ें.

// TODO: Initialize PendingIntent that will be triggered when a activity transition occurs.
Intent intent = new Intent(TRANSITIONS_RECEIVER_ACTION);
mActivityTransitionsPendingIntent =
        PendingIntent.getBroadcast(MainActivity.this, 0, intent, 0);

अब हमारे पास एक PendingIntent है. इसे ActivityTransition होने पर ट्रिगर किया जा सकता है.

ActivityTransitionRequest बनाएं और अपडेट का अनुरोध करें

ActivityTransitionRequest क्लास में ActivityTransitions की सूची पास करके, ActivityTransitionRequest ऑब्जेक्ट बनाया जा सकता है.

base मॉड्यूल में, MainActivity.java में जाकर Create request and listen for activity changes खोजें. टिप्पणी के बाद, यहां दिया गया कोड जोड़ें.

// TODO: Create request and listen for activity changes.
ActivityTransitionRequest request = new ActivityTransitionRequest(activityTransitionList);

// Register for Transitions Updates.
Task<Void> task =
        ActivityRecognition.getClient(this)
                .requestActivityTransitionUpdates(request, mActivityTransitionsPendingIntent);


task.addOnSuccessListener(
        new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(Void result) {
                activityTrackingEnabled = true;
                printToScreen("Transitions Api was successfully registered.");

            }
        });
task.addOnFailureListener(
        new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                printToScreen("Transitions Api could NOT be registered: " + e);
                Log.e(TAG, "Transitions Api could NOT be registered: " + e);

            }
        });

आइए, कोड की समीक्षा करें. सबसे पहले, हम गतिविधि के ट्रांज़िशन की सूची से ActivityTransitionRequest बनाते हैं.

ActivityTransitionRequest request = new ActivityTransitionRequest(activityTransitionList);

इसके बाद, हम गतिविधि के ट्रांज़िशन से जुड़े अपडेट पाने के लिए रजिस्टर करते हैं. इसके लिए, हम ActivityTransitionRequest का आपका इंस्टेंस और पिछले चरण में बनाया गया PendingIntent ऑब्जेक्ट, requestActivityTransitionUpdates() तरीके को पास करते हैं. requestActivityTransitionUpdates() मैथड, Task ऑब्जेक्ट दिखाता है. इसमें यह देखा जा सकता है कि अनुरोध पूरा हुआ या नहीं. इसे कोड के अगले ब्लॉक में दिखाया गया है:

// Register for Transitions Updates.
Task<Void> task =
        ActivityRecognition.getClient(this)
                .requestActivityTransitionUpdates(request, mActivityTransitionsPendingIntent);


task.addOnSuccessListener(
        new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(Void result) {
                activityTrackingEnabled = true;
                printToScreen("Transitions Api was successfully registered.");

            }
        });
task.addOnFailureListener(
        new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                printToScreen("Transitions Api could NOT be registered: " + e);
                Log.e(TAG, "Transitions Api could NOT be registered: " + e);

            }
        });

गतिविधि में बदलाव होने पर अपडेट पाने के लिए रजिस्टर करने के बाद, आपके ऐप्लिकेशन को रजिस्टर किए गए PendingIntent में सूचनाएं मिलती हैं. हम एक ऐसा वैरिएबल भी सेट करते हैं जिससे यह पता चलता है कि गतिविधि को ट्रैक करने की सुविधा चालू है. इससे हमें यह पता चलता है कि अगर उपयोगकर्ता फिर से बटन पर क्लिक करता है, तो हमें इस सुविधा को बंद/चालू करना है या नहीं.

ऐप्लिकेशन बंद होने पर अपडेट हटाना

ऐप्लिकेशन बंद होने पर, ट्रांज़िशन अपडेट हटाना ज़रूरी है.

base मॉड्यूल में, MainActivity.java में जाकर गतिविधि में हुए बदलावों को सुनने की सुविधा बंद करें खोजें. टिप्पणी के बाद, यहां दिया गया कोड जोड़ें.

// TODO: Stop listening for activity changes.
ActivityRecognition.getClient(this).removeActivityTransitionUpdates(mActivityTransitionsPendingIntent)
        .addOnSuccessListener(new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(Void aVoid) {
                activityTrackingEnabled = false;
                printToScreen("Transitions successfully unregistered.");
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                printToScreen("Transitions could not be unregistered: " + e);
                Log.e(TAG,"Transitions could not be unregistered: " + e);
            }
        });

अब हमें ऐप्लिकेशन बंद होने पर, ऊपर दिए गए कोड वाले तरीके को कॉल करना होगा

base मॉड्यूल में, onPause() में MainActivity.java में जाकर TODO: Disable activity transitions when user leaves the app खोजें. टिप्पणी के बाद, यहां दिया गया कोड जोड़ें.

// TODO: Disable activity transitions when user leaves the app.
if (activityTrackingEnabled) {
    disableActivityTransitions();
}

गतिविधि ट्रांज़िशन में हुए बदलावों को ट्रैक करने के लिए बस इतना ही करना है. अब हमें सिर्फ़ अपडेट प्रोसेस करने हैं.

7. इवेंट प्रोसेस किए जा रहे हैं

गतिविधि के ट्रांज़िशन का अनुरोध पूरा होने पर, आपके ऐप्लिकेशन को Intent कॉलबैक मिलता है. ActivityTransitionResult ऑब्जेक्ट को इंटेंट से निकाला जा सकता है. इसमें ActivityTransitionEvent ऑब्जेक्ट की सूची शामिल होती है. इवेंट, समय के हिसाब से क्रम में लगाए जाते हैं. उदाहरण के लिए, अगर कोई ऐप्लिकेशन ACTIVITY_TRANSITION_ENTER और ACTIVITY_TRANSITION_EXIT ट्रांज़िशन पर IN_VEHICLE गतिविधि के टाइप का अनुरोध करता है, तो उसे ActivityTransitionEvent ऑब्जेक्ट तब मिलता है, जब उपयोगकर्ता ड्राइविंग शुरू करता है. इसके बाद, उसे दूसरा ऑब्जेक्ट तब मिलता है, जब उपयोगकर्ता किसी दूसरी गतिविधि पर स्विच करता है.

आइए, उन इवेंट को हैंडल करने के लिए कोड जोड़ें.

base मॉड्यूल में, MainActivity.java में TODO: Extract activity transition information from listener खोजें. यह onReceive() में मौजूद BroadcastReceiver में है, जिसे हमने पहले बनाया था. टिप्पणी के बाद, यहां दिया गया कोड जोड़ें.

// TODO: Extract activity transition information from listener.
if (ActivityTransitionResult.hasResult(intent)) {

    ActivityTransitionResult result = ActivityTransitionResult.extractResult(intent);

    for (ActivityTransitionEvent event : result.getTransitionEvents()) {

        String info = "Transition: " + toActivityString(event.getActivityType()) +
                " (" + toTransitionType(event.getTransitionType()) + ")" + "   " +
                new SimpleDateFormat("HH:mm:ss", Locale.US).format(new Date());

        printToScreen(info);
    }
}

इससे जानकारी को String में बदल दिया जाएगा और स्क्रीन पर प्रिंट कर दिया जाएगा.

बस, आपका काम पूरा हुआ! ऐप्लिकेशन को चलाकर देखें.

अहम जानकारी: एम्युलेटर पर गतिविधि में हुए बदलावों को दोहराना मुश्किल होता है. इसलिए, हमारा सुझाव है कि आप फ़िज़िकल डिवाइस का इस्तेमाल करें.

आपको गतिविधि में हुए बदलावों को ट्रैक करने का विकल्प मिलना चाहिए.

बेहतर नतीजे पाने के लिए, ऐप्लिकेशन को किसी फ़िज़िकल डिवाइस पर इंस्टॉल करें और आस-पास घूमें. :)

8. कोड की समीक्षा करना

आपने एक ऐसा ऐप्लिकेशन बनाया है जो गतिविधि में होने वाले बदलावों को ट्रैक करता है और उन्हें स्क्रीन पर दिखाता है.

आपने जो काम किया है उसकी समीक्षा करने के लिए, पूरे कोड को पढ़ें. इससे आपको यह बेहतर तरीके से समझने में मदद मिलेगी कि यह एक साथ कैसे काम करता है.