हमारा सुझाव है कि 27 मार्च, 2025 से AOSP को बनाने और उसमें योगदान देने के लिए, aosp-main के बजाय android-latest-release का इस्तेमाल करें. ज़्यादा जानकारी के लिए, AOSP में हुए बदलाव लेख पढ़ें.

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

सिस्टम की परफ़ॉर्मेंस पर नज़र रखना
संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

वॉचडॉग, वेंडर सेवाओं और वीएचएएल सेवा की स्थिति पर नज़र रखता है. किसी हानिकारक प्रक्रिया को खत्म कर देता है. जब कोई गड़बड़ी वाली प्रोसेस खत्म हो जाती है, तो वॉचडॉग, प्रोसेस की स्थिति को /data/anr पर डाल देता है. यह स्थिति, 'ऐप्लिकेशन काम नहीं कर रहा है' (एएनआर) के अन्य डंप की तरह ही होती है. ऐसा करने से, डीबग करने की प्रोसेस आसान हो जाती है.

वेंडर की सेवा की परफ़ॉर्मेंस पर नज़र रखना

वेंडर सेवाओं को नेटिव और Java, दोनों प्लैटफ़ॉर्म पर मॉनिटर किया जाता है. किसी वेंडर की सेवा की निगरानी करने के लिए, सेवा को Watchdog के साथ, पहले से तय किए गए टाइम आउट की जानकारी देकर, सेवा की परफ़ॉर्मेंस की जांच करने की प्रोसेस रजिस्टर करनी होगी. वॉचडॉग निगरानी करता है रजिस्टर की गई स्वास्थ्य जांच प्रोसेस की परफ़ॉर्मेंस को एक अंतराल में पिंग करके रजिस्ट्रेशन के दौरान तय किए गए टाइम आउट के मुताबिक. पिंग किए जाने पर प्रोसेस टाइम आउट में जवाब नहीं देती, तो इस प्रोसेस को नुकसान पहुंचाने वाला माना जाता है.

स्थानीय सेवा की स्थिति पर नज़र रखना

वॉचडॉग एआईडीएल मेकफ़ाइल की जानकारी दें

shared_libs में carwatchdog_aidl_interface-ndk_platform को शामिल करें.

Android.bp

cc_binary {
    name: "sample_native_client",
    srcs: [
        "src/*.cpp"
    ],
    shared_libs: [
        "carwatchdog_aidl_interface-ndk_platform",
        "libbinder_ndk",
    ],
    vendor: true,
}

SELinux नीति जोड़ें

SELinux नीति जोड़ने के लिए, वेंडर सेवा डोमेन को बिंडर (binder_use मैक्रो) का इस्तेमाल करने की अनुमति दें. साथ ही, वेंडर सेवा डोमेन को carwatchdog क्लाइंट डोमेन (carwatchdog_client_domain मैक्रो) में जोड़ें. sample_client.te और file_contexts के लिए, नीचे दिया गया कोड देखें:
sample_client.te
```
type sample_client, domain;
type sample_client_exec, exec_type, file_type, vendor_file_type;

carwatchdog_client_domain(sample_client)

init_daemon_domain(sample_client)
binder_use(sample_client)
```
file_contexts
```
/vendor/bin/sample_native_client  u:object_r:sample_client_exec:s0
```

BnCarWatchdogClient को इनहेरिट करके क्लाइंट क्लास लागू करना

checkIfAlive में, सेहत की जांच करें. एक विकल्प यह है कि आप थ्रेड लूप हैंडलर पर पोस्ट करें. अगर सब कुछ ठीक है, तो ICarWatchdog::tellClientAlive पर कॉल करें. SampleNativeClient.h और SampleNativeClient.cpp के लिए, नीचे दिया गया कोड देखें:

SampleNativeClient.h

class SampleNativeClient : public BnCarWatchdogClient {
public:
    ndk::ScopedAStatus checkIfAlive(int32_t sessionId, TimeoutLength
        timeout) override;
    ndk::ScopedAStatus prepareProcessTermination() override;
    void initialize();

private:
    void respondToDaemon();
private:
    ::android::sp<::android::Looper> mHandlerLooper;
    std::shared_ptr<ICarWatchdog> mWatchdogServer;
    std::shared_ptr<ICarWatchdogClient> mClient;
    int32_t mSessionId;
};

SampleNativeClient.cpp

ndk::ScopedAStatus WatchdogClient::checkIfAlive(int32_t sessionId, TimeoutLength timeout) {
    mHandlerLooper->removeMessages(mMessageHandler,
        WHAT_CHECK_ALIVE);
    mSessionId = sessionId;
    mHandlerLooper->sendMessage(mMessageHandler,
        Message(WHAT_CHECK_ALIVE));
    return ndk::ScopedAStatus::ok();
}
// WHAT_CHECK_ALIVE triggers respondToDaemon from thread handler
void WatchdogClient::respondToDaemon() {
  // your health checking method here
  ndk::ScopedAStatus status = mWatchdogServer->tellClientAlive(mClient,
        mSessionId);
}

बाइंडर थ्रेड शुरू करें और क्लाइंट को रजिस्टर करें

कार वॉचडॉग डीमन इंटरफ़ेस का नाम है android.automotive.watchdog.ICarWatchdog/default.

डीमन को नाम से खोजें और ICarWatchdog::registerClient को कॉल करें. main.cpp और SampleNativeClient.cpp के लिए, नीचे दिया गया कोड देखें:

main.cpp

int main(int argc, char** argv) {
    sp<Looper> looper(Looper::prepare(/*opts=*/0));

    ABinderProcess_setThreadPoolMaxThreadCount(1);
    ABinderProcess_startThreadPool();
    std::shared_ptr<SampleNativeClient> client =
        ndk::SharedRefBase::make<SampleNatvieClient>(looper);

    // The client is registered in initialize()
    client->initialize();
    ...
}

SampleNativeClient.cpp

void SampleNativeClient::initialize() {
    ndk::SpAIBinder binder(AServiceManager_getService(
        "android.automotive.watchdog.ICarWatchdog/default"));
    std::shared_ptr<ICarWatchdog> server =
        ICarWatchdog::fromBinder(binder);
    mWatchdogServer = server;
    ndk::SpAIBinder binder = this->asBinder();
    std::shared_ptr<ICarWatchdogClient> client =
        ICarWatchdogClient::fromBinder(binder)
    mClient = client;
    server->registerClient(client, TimeoutLength::TIMEOUT_NORMAL);
}

Java सर्विस हेल्थ मॉनिटरिंग

CarWatch DogClientCallback इनहेरिट करके, क्लाइंट को लागू करें

नई फ़ाइल में इस तरह बदलाव करें:

private final CarWatchdogClientCallback mClientCallback = new CarWatchdogClientCallback() {
    @Override
    public boolean onCheckHealthStatus(int sessionId, int timeout) {
        // Your health check logic here
        // Returning true implies the client is healthy
        // If false is returned, the client should call
        // CarWatchdogManager.tellClientAlive after health check is
        // completed
    }

    @Override
    public void onPrepareProcessTermination() {}
};

क्लाइंट को रजिस्टर करें

CarWatchdogManager.registerClient() को कॉल करने के लिए:

private void startClient() {
    CarWatchdogManager manager =
        (CarWatchdogManager) car.getCarManager(
        Car.CAR_WATCHDOG_SERVICE);
    // Choose a proper executor according to your health check method
    ExecutorService executor = Executors.newFixedThreadPool(1);
    manager.registerClient(executor, mClientCallback,
        CarWatchdogManager.TIMEOUT_NORMAL);
}

क्लाइंट का रजिस्ट्रेशन रद्द करें

सेवा खत्म होने पर CarWatchdogManager.unregisterClient() पर कॉल करें:

private void finishClient() {
    CarWatchdogManager manager =
        (CarWatchdogManager) car.getCarManager(
        Car.CAR_WATCHDOG_SERVICE);
    manager.unregisterClient(mClientCallback);
}

VHAL की सेहत की निगरानी

वेंडर सेवा की परफ़ॉर्मेंस पर नज़र रखने के उलट, वॉचडॉग वीएचएएल सेवा पर नज़र रखता है स्वास्थ्य को बेहतर बनाने के लिए, VHAL_HEARTBEAT की वाहन की प्रॉपर्टी की सदस्यता लें. वॉचडॉग को उम्मीद है कि इस प्रॉपर्टी की वैल्यू हर N सेकंड में अपडेट की जाएगी. अगर इस टाइम आउट में हार्टबीट अपडेट नहीं होती, तो वॉचडॉग वीएचएएल को बंद कर देता है सेवा.

ध्यान दें: वॉचडॉग सिर्फ़ तब वीएचएएल सेवा की परफ़ॉर्मेंस की निगरानी करता है, जब VHAL_HEARTBEAT वाहन प्रॉपर्टी, वीएचएएल सेवा के साथ काम करती है.

VHAL का इंटरनल फ़ंक्शन, वेंडर के हिसाब से अलग-अलग हो सकता है. रेफ़रंस के तौर पर, यहां दिए गए कोड सैंपल का इस्तेमाल करें.

वाहन की VHAL_HEARTBEAT प्रॉपर्टी रजिस्टर करें.
VHAL सेवा शुरू करने पर, वाहन की VHAL_HEARTBEAT प्रॉपर्टी को रजिस्टर करें. नीचे दिए गए उदाहरण में, एक unordered_map, जो प्रॉपर्टी आईडी को कॉन्फ़िगर करने के लिए मैप करता है का इस्तेमाल, काम करने वाले सभी कॉन्फ़िगरेशन को होल्ड करने के लिए किया जाता है. VHAL_HEARTBEAT का कॉन्फ़िगरेशन मैप को चालू करें, ताकि जब VHAL_HEARTBEAT के बारे में क्वेरी की जाए, तो उससे जुड़ा कॉन्फ़िगरेशन वापस किया गया.
```
void registerVhalHeartbeatProperty() {
        const VehiclePropConfig config = {
                .prop = toInt(VehicleProperty::VHAL_HEARTBEAT),
                .access = VehiclePropertyAccess::READ,
                .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
        };
       // mConfigsById is declared as std::unordered_map<int32_t, VehiclePropConfig>.
       mConfigsById[config.prop] = config;
}
```

VHAL_HEARTBEAT वाहन की प्रॉपर्टी अपडेट करें.

VHAL की परफ़ॉर्मेंस की जांच की फ़्रीक्वेंसी के आधार पर (इसके बारे में VHAL की परफ़ॉर्मेंस की जांच की फ़्रीक्वेंसी तय करना" में बताया गया है), वाहन की VHAL_HEARTBEAT प्रॉपर्टी को हर N सेकंड में अपडेट करें. ऐसा करने का एक तरीका यह है कि कार्रवाई को कॉल करने के लिए, RecurrentTimer का इस्तेमाल किया जाए जो VHAL की परफ़ॉर्मेंस की जांच करता है और VHAL_HEARTBEAT वाहन को अपडेट करता है प्रॉपर्टी सेट अप करने का समय खत्म हो गया है.

यहां, RecurrentTimer का इस्तेमाल करके लागू किया गया सैंपल दिया गया है:

int main(int argc, char** argv) {
        RecurrentTimer recurrentTimer(updateVhalHeartbeat);
        recurrentTimer.registerRecurrentEvent(kHeartBeatIntervalNs,
                                           static_cast<int32_t>(VehicleProperty::VHAL_HEARTBEAT));
        … Run service …
        recurrentTimer.unregisterRecurrentEvent(
                static_cast<int32_t>(VehicleProperty::VHAL_HEARTBEAT));
}

void updateVhalHeartbeat(const std::vector<int32_t>& cookies) {
       for (int32_t property : cookies) {
              if (property != static_cast<int32_t>(VehicleProperty::VHAL_HEARTBEAT)) {
                     continue;
              }

              // Perform internal health checking such as retrieving a vehicle property to ensure
              // the service is responsive.
              doHealthCheck();

              // Construct the VHAL_HEARTBEAT property with system uptime.
              VehiclePropValuePool valuePool;
              VehicleHal::VehiclePropValuePtr propValuePtr = valuePool.obtainInt64(uptimeMillis());
              propValuePtr->prop = static_cast<int32_t>(VehicleProperty::VHAL_HEARTBEAT);
              propValuePtr->areaId = 0;
              propValuePtr->status = VehiclePropertyStatus::AVAILABLE;
              propValuePtr->timestamp = elapsedRealtimeNano();

              // Propagate the HAL event.
              onHalEvent(std::move(propValuePtr));
       }
}

(ज़रूरी नहीं) VHAL की हेल्थ चेक की फ़्रीक्वेंसी तय करें.
वॉचडॉग ro.carwatchdog.vhal_healthcheck.interval का रीड-ओनली ऐक्सेस प्रॉडक्ट प्रॉपर्टी से, VHAL की स्वास्थ्य जांच की फ़्रीक्वेंसी के बारे में पता चलता है. डिफ़ॉल्ट परफ़ॉर्मेंस की जांच फ़्रीक्वेंसी (जब इस प्रॉपर्टी के बारे में नहीं बताया गया हो) तीन सेकंड की होती है. अगर VHAL_HEARTBEAT वाहन की प्रॉपर्टी को अपडेट करने के लिए, VHAL सेवा को तीन सेकंड का समय कम पड़ता है, तो सेवा के जवाब देने की फ़्रीक्वेंसी के आधार पर, VHAL की परफ़ॉर्मेंस की जांच की फ़्रीक्वेंसी तय करें.

नुकसान पहुंचाने वाली ऐसी प्रोसेस को डीबग करना जिन्हें वॉचडॉग ने रद्द कर दिया हो

वॉचडॉग इस प्रोसेस की स्थिति को खारिज कर देता है और नुकसान पहुंचाने वाली प्रोसेस को खत्म करता है. खत्म होने पर एक खराब प्रोसेस की वजह से वॉचडॉग, लॉगकैट के लिए carwatchdog terminated <process name> (pid:<process id>) टेक्स्ट लॉग करता है. यह लॉग लाइन, बंद की गई प्रोसेस के बारे में जानकारी देती है. जैसे, प्रोसेस का नाम और प्रोसेस आईडी.

ऊपर दिए गए टेक्स्ट को चलाकर, Logcat को खोजा जा सकता है:
```
$ adb logcat -s CarServiceHelper | fgrep "carwatchdog killed"
```
उदाहरण के लिए, जब KitchenSink ऐप्लिकेशन, रजिस्टर किया गया वॉचडॉग क्लाइंट हो और वॉचडॉग पिंग के लिए काम नहीं करता, वॉचडॉग इस तरह की लाइन लॉग करता है रजिस्टर की गई KitchenSink प्रोसेस को खत्म करते समय जारी की जाएगी.
```
05-01 09:50:19.683   578  5777 W CarServiceHelper: carwatchdog killed com.google.android.car.kitchensink (pid: 5574)
```
ऐप्लिकेशन के काम न करने की असल वजह का पता लगाने के लिए, /data/anr में सेव किए गए प्रोसेस डंप का इस्तेमाल करें. ठीक उसी तरह जैसे गतिविधि के ANR मामलों के लिए किया जाता है. खत्म की गई प्रोसेस के लिए डंप फ़ाइल को वापस पाने के लिए, नीचे दिए गए निर्देशों का इस्तेमाल करें.
```
$ adb root
$ adb shell grep -Hn "pid process_pid" /data/anr/*
```
यहां दिया गया सैंपल आउटपुट, KitchenSink ऐप्लिकेशन के लिए खास तौर पर है:
```
$ adb shell su root grep -Hn "pid 5574" /data/anr/*.
```
```
/data/anr/anr_2020-05-01-09-50-18-290:3:----- pid 5574 at 2020-05-01 09:50:18 -----
/data/anr/anr_2020-05-01-09-50-18-290:285:----- Waiting Channels: pid 5574 at 2020-05-01 09:50:18 -----
```
खत्म की गई KitchenSink प्रोसेस के लिए डंप फ़ाइल, यहां दी गई है: /data/anr/anr_2020-05-01-09-50-18-290. बंद की गई प्रोसेस की ANR डंप फ़ाइल का इस्तेमाल करके, विश्लेषण शुरू करें.