---
title: साइलेंट पुनर्सत्यापन
description: स्मार्ट पुनर्सत्यापन इंजन का उपयोग करता है, जो Unico के नेटवर्क प्रभाव के भीतर उपयोगकर्ता के व्यवहारगत संदर्भ का विश्लेषण करता है, ताकि वर्तमान लेन-देन के लिए एक विश्वास संकेत प्रदान किया जा सके — दूसरे शब्दों में, यह विश्वास स्तर कि यह अपेक्षित उपयोगकर्ता ही है।
canonical: https://developer.unico.io/hi/dual-api/developers/sdks-and-tools/android/smart-revalidation/silent-revalidation
locale: hi
generated_by: markdown-export
---

## PrepareInfo एट्रिब्यूट

| एट्रिब्यूट | प्रकार | आवश्यक | विवरण |
|---|---|:-:|---|
| `externalUserId` | `String` | ✅ | आपके सिस्टम में उपयोगकर्ता पहचानकर्ता। ट्रांसमिशन से पहले स्वचालित रूप से SHA-256 से हैश किया जाता है, कभी भी plain text में नहीं भेजा जाता। |

## साइलेंट पुनर्सत्यापन शुरू करना

****चरण 1** — `initializeSDK` को लागू करें**

एक स्टैटिक `initializeSDK` मेथड के साथ एक नई `UnicoSDK` क्लास/ऑब्जेक्ट बनाएं, जो `UnicoSDK` इंस्टेंस रिटर्न करता है और `context` तथा आपके `sdkKey`, `bundleId`, और `environment` वाला एक `UnicoSDKConfig` प्राप्त करता है। रिटर्न किए गए इंस्टेंस को सुरक्षित रखें — बाद में Java से `startSilentValidation` कॉल करने के लिए इसकी आवश्यकता होती है।

  :::warning[इसे ऐप लॉन्च पर कॉल करें]
  `UnicoSDK.initializeSDK` को ऐप लॉन्च पर जितनी जल्दी हो सके कॉल किया जाना चाहिए (उदाहरण के लिए, `Application.onCreate`)। इसे देर से कॉल करने पर बैकग्राउंड प्रोसेसिंग का समय कम हो जाता है और अनिर्णायक (inconclusive) प्रमाणीकरण प्रतिक्रियाओं की संभावना बढ़ जाती है।
  :::

  ### Kotlin

    ```kotlin
    UnicoSDK.initializeSDK(
        context,
        UnicoSDKConfig(
            sdkKey = "your_sdk_key",
            bundleId = "your_bundle_id",
            environment = Environment.UAT
        )
    )
    ```

### Java

    ```java
    UnicoSDK sdk = UnicoSDK.initializeSDK(
        context,
        new UnicoSDKConfig("your_sdk_key", "your_bundle_id", Environment.UAT)
    );
    ```

****चरण 2** — `startSilentValidation` को लागू करें**

`initializeSDK` के बाद, पहले से चल रहे कलेक्शन को पहचाने गए उपयोगकर्ता के साथ जोड़ने के लिए `externalUserId` वाले `PrepareInfo` के साथ `startSilentValidation` को कॉल करें।

  ### Kotlin

    ```kotlin
    val prepareInfo = PrepareInfo(
        externalUserId = "external_user_id"
    )

    UnicoSDK.startSilentValidation(prepareInfo)
        .onSuccess { result -> /* ... */ }
        .onFailure { error -> /* ... */ }
    ```

### Java

:::info[Java के लिए Kotlin ब्रिज आवश्यक है]
    `startSilentValidation` एक Kotlin suspend फ़ंक्शन है और इसे सीधे Java से कॉल नहीं किया जा सकता। अपने प्रोजेक्ट में एक छोटा Kotlin ब्रिज जोड़ें जो coroutine लॉन्च करे और एक सामान्य callback इंटरफ़ेस एक्सपोज़ करे।
    :::

    ```kotlin
    interface SilentAuthCallback {
        fun onSuccess(success: Boolean)
        fun onFailure(message: String?)
    }

    object SilentAuthBridge {

        @JvmStatic
        fun startSilentValidation(
            owner: LifecycleOwner,
            sdk: UnicoSDK,
            externalUserId: String,
            callback: SilentAuthCallback
        ) {
            owner.lifecycleScope.launch {
                val result = sdk.startSilentValidation(PrepareInfo(externalUserId, null))
                result.onSuccess { callback.onSuccess(it.success) }
                    .onFailure { callback.onFailure(it.message) }
            }
        }
    }
    ```

    ```java
    SilentAuthBridge.startSilentValidation(this, sdk, externalUserId, new SilentAuthCallback() {
        @Override
        public void onSuccess(boolean success) {
            /* ... */
        }

        @Override
        public void onFailure(String message) {
            /* ... */
        }
    });
    ```

  यदि वैलिडेशन फ्लो की शुरुआत में होता है, उदाहरण के लिए लॉगिन पर, तो चरण 3 पर आगे बढ़ने से पहले `onSuccess` कॉलबैक की प्रतीक्षा करें।

****चरण 3** — प्रोसेस बनाएं और प्रमाणित करें**

वैलिडेशन के चल रहे रहते हुए, प्रमाणीकरण पूरा करने के लिए वेरिफिकेशन प्रोसेस बनाएं। देखें [API Reference ▸ API ▸ Create Process](/dual-api/developers/api-reference/api/post-processes)।

  चरण 2 में `PrepareInfo` में भेजे गए उसी `externalUserId` को रिक्वेस्ट बॉडी में शामिल करें — यही वह चीज़ है जो बैकएंड को प्रोसेस निर्माण को पहले से चल रहे वैलिडेशन के साथ सहसंबंधित (correlate) करने देती है।

  ```bash
  curl -X POST https://api.id.unico.app/processes/v1 \
    -H "Authorization: Bearer $TOKEN" \
    -H "APIKEY: $API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "subject": {
        "duiType": 1,
        "code": "12345678909",
        "name": "Luke Skywalker",
        "gender": "M",
        "birthDate": "2000-05-20",
        "email": "luke@example.com",
        "phone": "5519725570707"
      },
      "useCase": "Onboarding",
      "externalUserId": "external_user_id",
      "imageBase64": "/9j/4AAQSkZJR..."
    }'
  ```

  प्रतिक्रिया में प्रमाणीकरण के परिणाम के साथ `silentAuth.result` फ़ील्ड शामिल होता है:

  ```json
  {
      "id": "80371b2a-3ac7-432e-866d-57fe37896ac6",
      "status": 3,
      "silentAuth": {
          "result": "yes"
      }
  }
  ```

  | फ़ील्ड | प्रकार | विवरण |
  |---|---|---|
  | `silentAuth.result` | string | `yes` या `no` — नीचे संभावित मान देखें। |

  <details>
  **`silentAuth.result` — संभावित मान**

  | मान | अर्थ |
  |---|---|
  | `yes` | प्रमाणीकरण स्वीकृत, उपयोगकर्ता को पर्याप्त विश्वास के साथ पहचाना गया, अतिरिक्त कैप्चर की आवश्यकता नहीं। |
  | `no` | साइलेंट रूप से स्वीकृत करने के लिए अपर्याप्त डेटा। बायोमेट्रिक्स (सेल्फी) या किसी अन्य वैकल्पिक तरीके से प्रमाणित करने की सलाह दी जाती है। |

</details>