InterfaceService¶

Method	LWM2M request	Description
getAppName	GET /interface/app-name	Get application name
getAppPath	GET /interface/app-path	Get app path
getAuthorizedHostProtocol	GET /interface/authorized-host-protocol	Get authorized host protocols
getAvailableHostProtocols	GET /interface/available-host-protocols	Get available host protocols
getBleAddress	GET /interface/ble/address	Get ble address
getCloudClientId	GET /interface/cloud/client-id	Get cloud client id
getCloudConnectionMode	GET /interface/cloud/connection-mode	Get cloud connection mode
getCloudGatewayUrl	GET /interface/cloud-gateway-url	Get cloud gateway url
getCloudLogin	GET /interface/cloud/login	Get cloud login id
getCloudMqttPeriod	GET /interface/cloud/mqtt-period	Get cloud mqtt period
getCloudPassword	GET /interface/cloud/password	Get cloud password
getCloudServiceName	GET /interface/cloud/service-name	Get the cloud service name
getCom	GET /secure-element/com	encrypted communication channel
getConfigFormatFirmwareVersion	GET /interface/config-format-firmware-version	Get config format firmware version
getConfigFormatVersion	GET /interface/config-format-version	Get config format version
getConfigVersion	GET /interface/config-version	Get config version
getConfigure	GET /secure-element/configure	Get configuration of Secure Element
getCurrentGroupId	GET /interface/current-group-id	Get current group id
getCurrentHostProtocol	GET /interface/current-host-protocol	Get current host protocol
getCurrentProfileId	GET /interface/current-profile/id	Get current profile id
getFunctions	GET /interface/functions	Get functions
getHostInactivityPeriod	GET /interface/host-inactivity-period	Get host inactivity period
getLock	GET /interface/lock	Get lock infos
getMqttRelayClientId	GET /interface/mqtt/relay/client-id	Get mqtt relay client id
getMqttRelayLogin	GET /interface/mqtt/relay/login	Get mqtt relay login
getMqttRelayNetKey	GET /interface/mqtt/relay/net-key	Get the mqtt net key for the server
getMqttRelayPassword	GET /interface/mqtt/relay/password	Get the mqtt relay password
getMqttRelayPort	GET /interface/mqtt/relay/port	Get port of the mqtt broker
getMqttRelayUrl	GET /interface/mqtt/relay/url	Get mqtt relay url
getNetworkGatewayIp	GET /interface/network/gateway-ip	Get iotize gateway ip on the network
getNetworkInfraIp	GET /interface/network/infra-ip	Get IoTize device ip on the network
getNetworkInfraIpMask	GET /interface/network/infra-ip-mask	Get infrastructure ip mask
getNetworkMode	GET /interface/network-mode	Get network mode
getNfcPairingMode	GET /interface/nfc/pairing-mode	Check if nfc paring is mandatory
getPowerOptimisationLevel	GET /interface/power-optimisation-level	Get power optimization level
getPublicPassword	GET /interface/public-password	Get the public password ?
getRand	GET /interface/rand	Generate a random number
getWepKey	GET /interface/wep-key	Get network key
getWifiHostname	GET /interface/wifi/hostname	Get wifi hostname
getWifiSSID	GET /interface/wifi/ssid	Get wifi ssid
keepAlive	GET /interface/keep-alive	Keep alive.
login	POST /interface/login	Login
logout	POST /interface/logout	Logout
multiCommands	GET /interface/multi-commands	Execute multiple commands sent in one frame, and return all answers in one
postConfigVersion	POST /interface/config-version	???
postLoginUid	POST /interface/login-uid	Admnistration login
putAppName	PUT /interface/app-name	Set application name
putAppPath	PUT /interface/app-path	Set app path
putAuthorizedHostProtocol	PUT /interface/authorized-host-protocol	Write authorized host protocols
putCloudConnectionMode	PUT /interface/cloud/connection-mode	Write cloud connection mode
putCloudGatewayUrl	PUT /interface/cloud-gateway-url	Write cloud gateway url
putCloudMqttPeriod	PUT /interface/cloud/mqtt-period	Write cloud mqtt period
putCloudPassword	PUT /interface/cloud/password	Write cloud password
putCloudServiceName	PUT /interface/cloud/service-name	Write cloud service name
putConfigFormatVersion	PUT /interface/config-format-version	Set config format version
putConfigVersion	PUT /interface/config-version	Set config version
putConfigure	PUT /secure-element/configure	Write secure element configuration
putCurrentHostProtocol	PUT /interface/current-host-protocol	Write current host protocol
putHostInactivityPeriod	PUT /interface/host-inactivity-period	Write host inactivity period
putLock	PUT /interface/lock	Set lock infos
putMqttRelayNetKey	PUT /interface/mqtt/relay/net-key	Write mqtt net key
putMqttRelayPassword	PUT /interface/mqtt/relay/password	Write mqtt relay password
putMqttRelayPort	PUT /interface/mqtt/relay/port	Write service name of the mqtt broker
putMqttRelayUrl	PUT /interface/mqtt/relay/url	Write mqtt relay url
putNetworkGatewayIp	PUT /interface/network/gateway-ip	Write iotize gateway ip
putNetworkInfraIp	PUT /interface/network/infra-ip	Write infrastructure ip
putNetworkInfraIpMask	PUT /interface/network/infra-ip-mask	Write infrastructure ip mask
putNetworkMode	PUT /interface/network-mode	Write network mode
putNfcPairingMode	PUT /interface/nfc/pairing-mode	Change wether if nfc pairing is mandatory
putPowerOptimisationLevel	PUT /interface/power-optimisation-level	Write power optimization level
putWepKey	PUT /interface/wep-key	Write network key
putWifiSsid	PUT /interface/wifi/ssid	Write wifi ssid

getAppName¶

String getAppName()

Get application name

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getAppName();
    let value = (await call).body();
    console.log(`getAppName: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getAppName();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getAppName");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getAppPath¶

String getAppPath()

Get app path

Application Android à lancer ou page HTML à afficher quand l'IoTize est détecté par le téléphone

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getAppPath();
    let value = (await call).body();
    console.log(`getAppPath: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getAppPath();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getAppPath");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getAuthorizedHostProtocol¶

ListHostProtocol getAuthorizedHostProtocol()

Get authorized host protocols

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getAuthorizedHostProtocol();
    let value = (await call).body();
    console.log(`getAuthorizedHostProtocol: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<ListHostProtocol> call = myService.getAuthorizedHostProtocol();
    Response<ListHostProtocol> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getAuthorizedHostProtocol");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

ListHostProtocol

Authorization¶

No authorization required

getAvailableHostProtocols¶

ListHostProtocol getAvailableHostProtocols()

Get available host protocols

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getAvailableHostProtocols();
    let value = (await call).body();
    console.log(`getAvailableHostProtocols: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<ListHostProtocol> call = myService.getAvailableHostProtocols();
    Response<ListHostProtocol> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getAvailableHostProtocols");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

ListHostProtocol

Authorization¶

No authorization required

getBleAddress¶

String getBleAddress()

Get ble address

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getBleAddress();
    let value = (await call).body();
    console.log(`getBleAddress: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getBleAddress();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getBleAddress");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getCloudClientId¶

String getCloudClientId()

Get cloud client id

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getCloudClientId();
    let value = (await call).body();
    console.log(`getCloudClientId: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getCloudClientId();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getCloudClientId");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getCloudConnectionMode¶

CloudConnectionMode getCloudConnectionMode()

Get cloud connection mode

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getCloudConnectionMode();
    let value = (await call).body();
    console.log(`getCloudConnectionMode: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<CloudConnectionMode> call = myService.getCloudConnectionMode();
    Response<CloudConnectionMode> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getCloudConnectionMode");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

CloudConnectionMode

Authorization¶

No authorization required

getCloudGatewayUrl¶

String getCloudGatewayUrl()

Get cloud gateway url

Adresse serveur Web du broker MQTT servant au Cloud. Pour envoyer le datalog par exemple. (Mais PAS pour le Relay MQTT)

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getCloudGatewayUrl();
    let value = (await call).body();
    console.log(`getCloudGatewayUrl: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getCloudGatewayUrl();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getCloudGatewayUrl");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getCloudLogin¶

String getCloudLogin()

Get cloud login id

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getCloudLogin();
    let value = (await call).body();
    console.log(`getCloudLogin: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getCloudLogin();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getCloudLogin");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getCloudMqttPeriod¶

Integer getCloudMqttPeriod()

Get cloud mqtt period

Minimum period between 2 MQTT smartphone sendings in ms : 0 = no

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getCloudMqttPeriod();
    let value = (await call).body();
    console.log(`getCloudMqttPeriod: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<Integer> call = myService.getCloudMqttPeriod();
    Response<Integer> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getCloudMqttPeriod");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

Integer

Authorization¶

No authorization required

getCloudPassword¶

String getCloudPassword()

Get cloud password

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getCloudPassword();
    let value = (await call).body();
    console.log(`getCloudPassword: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getCloudPassword();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getCloudPassword");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getCloudServiceName¶

String getCloudServiceName()

Get the cloud service name

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getCloudServiceName();
    let value = (await call).body();
    console.log(`getCloudServiceName: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getCloudServiceName();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getCloudServiceName");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getCom¶

byte[] getCom(data)

encrypted communication channel

Example¶

Typescript

let myService = new InterfaceService();
let data = BINARY_DATA_HERE; // byte[] | 

try{
    let call = myService.getCom(data);
    let value = (await call).body();
    console.log(`getCom: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


byte[] data = BINARY_DATA_HERE; // byte[] | 
try {
    Call<byte[]> call = myService.getCom(data);
    Response<byte[]> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getCom");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
data	byte[](byte[].md)		[optional]

Return type¶

byte[]

Authorization¶

No authorization required

getConfigFormatFirmwareVersion¶

String getConfigFormatFirmwareVersion()

Get config format firmware version

Version du Firmware qui a écrit la conf. (écrit automatiquement lors de la conf par le Firmware, pas depuis le fichier de conf)

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getConfigFormatFirmwareVersion();
    let value = (await call).body();
    console.log(`getConfigFormatFirmwareVersion: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getConfigFormatFirmwareVersion();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getConfigFormatFirmwareVersion");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getConfigFormatVersion¶

String getConfigFormatVersion()

Get config format version

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getConfigFormatVersion();
    let value = (await call).body();
    console.log(`getConfigFormatVersion: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getConfigFormatVersion();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getConfigFormatVersion");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getConfigVersion¶

String getConfigVersion()

Get config version

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getConfigVersion();
    let value = (await call).body();
    console.log(`getConfigVersion: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getConfigVersion();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getConfigVersion");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getConfigure¶

byte[] getConfigure()

Get configuration of Secure Element

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getConfigure();
    let value = (await call).body();
    console.log(`getConfigure: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<byte[]> call = myService.getConfigure();
    Response<byte[]> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getConfigure");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

byte[]

Authorization¶

No authorization required

getCurrentGroupId¶

Integer getCurrentGroupId()

Get current group id

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getCurrentGroupId();
    let value = (await call).body();
    console.log(`getCurrentGroupId: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<Integer> call = myService.getCurrentGroupId();
    Response<Integer> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getCurrentGroupId");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

Integer

Authorization¶

No authorization required

getCurrentHostProtocol¶

HostProtocol getCurrentHostProtocol()

Get current host protocol

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getCurrentHostProtocol();
    let value = (await call).body();
    console.log(`getCurrentHostProtocol: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<HostProtocol> call = myService.getCurrentHostProtocol();
    Response<HostProtocol> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getCurrentHostProtocol");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

HostProtocol

Authorization¶

No authorization required

getCurrentProfileId¶

Integer getCurrentProfileId()

Get current profile id

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getCurrentProfileId();
    let value = (await call).body();
    console.log(`getCurrentProfileId: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<Integer> call = myService.getCurrentProfileId();
    Response<Integer> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getCurrentProfileId");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

Integer

Authorization¶

No authorization required

getFunctions¶

AvailableFunction getFunctions()

Get functions

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getFunctions();
    let value = (await call).body();
    console.log(`getFunctions: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<AvailableFunction> call = myService.getFunctions();
    Response<AvailableFunction> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getFunctions");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

AvailableFunction

Authorization¶

No authorization required

getHostInactivityPeriod¶

Integer getHostInactivityPeriod()

Get host inactivity period

Host inactivity period before switch to standby mode or shutdown depending on optimisation level (res /1024//14)

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getHostInactivityPeriod();
    let value = (await call).body();
    console.log(`getHostInactivityPeriod: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<Integer> call = myService.getHostInactivityPeriod();
    Response<Integer> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getHostInactivityPeriod");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

Integer

Authorization¶

No authorization required

getLock¶

InterfaceLock getLock()

Get lock infos

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getLock();
    let value = (await call).body();
    console.log(`getLock: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<InterfaceLock> call = myService.getLock();
    Response<InterfaceLock> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getLock");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

InterfaceLock

Authorization¶

No authorization required

getMqttRelayClientId¶

String getMqttRelayClientId()

Get mqtt relay client id

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getMqttRelayClientId();
    let value = (await call).body();
    console.log(`getMqttRelayClientId: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getMqttRelayClientId();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getMqttRelayClientId");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getMqttRelayLogin¶

String getMqttRelayLogin()

Get mqtt relay login

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getMqttRelayLogin();
    let value = (await call).body();
    console.log(`getMqttRelayLogin: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getMqttRelayLogin();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getMqttRelayLogin");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getMqttRelayNetKey¶

String getMqttRelayNetKey()

Get the mqtt net key for the server

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getMqttRelayNetKey();
    let value = (await call).body();
    console.log(`getMqttRelayNetKey: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getMqttRelayNetKey();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getMqttRelayNetKey");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getMqttRelayPassword¶

String getMqttRelayPassword()

Get the mqtt relay password

Mot de passe connexion au broker

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getMqttRelayPassword();
    let value = (await call).body();
    console.log(`getMqttRelayPassword: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getMqttRelayPassword();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getMqttRelayPassword");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getMqttRelayPort¶

String getMqttRelayPort()

Get port of the mqtt broker

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getMqttRelayPort();
    let value = (await call).body();
    console.log(`getMqttRelayPort: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getMqttRelayPort();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getMqttRelayPort");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getMqttRelayUrl¶

String getMqttRelayUrl()

Get mqtt relay url

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getMqttRelayUrl();
    let value = (await call).body();
    console.log(`getMqttRelayUrl: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getMqttRelayUrl();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getMqttRelayUrl");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getNetworkGatewayIp¶

String getNetworkGatewayIp()

Get iotize gateway ip on the network

Adresse IP : ex 192.168.1.1. Seulement pour les IoTize Wi-Fi. (vraiment ?)

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getNetworkGatewayIp();
    let value = (await call).body();
    console.log(`getNetworkGatewayIp: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getNetworkGatewayIp();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getNetworkGatewayIp");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getNetworkInfraIp¶

String getNetworkInfraIp()

Get IoTize device ip on the network

Adresse statique IP : ex 192.168.1.10. DHCP si adresse = 0.0.0.0. Seulement pour les IoTize Wi-Fi.

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getNetworkInfraIp();
    let value = (await call).body();
    console.log(`getNetworkInfraIp: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getNetworkInfraIp();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getNetworkInfraIp");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getNetworkInfraIpMask¶

String getNetworkInfraIpMask()

Get infrastructure ip mask

Mask IP : ex 255.255.255.0. Seulement pour les IoTize Wi-Fi.

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getNetworkInfraIpMask();
    let value = (await call).body();
    console.log(`getNetworkInfraIpMask: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getNetworkInfraIpMask();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getNetworkInfraIpMask");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getNetworkMode¶

NetworkMode getNetworkMode()

Get network mode

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getNetworkMode();
    let value = (await call).body();
    console.log(`getNetworkMode: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<NetworkMode> call = myService.getNetworkMode();
    Response<NetworkMode> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getNetworkMode");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

NetworkMode

Authorization¶

No authorization required

getNfcPairingMode¶

NfcPairingMode getNfcPairingMode()

Check if nfc paring is mandatory

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getNfcPairingMode();
    let value = (await call).body();
    console.log(`getNfcPairingMode: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<NfcPairingMode> call = myService.getNfcPairingMode();
    Response<NfcPairingMode> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getNfcPairingMode");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

NfcPairingMode

Authorization¶

No authorization required

getPowerOptimisationLevel¶

LowPowerOptimisationLevel getPowerOptimisationLevel()

Get power optimization level

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getPowerOptimisationLevel();
    let value = (await call).body();
    console.log(`getPowerOptimisationLevel: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<LowPowerOptimisationLevel> call = myService.getPowerOptimisationLevel();
    Response<LowPowerOptimisationLevel> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getPowerOptimisationLevel");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

LowPowerOptimisationLevel

Authorization¶

No authorization required

getPublicPassword¶

String getPublicPassword()

Get the public password ?

Password utilisé pour l'enregistrement. Également défaut du MQTT Relay PWD

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getPublicPassword();
    let value = (await call).body();
    console.log(`getPublicPassword: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getPublicPassword();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getPublicPassword");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getRand¶

byte[] getRand()

Generate a random number

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getRand();
    let value = (await call).body();
    console.log(`getRand: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<byte[]> call = myService.getRand();
    Response<byte[]> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getRand");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

byte[]

Authorization¶

No authorization required

getWepKey¶

String getWepKey()

Get network key

Clé WAP / WEP pour connection réseau infrastructure & P2P

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getWepKey();
    let value = (await call).body();
    console.log(`getWepKey: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getWepKey();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getWepKey");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getWifiHostname¶

String getWifiHostname()

Get wifi hostname

Hostname par exemple, à lire par NFC pour connection socket à un IoTize Wi-Fi en mode infrastructure avec DHCP

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getWifiHostname();
    let value = (await call).body();
    console.log(`getWifiHostname: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getWifiHostname();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getWifiHostname");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

getWifiSSID¶

String getWifiSSID()

Get wifi ssid

May be null if not connected to any network

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.getWifiSSID();
    let value = (await call).body();
    console.log(`getWifiSSID: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<String> call = myService.getWifiSSID();
    Response<String> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#getWifiSSID");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

String

Authorization¶

No authorization required

keepAlive¶

Integer keepAlive()

Keep alive.

Call this method to ensure communication resources are maintain.

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.keepAlive();
    let value = (await call).body();
    console.log(`keepAlive: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<Integer> call = myService.keepAlive();
    Response<Integer> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#keepAlive");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

Integer

Authorization¶

No authorization required

login(credential)

Login

User login with username and password

Example¶

Typescript

let myService = new InterfaceService();
let credential = new LoginCredential(); // LoginCredential | 

try{
    let call = myService.login(credential);
    let value = (await call).body();
    console.log(`login: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


LoginCredential credential = new LoginCredential(); // LoginCredential | 
try {
    Call<Void> call = myService.login(credential);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#login");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
credential	LoginCredential(LoginCredential.md)		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

logout¶

logout()

Logout

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.logout();
    let value = (await call).body();
    console.log(`logout: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<Void> call = myService.logout();
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#logout");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

null (empty response body)

Authorization¶

No authorization required

multiCommands¶

MultiResponses multiCommands(data)

Execute multiple commands sent in one frame, and return all answers in one

Example¶

Typescript

let myService = new InterfaceService();
let data = null; // MultiCommands | 

try{
    let call = myService.multiCommands(data);
    let value = (await call).body();
    console.log(`multiCommands: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


MultiCommands data = null; // MultiCommands | 
try {
    Call<MultiResponses> call = myService.multiCommands(data);
    Response<MultiResponses> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#multiCommands");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
data	MultiCommands(MultiCommands.md)		[optional]

Return type¶

MultiResponses

Authorization¶

No authorization required

postConfigVersion¶

postConfigVersion()

???

Example¶

Typescript

let myService = new InterfaceService();

try{
    let call = myService.postConfigVersion();
    let value = (await call).body();
    console.log(`postConfigVersion: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


try {
    Call<Void> call = myService.postConfigVersion();
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#postConfigVersion");
    e.printStackTrace();
}

Parameters¶

This endpoint does not need any parameter.

Return type¶

null (empty response body)

Authorization¶

No authorization required

postLoginUid¶

postLoginUid(uid)

Admnistration login

Log in as an administrator thanks to the UID

Example¶

Typescript

let myService = new InterfaceService();
let uid = BINARY_DATA_HERE; // byte[] | 

try{
    let call = myService.postLoginUid(uid);
    let value = (await call).body();
    console.log(`postLoginUid: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


byte[] uid = BINARY_DATA_HERE; // byte[] | 
try {
    Call<Void> call = myService.postLoginUid(uid);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#postLoginUid");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
uid	byte[](byte[].md)

Return type¶

null (empty response body)

Authorization¶

No authorization required

putAppName¶

putAppName(appName)

Set application name

Example¶

Typescript

let myService = new InterfaceService();
let appName = "appName_example"; // String | 

try{
    let call = myService.putAppName(appName);
    let value = (await call).body();
    console.log(`putAppName: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


String appName = "appName_example"; // String | 
try {
    Call<Void> call = myService.putAppName(appName);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putAppName");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
appName	String

Return type¶

null (empty response body)

Authorization¶

No authorization required

putAppPath¶

putAppPath(version)

Set app path

Example¶

Typescript

let myService = new InterfaceService();
let version = "version_example"; // String | 

try{
    let call = myService.putAppPath(version);
    let value = (await call).body();
    console.log(`putAppPath: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


String version = "version_example"; // String | 
try {
    Call<Void> call = myService.putAppPath(version);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putAppPath");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
version	String

Return type¶

null (empty response body)

Authorization¶

No authorization required

putAuthorizedHostProtocol¶

putAuthorizedHostProtocol(mode)

Write authorized host protocols

Example¶

Typescript

let myService = new InterfaceService();
let mode = new ListHostProtocol(); // ListHostProtocol | 

try{
    let call = myService.putAuthorizedHostProtocol(mode);
    let value = (await call).body();
    console.log(`putAuthorizedHostProtocol: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


ListHostProtocol mode = new ListHostProtocol(); // ListHostProtocol | 
try {
    Call<Void> call = myService.putAuthorizedHostProtocol(mode);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putAuthorizedHostProtocol");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
mode	ListHostProtocol(ListHostProtocol.md)		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putCloudConnectionMode¶

putCloudConnectionMode(key)

Write cloud connection mode

Example¶

Typescript

let myService = new InterfaceService();
let key = new CloudConnectionMode(); // CloudConnectionMode | 

try{
    let call = myService.putCloudConnectionMode(key);
    let value = (await call).body();
    console.log(`putCloudConnectionMode: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


CloudConnectionMode key = new CloudConnectionMode(); // CloudConnectionMode | 
try {
    Call<Void> call = myService.putCloudConnectionMode(key);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putCloudConnectionMode");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
key	CloudConnectionMode(CloudConnectionMode.md)		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putCloudGatewayUrl¶

putCloudGatewayUrl(version)

Write cloud gateway url

Example¶

Typescript

let myService = new InterfaceService();
let version = "version_example"; // String | 

try{
    let call = myService.putCloudGatewayUrl(version);
    let value = (await call).body();
    console.log(`putCloudGatewayUrl: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


String version = "version_example"; // String | 
try {
    Call<Void> call = myService.putCloudGatewayUrl(version);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putCloudGatewayUrl");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
version	String

Return type¶

null (empty response body)

Authorization¶

No authorization required

putCloudMqttPeriod¶

putCloudMqttPeriod(key)

Write cloud mqtt period

Example¶

Typescript

let myService = new InterfaceService();
let key = 56; // Integer | 

try{
    let call = myService.putCloudMqttPeriod(key);
    let value = (await call).body();
    console.log(`putCloudMqttPeriod: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


Integer key = 56; // Integer | 
try {
    Call<Void> call = myService.putCloudMqttPeriod(key);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putCloudMqttPeriod");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
key	Integer		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putCloudPassword¶

putCloudPassword(key)

Write cloud password

Example¶

Typescript

let myService = new InterfaceService();
let key = "key_example"; // String | 

try{
    let call = myService.putCloudPassword(key);
    let value = (await call).body();
    console.log(`putCloudPassword: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


String key = "key_example"; // String | 
try {
    Call<Void> call = myService.putCloudPassword(key);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putCloudPassword");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
key	String		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putCloudServiceName¶

putCloudServiceName(name)

Write cloud service name

Example¶

Typescript

let myService = new InterfaceService();
let name = "name_example"; // String | 

try{
    let call = myService.putCloudServiceName(name);
    let value = (await call).body();
    console.log(`putCloudServiceName: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


String name = "name_example"; // String | 
try {
    Call<Void> call = myService.putCloudServiceName(name);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putCloudServiceName");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
name	String		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putConfigFormatVersion¶

putConfigFormatVersion(configFormat)

Set config format version

Example¶

Typescript

let myService = new InterfaceService();
let configFormat = 56; // Integer | 

try{
    let call = myService.putConfigFormatVersion(configFormat);
    let value = (await call).body();
    console.log(`putConfigFormatVersion: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


Integer configFormat = 56; // Integer | 
try {
    Call<Void> call = myService.putConfigFormatVersion(configFormat);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putConfigFormatVersion");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
configFormat	Integer

Return type¶

null (empty response body)

Authorization¶

No authorization required

putConfigVersion¶

putConfigVersion(version)

Set config version

Example¶

Typescript

let myService = new InterfaceService();
let version = 56; // Integer | 

try{
    let call = myService.putConfigVersion(version);
    let value = (await call).body();
    console.log(`putConfigVersion: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


Integer version = 56; // Integer | 
try {
    Call<Void> call = myService.putConfigVersion(version);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putConfigVersion");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
version	Integer

Return type¶

null (empty response body)

Authorization¶

No authorization required

putConfigure¶

putConfigure(conf)

Write secure element configuration

Example¶

Typescript

let myService = new InterfaceService();
let conf = BINARY_DATA_HERE; // byte[] | 

try{
    let call = myService.putConfigure(conf);
    let value = (await call).body();
    console.log(`putConfigure: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


byte[] conf = BINARY_DATA_HERE; // byte[] | 
try {
    Call<Void> call = myService.putConfigure(conf);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putConfigure");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
conf	byte[](byte[].md)		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putCurrentHostProtocol¶

putCurrentHostProtocol(hostProtocol)

Write current host protocol

Example¶

Typescript

let myService = new InterfaceService();
let hostProtocol = new HostProtocol(); // HostProtocol | 

try{
    let call = myService.putCurrentHostProtocol(hostProtocol);
    let value = (await call).body();
    console.log(`putCurrentHostProtocol: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


HostProtocol hostProtocol = new HostProtocol(); // HostProtocol | 
try {
    Call<Void> call = myService.putCurrentHostProtocol(hostProtocol);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putCurrentHostProtocol");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
hostProtocol	HostProtocol(HostProtocol.md)

Return type¶

null (empty response body)

Authorization¶

No authorization required

putHostInactivityPeriod¶

putHostInactivityPeriod(key)

Write host inactivity period

Example¶

Typescript

let myService = new InterfaceService();
let key = 56; // Integer | 

try{
    let call = myService.putHostInactivityPeriod(key);
    let value = (await call).body();
    console.log(`putHostInactivityPeriod: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


Integer key = 56; // Integer | 
try {
    Call<Void> call = myService.putHostInactivityPeriod(key);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putHostInactivityPeriod");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
key	Integer		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putLock¶

putLock(infos)

Set lock infos

Example¶

Typescript

let myService = new InterfaceService();
let infos = new InterfaceLock(); // InterfaceLock | 

try{
    let call = myService.putLock(infos);
    let value = (await call).body();
    console.log(`putLock: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


InterfaceLock infos = new InterfaceLock(); // InterfaceLock | 
try {
    Call<Void> call = myService.putLock(infos);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putLock");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
infos	InterfaceLock(InterfaceLock.md)

Return type¶

null (empty response body)

Authorization¶

No authorization required

putMqttRelayNetKey¶

putMqttRelayNetKey(netkey)

Write mqtt net key

Example¶

Typescript

let myService = new InterfaceService();
let netkey = "netkey_example"; // String | 

try{
    let call = myService.putMqttRelayNetKey(netkey);
    let value = (await call).body();
    console.log(`putMqttRelayNetKey: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


String netkey = "netkey_example"; // String | 
try {
    Call<Void> call = myService.putMqttRelayNetKey(netkey);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putMqttRelayNetKey");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
netkey	String		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putMqttRelayPassword¶

putMqttRelayPassword(url)

Write mqtt relay password

Example¶

Typescript

let myService = new InterfaceService();
let url = "url_example"; // String | 

try{
    let call = myService.putMqttRelayPassword(url);
    let value = (await call).body();
    console.log(`putMqttRelayPassword: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


String url = "url_example"; // String | 
try {
    Call<Void> call = myService.putMqttRelayPassword(url);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putMqttRelayPassword");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
url	String		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putMqttRelayPort¶

putMqttRelayPort(url)

Write service name of the mqtt broker

Example¶

Typescript

let myService = new InterfaceService();
let url = "url_example"; // String | 

try{
    let call = myService.putMqttRelayPort(url);
    let value = (await call).body();
    console.log(`putMqttRelayPort: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


String url = "url_example"; // String | 
try {
    Call<Void> call = myService.putMqttRelayPort(url);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putMqttRelayPort");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
url	String		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putMqttRelayUrl¶

putMqttRelayUrl(url)

Write mqtt relay url

Example¶

Typescript

let myService = new InterfaceService();
let url = "url_example"; // String | 

try{
    let call = myService.putMqttRelayUrl(url);
    let value = (await call).body();
    console.log(`putMqttRelayUrl: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


String url = "url_example"; // String | 
try {
    Call<Void> call = myService.putMqttRelayUrl(url);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putMqttRelayUrl");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
url	String		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putNetworkGatewayIp¶

putNetworkGatewayIp(key)

Write iotize gateway ip

Example¶

Typescript

let myService = new InterfaceService();
let key = "key_example"; // String | 

try{
    let call = myService.putNetworkGatewayIp(key);
    let value = (await call).body();
    console.log(`putNetworkGatewayIp: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


String key = "key_example"; // String | 
try {
    Call<Void> call = myService.putNetworkGatewayIp(key);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putNetworkGatewayIp");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
key	String		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putNetworkInfraIp¶

putNetworkInfraIp(key)

Write infrastructure ip

Example¶

Typescript

let myService = new InterfaceService();
let key = "key_example"; // String | 

try{
    let call = myService.putNetworkInfraIp(key);
    let value = (await call).body();
    console.log(`putNetworkInfraIp: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


String key = "key_example"; // String | 
try {
    Call<Void> call = myService.putNetworkInfraIp(key);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putNetworkInfraIp");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
key	String		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putNetworkInfraIpMask¶

putNetworkInfraIpMask(key)

Write infrastructure ip mask

Example¶

Typescript

let myService = new InterfaceService();
let key = "key_example"; // String | 

try{
    let call = myService.putNetworkInfraIpMask(key);
    let value = (await call).body();
    console.log(`putNetworkInfraIpMask: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


String key = "key_example"; // String | 
try {
    Call<Void> call = myService.putNetworkInfraIpMask(key);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putNetworkInfraIpMask");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
key	String		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putNetworkMode¶

putNetworkMode(mode)

Write network mode

Example¶

Typescript

let myService = new InterfaceService();
let mode = new NetworkMode(); // NetworkMode | 

try{
    let call = myService.putNetworkMode(mode);
    let value = (await call).body();
    console.log(`putNetworkMode: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


NetworkMode mode = new NetworkMode(); // NetworkMode | 
try {
    Call<Void> call = myService.putNetworkMode(mode);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putNetworkMode");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
mode	NetworkMode(NetworkMode.md)		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putNfcPairingMode¶

putNfcPairingMode(mode)

Change wether if nfc pairing is mandatory

Example¶

Typescript

let myService = new InterfaceService();
let mode = new NfcPairingMode(); // NfcPairingMode | 

try{
    let call = myService.putNfcPairingMode(mode);
    let value = (await call).body();
    console.log(`putNfcPairingMode: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


NfcPairingMode mode = new NfcPairingMode(); // NfcPairingMode | 
try {
    Call<Void> call = myService.putNfcPairingMode(mode);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putNfcPairingMode");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
mode	NfcPairingMode(NfcPairingMode.md)		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putPowerOptimisationLevel¶

putPowerOptimisationLevel(mode)

Write power optimization level

Example¶

Typescript

let myService = new InterfaceService();
let mode = new LowPowerOptimisationLevel(); // LowPowerOptimisationLevel | 

try{
    let call = myService.putPowerOptimisationLevel(mode);
    let value = (await call).body();
    console.log(`putPowerOptimisationLevel: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


LowPowerOptimisationLevel mode = new LowPowerOptimisationLevel(); // LowPowerOptimisationLevel | 
try {
    Call<Void> call = myService.putPowerOptimisationLevel(mode);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putPowerOptimisationLevel");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
mode	LowPowerOptimisationLevel(LowPowerOptimisationLevel.md)		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putWepKey¶

putWepKey(key)

Write network key

Example¶

Typescript

let myService = new InterfaceService();
let key = "key_example"; // String | 

try{
    let call = myService.putWepKey(key);
    let value = (await call).body();
    console.log(`putWepKey: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


String key = "key_example"; // String | 
try {
    Call<Void> call = myService.putWepKey(key);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putWepKey");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
key	String		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required

putWifiSsid¶

putWifiSsid(key)

Write wifi ssid

Example¶

Typescript

let myService = new InterfaceService();
let key = "key_example"; // String | 

try{
    let call = myService.putWifiSsid(key);
    let value = (await call).body();
    console.log(`putWifiSsid: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

Java

import com.iotize.android.device.device.api.service.definition.InterfaceService;

ServiceFactory serviceFactory = ...;
InterfaceService myService = serviceFactory.create(InterfaceService.class);


String key = "key_example"; // String | 
try {
    Call<Void> call = myService.putWifiSsid(key);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling InterfaceService#putWifiSsid");
    e.printStackTrace();
}

Parameters¶

Name	Type	Description	Notes
key	String		[optional]

Return type¶

null (empty response body)

Authorization¶

No authorization required