# Basics

## Validating Client

To validate if the client application is connected using Wisej.NET Hybrid, you can use:

```csharp
bool valid = Wisej.Hybrid.Device.Valid;
```

## Reading Device Information

Information about the hybrid client device is available using the **Device.Info** member. The **Info** member contains a number of predefined modules such as system, app version, and battery state information. These modules can be accessed using the following approach in C# and Wisej.NET:

```csharp
// determine the power source of the connected hybrid device.
BatteryPowerSource powerSource = Device.Info.Battery.PowerSource;

// determine if this is a "first launch" of the application since installation.
bool isFirstLaunchEver = Device.Info.Versioning.IsFirstLaunchEver;

// determine hybrid client cache directory.
string cacheDirectory = Device.Info.FileSystem.CacheDirectory;
```

Some modules that register information about the hybrid client device are registered dynamically like those that are provided in the Wisej.NET Hybrid Extensions. Those modules can be accessed using the **Device.Use\<T>()** method included where **T** is an implementation of **IClientInfoProvider**.

```csharp
// get the type of biometrics supported by the device.
AuthenticationType = Device.Info.Use<AuthenticationInfoProvider>().AuthenticationType;
```

This same approach can be used to access built-in modules:

```csharp
// determine hybrid client app data directory.
string cacheDirectory = Device.Info.Use<FileSystemInfoProvider>().AppDataDirectory;
```

## Properties

A number of properties used to configure the hybrid client device are exposed through built-in modules such as **Device.Flyout** and **Device.Email**.

```csharp
// set the device flyout items.
Device.Flyout.Items = new FlyoutItem[] {
    new FlyoutItem("Home", "Home.png"),
    new FlyoutItem("Settings", "Settings.png")
};

// determine if email composing is supported on the client hybrid device.
bool isComposeSupported = Device.Email.IsComposeSupported;
```

{% hint style="warning" %}
The first time a property is read from the value will be retrieved modally from the client device. This operation will suspend the current thread until a value is retrieved.
{% endhint %}

Alternatively, properties can be registered through dynamic modules such as those provided in the Wisej.NET Hybrid Extensions. These can be read from and assigned using the **Device.Use\<T> method** where **T** is the name of the module type.

```csharp
// set the statusbar background color
Device.Use<Statusbar>().BackColor = Color.Blue;
```

## Methods

Methods can be used to interact with the hybrid client device's hardware or user interface such as toggling a flashlight or writing a file to the client device.

```csharp
// enabling the device's flashlight.
Device.Flashlight.TurnOn();

// disabling the device's flashlight.
Device.Flashlight.TurnOff();

// write text to a file in the client app data directory.
var path = Path.Combine(Device.FileSystem.AppDataDirectory, "MyFile.txt");
Device.FileSystem.WriteAllText(path, "Hello, World!");

// show a native MAUI view modally and retrieve the response.
var fullyQualifiedName = "MyAssembly.MyType, MyAssembly";
var result = Device.Navigation.ShowDialog(fullyQualifiedName, "arg1", 2, 3);
```

Alternatively, some Wisej.NET Hybrid Extensions may register modules with methods dynamically. These can be called using the **Device.Get\<T> method** where **T** is the name of the module type.

```csharp
// authenticate a user
bool authenticated = Device.Use<DeviceAuthentication>().Authenticate();
```

{% hint style="warning" %}
In the case of calling any method that returns a value with Wisej.NET Hybrid, the operation is modal. The modal operation **suspends the current thread** until the value is returned from the client device.
{% endhint %}

## Events

Events from the hybrid client device are automatically wired from the client device to the Wisej.NET application. Events can be accessed from a member of a built-in module such as **Device.Battery**, **Device.Flyout**, **or Device.TabBar:**

```csharp
// attaching to a battery state event.
Device.Info.Battery.BatteryInfoChanged += Device_BatteryInfoChanged;

// attaching to a flyout item selection event.
Device.Flyout.ItemSelected += Device_FlyoutItemSelected;
```

Alternatively, dynamically registered modules such as the Wisej.NET Hybrid Extensions can be accessed and attached using the **Device.Use\<T>()** method where **T** is the name of the module type.

```csharp
// attaching to a registration event for remote notification tokens.
Device.Use<DeviceRemoteNotifications>().RegisteredForRemoteNotifications += Device_RegisteredForRemoteNotifications;
```

{% hint style="warning" %}
All **Device** member events should be manually disconnected when the event is no longer in use.
{% endhint %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.wisej.com/hybrid/development/basics.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.