> ## Documentation Index
> Fetch the complete documentation index at: https://www.mellowtel.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# अपने Windows डेस्कटॉप ऐप में Mellowtel को इंटीग्रेट करें

अपने Windows डेस्कटॉप एप्लिकेशन में Mellowtel को इंटीग्रेट करें ताकि उपयोगकर्ता अपने अप्रयुक्त इंटरनेट बैंडविड्थ को इनाम या प्रीमियम फीचर्स के बदले साझा कर सकें।

<Warning>
  **उपयोगकर्ता की सहमति अनिवार्य है।** यदि आप `StartAsync()` को उपयोगकर्ता के ऑप्ट-इन किए बिना कॉल करते हैं, तो SDK `InvalidOperationException` फेंकता है।
</Warning>

## आवश्यकताएँ

* एक Mellowtel खाता और [डैशबोर्ड](https://www.mellowtel.com/mellowtel-auth/) से **इंटीग्रेशन ID**। प्रत्येक डेस्कटॉप ऐप को अपनी अनूठी इंटीग्रेशन ID मिलती है।
* .NET 10 SDK
* Windows 10 या Windows 11
* एक .NET डेस्कटॉप एप्लिकेशन (कंसोल, WPF, या Windows फॉर्म्स)

<Note>
  क्या आप इसे अपने ऐप में वायर करने से पहले एक पूर्ण, वास्तविक दुनिया का इंटीग्रेशन देखना चाहते हैं? [mellowtel-pomodoro-windows](https://github.com/mellowtel-inc/mellowtel-pomodoro-windows) WPF नमूना संपूर्ण प्रवाह दिखाता है: सहमति संवाद, सेटिंग्स टॉगल, और बैकग्राउंड जीवनचक्र।
</Note>

***

## इंस्टॉलेशन

Windows के लिए Mellowtel NuGet पर [`Mellowtel.Win`](https://www.nuget.org/packages/Mellowtel.Win) के रूप में उपलब्ध है।

### 1. पैकेज इंस्टॉल करें

अपने प्रोजेक्ट डायरेक्टरी से:

```bash theme={null}
dotnet add package Mellowtel.Win
```

या अपने `.csproj` में एक `PackageReference` जोड़ें:

```xml theme={null}
<PackageReference Include="Mellowtel.Win" Version="1.0.0" />
```

### 2. अपने कोड में जोड़ें

```csharp theme={null}
using MellowtelWin;

// अपने इंटीग्रेशन ID के साथ Mellowtel को इनिशियलाइज करें
var mellowtel = new Mellowtel("YOUR_INTEGRATION_ID", new MellowtelOptions
{
    PluginId = "your-app-id"
});

// यदि उपयोगकर्ता पहले से ऑप्ट-इन कर चुका है, तो चुपचाप फिर से शुरू करें। 
// यदि नहीं, तो यह एक नो-ऑप है और false लौटाता है।
await mellowtel.StartIfOptedInAsync();

// पहली बार का प्रवाह: अपनी सहमति UI दिखाएं, फिर ऑप्ट-इन करें और शुरू करें।
if (!mellowtel.GetOptInStatus() && ShowConsentDialog())
{
    mellowtel.OptIn();
    await mellowtel.StartAsync();
}

// ऐप शटडाउन पर
await mellowtel.StopAsync();
mellowtel.Dispose();
```

<Note>
  `YOUR_INTEGRATION_ID` को अपने Mellowtel डैशबोर्ड से प्राप्त इंटीग्रेशन ID से बदलें, और `PluginId` को अपने ऐप के लिए एक स्थिर पहचानकर्ता पर सेट करें। `ShowConsentDialog()` आपकी अपनी UI है जो केवल तब `true` लौटाती है जब उपयोगकर्ता स्पष्ट रूप से सहमत होता है। नीचे [उपयोगकर्ता सहमति](#user-consent) देखें।
</Note>

### कॉन्फ़िगरेशन विकल्प

`MellowtelOptions` आपको कुछ चीजों को ट्यून करने देता है:

| प्रॉपर्टी      | प्रकार   | डिफ़ॉल्ट          | विवरण                                                           |
| -------------- | -------- | ----------------- | --------------------------------------------------------------- |
| `PluginId`     | `string` | `"mellowtel-win"` | आपके ऐप के लिए स्थिर पहचानकर्ता। इसे कुछ अनूठा सेट करें।        |
| `MaxDailyRate` | `int`    | बिल्ट-इन डिफ़ॉल्ट | अधिकतम अनुरोध जो SDK प्रतिदिन संभालेगा।                         |
| `DisableLogs`  | `bool`   | `true`            | विकास के दौरान SDK लॉग्स सक्षम करने के लिए `false` पर सेट करें। |

***

## एप्लिकेशन प्रकार के अनुसार उदाहरण

<Tabs>
  <Tab title="कंसोल ऐप">
    ```csharp theme={null}
    using MellowtelWin;

    class Program
    {
        static async Task Main(string[] args)
        {
            using var mellowtel = new Mellowtel("YOUR_INTEGRATION_ID", new MellowtelOptions
            {
                PluginId = "your-app-id"
            });

            if (!mellowtel.GetOptInStatus())
            {
                Console.WriteLine("उपयोगकर्ता को इस सेवा का उपयोग करने से पहले ऑप्ट-इन करना होगा।");
                return;
            }

            using var cts = new CancellationTokenSource();
            Console.CancelKeyPress += (s, e) => { e.Cancel = true; cts.Cancel(); };

            try
            {
                await mellowtel.StartAsync(cts.Token);
                Console.WriteLine("Mellowtel चल रहा है। बंद करने के लिए Ctrl+C दबाएं।");
                await Task.Delay(Timeout.Infinite, cts.Token);
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine($"शुरू नहीं कर सकते: {ex.Message}");
            }
            catch (OperationCanceledException)
            {
                Console.WriteLine("बंद कर रहा है...");
            }
            finally
            {
                await mellowtel.StopAsync();
            }
        }
    }
    ```
  </Tab>

  <Tab title="WPF ऐप">
    अपने `MainWindow.xaml.cs` में जोड़ें:

    ```csharp theme={null}
    using MellowtelWin;
    using System.Windows;

    public partial class MainWindow : Window
    {
        private Mellowtel? _mellowtel;

        public MainWindow()
        {
            InitializeComponent();
            Loaded += Window_Loaded;
        }

        private async void Window_Loaded(object sender, RoutedEventArgs e)
        {
            _mellowtel = new Mellowtel("YOUR_INTEGRATION_ID", new MellowtelOptions
            {
                PluginId = "your-app-id"
            });

            _mellowtel.ConnectionStateChanged += (s, connected) =>
            {
                Dispatcher.Invoke(() =>
                {
                    StatusTextBlock.Text = connected ? "Connected" : "Disconnected";
                });
            };

            // यदि पहले से ऑप्ट-इन किया गया है तो चुपचाप फिर से शुरू करें। अन्यथा अपनी सहमति UI दिखाएं।
            var started = await _mellowtel.StartIfOptedInAsync();
            if (!started)
            {
                // यहां अपनी सहमति संवाद दिखाएं
            }
        }

        protected override async void OnClosing(CancelEventArgs e)
        {
            if (_mellowtel != null)
            {
                await _mellowtel.StopAsync();
                _mellowtel.Dispose();
            }
            base.OnClosing(e);
        }
    }
    ```
  </Tab>

  <Tab title="Windows फॉर्म्स">
    अपने `MainForm.cs` में जोड़ें:

    ```csharp theme={null}
    using MellowtelWin;

    public partial class MainForm : Form
    {
        private Mellowtel? _mellowtel;

        public MainForm()
        {
            InitializeComponent();
            Load += MainForm_Load;
            FormClosing += MainForm_FormClosing;
        }

        private async void MainForm_Load(object sender, EventArgs e)
        {
            _mellowtel = new Mellowtel("YOUR_INTEGRATION_ID", new MellowtelOptions
            {
                PluginId = "your-app-id"
            });

            _mellowtel.ConnectionStateChanged += (s, connected) =>
            {
                if (InvokeRequired)
                    Invoke(() => statusLabel.Text = connected ? "Connected" : "Disconnected");
                else
                    statusLabel.Text = connected ? "Connected" : "Disconnected";
            };

            // यदि पहले से ऑप्ट-इन किया गया है तो चुपचाप फिर से शुरू करें। अन्यथा अपनी सहमति UI दिखाएं।
            var started = await _mellowtel.StartIfOptedInAsync();
            if (!started)
            {
                // यहां अपनी सहमति संवाद दिखाएं
            }
        }

        private async void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (_mellowtel != null)
            {
                await _mellowtel.StopAsync();
                _mellowtel.Dispose();
            }
        }
    }
    ```
  </Tab>
</Tabs>

### कनेक्शन स्थिति का अवलोकन

`Mellowtel` इंस्टेंस एक `ConnectionStateChanged` इवेंट को उजागर करता है जो हर बार फायर होता है जब Mellowtel के बैकएंड के लिए अंतर्निहित वेब सॉकेट कनेक्ट या डिस्कनेक्ट होता है। ऊपर दिए गए WPF और Windows फॉर्म्स उदाहरण इसे एक स्थिति संकेतक चलाने के लिए सब्सक्राइब करते हैं। पेलोड एक `bool` है जहां `true` का मतलब कनेक्टेड है और `false` का मतलब डिस्कनेक्टेड है।

यह इवेंट एक बैकग्राउंड थ्रेड पर फायर होता है, इसलिए UI फ्रेमवर्क जो थ्रेड एफिनिटी को लागू करते हैं, उन्हें UI थ्रेड पर अपडेट्स को मार्शल करना चाहिए। WPF में `Dispatcher.Invoke` का उपयोग करें, और Windows फॉर्म्स में `Control.Invoke` का उपयोग करें (दोनों ऊपर दिए गए उदाहरणों में दिखाए गए हैं)।

<Note>
  **WPF `async void OnClosing` पैटर्न के बारे में।** ऊपर दिया गया WPF उदाहरण `protected override async void OnClosing` का उपयोग करता है, जो सबसे सरल रूप है लेकिन इसमें एक सूक्ष्म समस्या है: `base.OnClosing(e)` को सिंक्रोनसली कॉल किया जाता है जबकि `StopAsync()` अभी भी प्रतीक्षा कर रहा है, इसलिए विंडो सफाई समाप्त होने से पहले बंद हो सकती है। अधिकांश ऐप्स के लिए यह ठीक है क्योंकि प्रक्रिया तुरंत बाद में समाप्त हो जाती है। यदि आपको एक गारंटीड ग्रेसफुल शटडाउन की आवश्यकता है (उदाहरण के लिए, टेलीमेट्री को फ्लश करने के लिए), तो [Microsoft द्वारा प्रलेखित डिफरल पैटर्न](https://learn.microsoft.com/en-us/dotnet/api/system.windows.window.closing) का पालन करें जहां आप `e.Cancel = true` सेट करते हैं, अपने असिंक्रोनस कार्य का `await` करते हैं, और फिर विंडो को स्पष्ट रूप से बंद करते हैं।
</Note>

***

## उपयोगकर्ता सहमति

<Warning>
  सहमति संवाद दिखाना **अनिवार्य** है। SDK इसे लागू करता है: `StartAsync()` उपयोगकर्ता के ऑप्ट-इन न करने पर `InvalidOperationException` फेंकता है।
</Warning>

```csharp theme={null}
var mellowtel = new Mellowtel("YOUR_INTEGRATION_ID", new MellowtelOptions
{
    PluginId = "your-app-id"
});

if (!mellowtel.GetOptInStatus())
{
    var userAgreed = ShowConsentDialog(); // आपका कस्टम संवाद

    if (userAgreed)
        mellowtel.OptIn();
    else
        return; // उपयोगकर्ता ने अस्वीकार कर दिया, शुरू न करें
}

try
{
    await mellowtel.StartAsync();
}
catch (InvalidOperationException ex)
{
    Console.WriteLine($"त्रुटि: {ex.Message}");
}
```

### आपकी सहमति संवाद में क्या शामिल होना चाहिए

<Steps>
  <Step title="समझाएं कि Mellowtel क्या करता है">
    साधारण भाषा का उपयोग करें। उदाहरण: *"यह ऐप आपके अप्रयुक्त इंटरनेट बैंडविड्थ को साझा करने के लिए Mellowtel का उपयोग करता है। इससे आपको \[लाभ/विशेषता] मिलती है। आप किसी भी समय सेटिंग्स में ऑप्ट-आउट कर सकते हैं।"*
  </Step>

  <Step title="उपयोगकर्ताओं को स्पष्ट विकल्प दें">
    अलग-अलग स्वीकार और अस्वीकार विकल्प शामिल करें।
  </Step>

  <Step title="नीतियों के लिए लिंक शामिल करें">
    [सेवा की शर्तें](https://www.mellowtel.com/terms-and-conditions) और [गोपनीयता नीति](https://www.mellowtel.com/privacy-policy) के लिंक शामिल करें।
  </Step>
</Steps>

### उपयोगकर्ताओं को सेटिंग्स में अपनी सहमति बदलने दें

```csharp theme={null}
// वर्तमान स्थिति की जाँच करें
bool isOptedIn = mellowtel.GetOptInStatus();

// ऑप्ट-आउट करें
if (userWantsToOptOut)
{
    mellowtel.OptOut();
    await mellowtel.StopAsync();
}

// फिर से ऑप्ट-इन करें
if (userWantsToOptIn)
{
    mellowtel.OptIn();
    await mellowtel.StartAsync();
}
```

अधिक समृद्ध UI के लिए (उदाहरण के लिए, यह दिखाने के लिए कि उपयोगकर्ता ने पहली बार कब ऑप्ट-इन किया था), `GetOptInDetails()` ऑप्ट-इन स्थिति के साथ-साथ ऑप्ट-इन और ऑप्ट-आउट टाइमस्टैम्प लौटाता है:

```csharp theme={null}
var (isOptedIn, optInDate, optOutDate) = mellowtel.GetOptInDetails();
```

***

## समस्या निवारण

<AccordionGroup>
  <Accordion title="&#x22;पैकेज नहीं मिला&#x22; त्रुटि">
    1. सुनिश्चित करें कि आपका प्रोजेक्ट **.NET 10** या बाद के संस्करण को लक्षित करता है। `Mellowtel.Win` को `net10.0` की आवश्यकता है।
    2. NuGet कैश को साफ़ करें और पुनर्स्थापित करें:

    ```bash theme={null}
    dotnet nuget locals all --clear
    dotnet restore
    ```
  </Accordion>

  <Accordion title="&#x22;InvalidOperationException: उपयोगकर्ता ने ऑप्ट-इन नहीं किया है&#x22;">
    `StartAsync()` को स्पष्ट सहमति की आवश्यकता होती है। जब आपकी सहमति संवाद सकारात्मक परिणाम लौटाता है, तो `OptIn()` कॉल करें, फिर `StartAsync()` कॉल करें। बाद के लॉन्च पर चुपचाप फिर से शुरू करने के लिए, इसके बजाय `StartIfOptedInAsync()` का उपयोग करें, जो तब एक नो-ऑप है जब उपयोगकर्ता ने ऑप्ट-इन नहीं किया है।
  </Accordion>
</AccordionGroup>

***

पूरा करने का अनुमानित समय: 10-15 मिनट।

यदि आपको सहायता की आवश्यकता है या आपके पास कोई प्रतिक्रिया है, तो हमसे [info@mellowtel.com](mailto:info@mellowtel.com) पर संपर्क करें या हमारे [Discord समुदाय](https://discord.com/invite/txAZp4MSDe) में शामिल हों।