इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

1. परिचय

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

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

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

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

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

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

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

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

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

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

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

2. शुरू करें

स्टार्टर प्रोजेक्ट के रिपॉज़िटरी को क्लोन करना

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

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

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

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

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

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

अगर आपने 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: मेनिफ़ेस्ट में गतिविधि की पहचान करने से जुड़ी दोनों अनुमतियां जोड़ें खोजें. इसके बाद, <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) या इसके बाद का वर्शन है या नहीं. अगर उपयोगकर्ता के डिवाइस में Android 10 (29) या इसके बाद का वर्शन है, तो हम गतिविधि की पहचान करने की अनुमतियों की जांच करेंगे.
अगर अनुमतियां नहीं दी जाती हैं, तो हम उपयोगकर्ता को स्प्लैश स्क्रीन (PermissionRationalActivity.java) पर भेजेंगे. इसमें यह बताया जाएगा कि ऐप्लिकेशन को अनुमति क्यों चाहिए. साथ ही, उपयोगकर्ता को अनुमति देने की अनुमति भी दी जाएगी.

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

base मॉड्यूल में, MainActivity.java में TODO: 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: 29+ के लिए अनुमति की जांच की समीक्षा करें खोजें. आपको यह कोड स्निपेट दिखेगा.

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

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

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

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

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

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

base मॉड्यूल में, MainActivity.java में TODO: गतिविधि ट्रैकिंग की सुविधा चालू/बंद करें और ज़रूरत पड़ने पर अनुमतियां मांगें खोजें. टिप्पणी के बाद, नीचे दिया गया कोड जोड़ें.

// 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: गतिविधि की पहचान करने की सुविधा के लिए अनुमति के अनुरोध की समीक्षा करें खोजें. आपको यह कोड स्निपेट दिखेगा.

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

// 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: गतिविधि ट्रांज़िशन को सुनने के लिए BroadcastReceiver बनाएं खोजें. स्निपेट को यहां चिपकाएं.

// 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: गतिविधि ट्रांज़िशन को सुनने के लिए, BroadcastReceiver रजिस्टर करें खोजें. (यह onStart() में है). स्निपेट को यहां चिपकाएं.

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

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

BroadcastReceiver को अनरजिस्टर करना

base मॉड्यूल में, MainActivity.java में ऐप्लिकेशन छोड़ने पर, गतिविधि ट्रांज़िशन रिसीवर को अनरजिस्टर करें खोजें. (यह onStop() में है).स्निपेट को यहां चिपकाएं.

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

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

6. गतिविधि के ट्रांज़िशन सेटअप करना और अपडेट का अनुरोध करना

गतिविधि के ट्रांज़िशन से जुड़े अपडेट पाने के लिए, आपको ये सेटिंग लागू करनी होंगी:

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

ऐसी गतिविधियों की सूची बनाना जिन्हें फ़ॉलो करना है

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

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

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

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

// 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: PendingIntent को शुरू करें, जो गतिविधि ट्रांज़िशन होने पर ट्रिगर होगा खोजें. टिप्पणी के बाद, नीचे दिया गया कोड जोड़ें.

// 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 में अनुरोध बनाएं और गतिविधि में हुए बदलावों को सुनें खोजें. टिप्पणी के बाद, नीचे दिया गया कोड जोड़ें.

// 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 के आपके इंस्टेंस और requestActivityTransitionUpdates() तरीके में, पिछले चरण में बनाए गए PendingIntent ऑब्जेक्ट को पास करके, गतिविधि ट्रांज़िशन के अपडेट के लिए रजिस्टर करते हैं. 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: जब उपयोगकर्ता ऐप्लिकेशन छोड़ता है, तो गतिविधि ट्रांज़िशन बंद करें खोजें. टिप्पणी के बाद, नीचे दिया गया कोड जोड़ें.

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

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

7. इवेंट प्रोसेस करना

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

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

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

// 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. कोड की समीक्षा करना

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

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