// build.gradle file:
dependencies {
    .
    .
    .
    // Mudra SDK: 
        //implement the .aar file.
        implementation files(rootDir.absolutePath+'Path/MudraAndroidSDK.aar') 

    //Cloud support:
        implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
        implementation 'com.squareup.retrofit2:retrofit:2.9.0'
        implementation 'com.squareup.retrofit2:adapter-rxjava2:2.9.0'
        implementation 'com.squareup.retrofit2:converter-scalars:2.9.0'
        implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
        implementation 'com.squareup.okhttp3:logging-interceptor:5.0.0-alpha.6'

    // Bluetooth support:
        implementation 'no.nordicsemi.android:ble:2.6.0'
        implementation 'no.nordicsemi.android.support.v18:scanner:1.6.0'
}

// manifest file:    
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

//Replace your email.
Mudra.getInstance().getLicenseForEmailFromCloud("-----@------", (success, errorResult) -> {
    if( success ) {
        Log.d(TAG , "licenses set successfully.");
    } else {
        Log.d(TAG , "failed to set licenses : " + errorResult +".");
    }
});

# Replace your email.
from mudra_sdk import Mudra

def callback(success, error_result):
    if success:
        print("licenses set successfully.")
    else:
        print(f"failed to set licenses : {error_result}.")

Mudra().get_license_for_email_from_cloud("-----@------", callback)

public class MainActivity extends AppCompatActivity {

    private ActivityMainBinding binding;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        binding = ActivityMainBinding.inflate(getLayoutInflater());
        setContentView(binding.getRoot());
        initializeMudra();
    }

    private void initializeMudra()
    {
        Mudra.getInstance().requestAccessPermissions(this);
        Mudra.getInstance().getLicenseForEmailFromCloud("-----@------", (success, errorResult) -> {
            if( success ) {
                Log.d(TAG , "licenses set successfully.");
            } else {
                Log.d(TAG , "failed to set licenses : " + errorResult +".");
            }
        });
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_main, menu);
        return true;
    }
}

//--------------------------------------------------------------------------------------------------------------------
private void setMudraDelegate() {
    Mudra.getInstance().setMudraDelegate(new MudraDelegate() {
        @Override
        public void onDeviceDiscovered(MudraDevice mudraDevice) {

        }

        @Override
        public void onDeviceConnecting(MudraDevice mudraDevice) {

        }

        @Override
        public void onDeviceConnectedByAndroidOS(MudraDevice mudraDevice) {

        }

        @Override
        public void onDeviceFailedToConnect(MudraDevice mudraDevice) {

        }

        @Override
        public void onDeviceConnected(MudraDevice mudraDevice) {

        }

        @Override
        public void onDeviceDisconnecting(MudraDevice mudraDevice) {

        }

        @Override
        public void onDeviceDisconnected(MudraDevice mudraDevice) {

        }
    });
}

from mudra_sdk import Mudra, MudraDevice
from mudra_sdk.models.callbacks import MudraDelegate

def set_mudra_delegate():
    # Implement delegate to handle device events
    class MyMudraDelegate(MudraDelegate):
        def on_device_discovered(self, device: MudraDevice):
            print(f"Discovered: {device.name} ({device.address})")

        def on_mudra_device_connected(self, device: MudraDevice):
            print(f"Device connected: {device.name}")

        def on_mudra_device_disconnected(self, device: MudraDevice):
            print(f"Device disconnected: {device.name}")

        def on_mudra_device_connecting(self, device: MudraDevice):
            print(f"Device connecting: {device.name}...")

        def on_mudra_device_disconnecting(self, device: MudraDevice):
            print(f"Device disconnecting: {device.name}...")

        def on_mudra_device_connection_failed(self, device: MudraDevice, error: str):
            print(f"Connection failed: {device.name}, Error: {error}")

        def on_bluetooth_state_changed(self, state: bool):
            print(f"Bluetooth state changed: {'On' if state else 'Off'}")

    # Set the delegate
    Mudra().set_delegate(MyMudraDelegate())

mudraDevice.getBatteryLevel() // int, Returns the device's battery level.

mudraDevice.getFirmwareVersion() // String, Returns the device's firmware version, returns **empty string** in case there is no firmware version.

mudraDevice.getSerialNumber() // long, Returns the device's the device's serial number, or **0** in case there is no serial number.

mudraDevice.getDeviceNumberByName() // String, Returns the device's band number, or **0** in case there is no band number.

mudraDevice.get_battery_level() # int, Returns the device's battery level.

mudraDevice.get_firmware_version() # str, Returns the device's firmware version, returns "" in case there is no firmware version.

mudraDevice.get_serial_number() # int, Returns the device's serial number, or 0 in case there is no serial number.

mudraDevice.get_device_number_by_name() # str, Returns the device's band number, or "0" in case there is no band number.

// Check if navigation feature is enabled
boolean isNavigationEnabled = mudraDevice.getFirmwareStatus().isNavigationEnabled();

// Check if gesture feature is enabled
boolean isGestureEnabled = mudraDevice.getFirmwareStatus().isGestureEnabled();

// Check if pressure feature is enabled
boolean isPressureEnabled = mudraDevice.getFirmwareStatus().isPressureEnabled();

// Check if SNC (Surface Nerve Conductance) feature is enabled
boolean isSncEnabled = mudraDevice.getFirmwareStatus().isSncEnabled();

// Check if accelerometer feature is enabled
boolean isAccEnabled = mudraDevice.getFirmwareStatus().isAccEnabled();

// Check if gyroscope feature is enabled
boolean isGyroEnabled = mudraDevice.getFirmwareStatus().isGyroEnabled();

// Check if quaternion feature is enabled
boolean isQuaternionEnabled = mudraDevice.getFirmwareStatus().isQuaternionEnabled();

// Check if firmware sends navigation delta X and delta Y to the app on movement
boolean isSendsToAppEnabled = mudraDevice.getFirmwareStatus().isSendsNavigationToAppEnabled();

// Check if firmware sends navigation delta X and delta Y to the HID (Human Interface Device)
boolean isSendsToNavigationHIDEnabled = mudraDevice.getFirmwareStatus().isSendsNavigationToHIDEnabled();

// Check if firmware sends mouse click and release on gesture to the HID
boolean isSendsToGestureHIDEnabled = mudraDevice.getFirmwareStatus().isSendsGestureToHIDEnabled();

// Check if Air-Touch feature is enabled
boolean isAirTouchEnabled = mudraDevice.getFirmwareStatus().isAirTouchEnabled();

// Request the firmware to send its status
mudraDevice.requestForFirmwareStatus();

// Set a callback to be executed each time the firmware status changes
mudraDevice.setOnFirmwareStatusChanged(new OnFirmwareStatusChanged() {
    @Override
    public void run(boolean updated) {
        // Implement callback logic here
    }
});

# Check if navigation feature is enabled
is_navigation_enabled = mudra_device.firmware_status.is_navigation_enabled()

# Check if gesture feature is enabled
is_gesture_enabled = mudra_device.firmware_status.is_gesture_enabled()

# Check if pressure feature is enabled
is_pressure_enabled = mudra_device.firmware_status.is_pressure_enabled()

# Check if SNC (Surface Nerve Conductance) feature is enabled
is_snc_enabled = mudra_device.firmware_status.is_snc_enabled()

# Check if accelerometer feature is enabled
is_acc_enabled = mudra_device.firmware_status.is_acc_enabled()

# Check if gyroscope feature is enabled
is_gyro_enabled = mudra_device.firmware_status.is_gyro_enabled()

# Check if quaternion feature is enabled
is_quaternion_enabled = mudra_device.firmware_status.is_quaternion_enabled()

# Check if firmware sends navigation delta X and delta Y to the app on movement
is_sends_to_app_enabled = mudra_device.firmware_status.is_sends_navigation_to_app_enabled()

# Check if firmware sends navigation delta X and delta Y to the HID (Human Interface Device)
is_sends_to_navigation_hid_enabled = mudra_device.firmware_status.is_sends_navigation_to_hid_enabled()

# Check if firmware sends mouse click and release on gesture to the HID
is_sends_to_gesture_hid_enabled = mudra_device.firmware_status.is_sends_gesture_to_hid_enabled()

# Check if Air-Touch feature is enabled
is_air_touch_enabled = mudra_device.firmware_status.is_air_touch_enabled()

# Request the firmware to send its status
mudra_device.request_for_firmware_status()

# Set a callback to be executed each time the firmware status changes
def on_firmware_status_changed(updated):
    # Implement callback logic here
    pass

mudra_device.set_on_firmware_status_changed(on_firmware_status_changed)

mudraDevice.setOnChargingStatusChange(new OnChargingStatusChanged() {
    @Override
    public void run(boolean isCharging) {

    }
});

mudraDevice.setOnBatteryLevelChanged(new OnBatteryLevelChanged() {
    @Override
    public void run(int batteryLevel) {

    }
});

def on_charging_status_changed(is_charging):
    # Implement callback logic here
    pass

def on_battery_level_changed(battery_level):
    # Implement callback logic here
    pass

mudra_device.set_on_charging_status_change(on_charging_status_changed)
mudra_device.set_on_battery_level_changed(on_battery_level_changed)

//To set hand
mudraDevice.setHand(HandType.RIGHT);
mudraDevice.setHand(HandType.LEFT);

# To set hand
mudra_device.set_hand(HandType.right)
mudra_device.set_hand(HandType.left)

// Enable registration for the SNC callback.
mudraDevice.setOnSncReady(new OnSncReady() {
    @Override
    public void run(long timestamp, float[] data, int frequency, float frequencyStd, float[] rms) {
        // 'data' contains 24 values total:
        //   indices [0–7)   → SNC channel 1
        //   indices [8–15)  → SNC channel 2
        //   indices [16–23) → SNC channel 3

        // 'frequency' is the number of SNC packets received per second.

        // 'frequencyStd' is the standard deviation of the packet frequency.

        // 'rms' contains the root-mean-square value for each SNC channel:
        //   rms[0] → channel 1
        //   rms[1] → channel 2
        //   rms[2] → channel 3
    }
});

// Disable registration by passing null.
mudraDevice.setOnSncReady(null)

// Check whether the callback is currently registered.
// Returns true if a callback is set, false otherwise.
mudraDevice.isOnSncCallbackSet(); // returns true in case the callback is set, false otherwise.

# Enable registration for the SNC callback.
def on_snc_ready(timestamp, data, frequency, frequency_std, rms):
    # 'data' contains 24 values total:
    #   indices [0–7)   -> SNC channel 1
    #   indices [8–15)  -> SNC channel 2
    #   indices [16–23) -> SNC channel 3

    # 'frequency' is the number of SNC packets received per second.

    # 'frequency_std' is the standard deviation of the packet frequency.

    # 'rms' contains the root-mean-square value for each SNC channel:
    #   rms[0] -> channel 1
    #   rms[1] -> channel 2
    #   rms[2] -> channel 3
    pass

mudra_device.set_on_snc_ready(on_snc_ready)

# Disable registration by passing None.
mudra_device.set_on_snc_ready(None)

# Check whether the callback is currently registered.
# Returns True if a callback is set, False otherwise.
mudra_device.is_on_snc_callback_set()

// Enable registration for the IMU gyro callback.
mudraDevice.setOnImuGyroReady(new OnImuGyroReady() {
        @Override
        public void run(long timestamp, float[] data, int frequency, float frequencyStd) {
            // 'data' contains 24 values arranged in interleaved groups:
            //   indices [0, 3, 6, 9, 12, 15, 18, 21] → GYRO channel 1
            //   indices [1, 4, 7, 10, 13, 16, 19, 22] → GYRO channel 2
            //   indices [2, 5, 8, 11, 14, 17, 20, 23] → GYRO channel 3

            // 'frequency' is the number of gyro packets received per second.
            // 'frequencyStd' is the standard deviation of that frequency.
        }
});

// Disable registration by passing null.
mudraDevice.setOnImuGyroReady(null)


// Check whether the callback is currently registered.
// Returns true if a callback is set, false otherwise.
mudraDevice.isOnImuGyroCallbackSet(); // returns true in case the callback is set, false otherwise.

# Enable registration for the IMU gyro callback.
def on_imu_gyro_ready(timestamp, data, frequency, frequency_std):
    # 'data' contains 24 values arranged in interleaved groups:
    #   indices [0, 3, 6, 9, 12, 15, 18, 21] -> GYRO channel 1
    #   indices [1, 4, 7, 10, 13, 16, 19, 22] -> GYRO channel 2
    #   indices [2, 5, 8, 11, 14, 17, 20, 23] -> GYRO channel 3

    # 'frequency' is the number of gyro packets received per second.
    # 'frequency_std' is the standard deviation of that frequency.
    pass

mudra_device.set_on_imu_gyro_ready(on_imu_gyro_ready)

# Disable registration by passing None.
mudra_device.set_on_imu_gyro_ready(None)

# Check whether the callback is currently registered.
# Returns True if a callback is set, False otherwise.
mudra_device.is_on_imu_gyro_callback_set()

// Enable registration for the raw accelerometer callback.
mudraDevice.setOnImuAccRawReady(new OnImuAccRawReady() {
    @Override
    public void run(long timestamp, float[] data, int frequency, float frequencyStd) {
        // 'data' contains 24 values arranged in an interleaved pattern:
        //   indices [0, 3, 6, 9, 12, 15, 18, 21] → ACC channel 1
        //   indices [1, 4, 7, 10, 13, 16, 19, 22] → ACC channel 2
        //   indices [2, 5, 8, 11, 14, 17, 20, 23] → ACC channel 3

        // 'frequency' is the number of accelerometer packets received per second.
        // 'frequencyStd' is the standard deviation of that packet frequency.
    }
});

// Disable registration by passing null.
mudraDevice.setOnImuAccRawReady(null)


// Check whether the callback is currently registered.
// Returns true if a callback is set, false otherwise.
mudraDevice.isOnImuAccRawCallbackSet();

# Enable registration for the raw accelerometer callback.
def on_imu_acc_raw_ready(timestamp, data, frequency, frequency_std):
    # 'data' contains 24 values arranged in an interleaved pattern:
    #   indices [0, 3, 6, 9, 12, 15, 18, 21] -> ACC channel 1
    #   indices [1, 4, 7, 10, 13, 16, 19, 22] -> ACC channel 2
    #   indices [2, 5, 8, 11, 14, 17, 20, 23] -> ACC channel 3

    # 'frequency' is the number of accelerometer packets received per second.
    # 'frequency_std' is the standard deviation of that packet frequency.
    pass

mudra_device.set_on_imu_acc_raw_ready(on_imu_acc_raw_ready)

# Disable registration by passing None.
mudra_device.set_on_imu_acc_raw_ready(None)

# Check whether the callback is currently registered.
# Returns True if a callback is set, False otherwise.
mudra_device.is_on_imu_acc_raw_callback_set()

//To enable register, for the callback.
mudraDevice.setOnPressureReady(new OnPressureReady() {
    @Override
    public void run(float pressure) {

    }
});

//To disable put null.
mudraDevice.setOnPressureReady(null)

//To check if the callback is set.
mudraDevice.isOnPressureReadySet(); // returns true in case the callback is set, false otherwise.

# To enable/register for the callback.
def on_pressure_ready(pressure):
    # Use the pressure value (float between 0.0 and 1.0)
    pass

mudra_device.set_on_pressure_ready(on_pressure_ready)

# To disable, pass None.
mudra_device.set_on_pressure_ready(None)

# To check if the callback is set.
mudra_device.is_on_pressure_ready_set()  # returns True if set, False otherwise

// Enable discrete gestures
mudraDevice.setOnGestureReady(new OnGestureReady() {
    @Override
    public void run(GestureType gestureType) {
        // Callback executed when a discrete gesture is detected
    }
});

// Disable discrete gestures
mudraDevice.setOnGestureReady(null);


// Enable continuous gestures
mudraDevice.setOnButtonChanged(new OnButtonChanged() {
    @Override
    public void run(AirMouseCommand airMouseCommand) {
        // buttonEvent == AirMouseCommand.Release for release event
        // buttonEvent == AirMouseCommand.Press for press event
    }
});

// Disable continuous gestures
mudraDevice.setOnButtonChanged(null);


// Enable sending HID commands "Mouse Left Button Press" and "Mouse Left Button Release"
// by setting sending to Firmware Target GESTURE_TO_HID.
mudraDevice.setFirmwareTarget(FirmwareTarget.GESTURE_TO_HID, true); // Enable sending through HID
mudraDevice.setFirmwareTarget(FirmwareTarget.GESTURE_TO_HID, false); // Disable sending through HID

# Enable discrete gestures
def on_gesture_ready(gesture_type):
    # Callback executed when a discrete gesture is detected (e.g., Tap, Double Tap, Twist, Double Twist)
    pass

mudra_device.set_on_gesture_ready(on_gesture_ready)

# Disable discrete gestures
mudra_device.set_on_gesture_ready(None)

# Enable continuous gestures
def on_button_changed(air_mouse_command):
    # air_mouse_command == "Press" for press event
    # air_mouse_command == "Release" for release event
    pass

mudra_device.set_on_button_changed(on_button_changed)

# Disable continuous gestures
mudra_device.set_on_button_changed(None)

# Enable sending HID commands "Mouse Left Button Press" and "Mouse Left Button Release"
mudra_device.set_firmware_target(FirmwareTarget.gesture_to_hid, True)  # Enable
mudra_device.set_firmware_target(FirmwareTarget.gesture_to_hid, False) # Disable

// To enable navigation:\
mudraDevice.setOnNavigationReady(new OnNavigationReady() {
        @Override
        public void run(int delta_x, int delta_y) {
            // Callback executed when receiving Delta_x and Delta_y
            // In case enabled: mudraDevice.setFirmwareTarget(FirmwareTarget.NAVIGATION_TO_APP, true).
        }
});
// To disable navigation:
mudraDevice.setOnNavigationReady(null);

// Developer can control where to send the navigation Delta_x and Delta_y:
mudraDevice.setFirmwareTarget(FirmwareTarget.NAVIGATION_TO_HID, true);  // Enable sending Delta_x and Delta_y through HID
mudraDevice.setFirmwareTarget(FirmwareTarget.NAVIGATION_TO_HID, false); // Disable sending Delta_x and Delta_y through HID

mudraDevice.setFirmwareTarget(FirmwareTarget.NAVIGATION_TO_APP, true);  // Enable sending Delta_x and Delta_y to the app as a callback
mudraDevice.setFirmwareTarget(FirmwareTarget.NAVIGATION_TO_APP, false); // Disable sending Delta_x and Delta_y to the app as a callback

# To enable navigation:
def on_navigation_ready(delta_x, delta_y):
    # Callback executed when receiving Delta_x and Delta_y
    pass

mudra_device.set_on_navigation_ready(on_navigation_ready)

# To disable navigation:
mudra_device.set_on_navigation_ready(None)

# Developer can control where to send the navigation Delta_x and Delta_y:
mudra_device.set_firmware_target(FirmwareTarget.navigation_to_hid, True)   # Enable sending through HID
mudra_device.set_firmware_target(FirmwareTarget.navigation_to_hid, False)  # Disable HID

mudra_device.set_firmware_target(FirmwareTarget.navigation_to_app, True)   # Enable sending to app as callback
mudra_device.set_firmware_target(FirmwareTarget.navigation_to_app, False)  # Disable sending to app

//To enable
mudraDevice.setOnImuQuaternionReady(new OnImuQuaternionReady() {
        @Override
        public void run(long l, float[] floats) {
            //floats[0] -> W
            //floats[1] -> X
            //floats[2] -> Y
            //floats[3] -> Z
        }
});

//To disable
mudraDevice.setOnImuQuaternionReady(null);

# To enable
def on_imu_quaternion_ready(timestamp, quaternion):
    # quaternion[0] -> W
    # quaternion[1] -> X
    # quaternion[2] -> Y
    # quaternion[3] -> Z
    pass

mudra_device.set_on_imu_quaternion_ready(on_imu_quaternion_ready)

# To disable
mudra_device.set_on_imu_quaternion_ready(None)

mudraDevice.setAirTouchActive(true); // To activate Air-Touch
mudraDevice.setAirTouchActive(false); // To deactivate Air-Touch

mudra_device.set_air_touch_active(True)   # To activate Air-Touch
mudra_device.set_air_touch_active(False)  # To deactivate Air-Touch