• Home
• com.arm.mbed.cloud.sdk
• mbed-cloud-sdk
• 2.2.1
• source code
• Connect.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.arm.mbed.cloud.sdk.Connect Maven / Gradle / Ivy

package com.arm.mbed.cloud.sdk;

import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;

import io.reactivex.BackpressureStrategy;
import io.reactivex.Flowable;
import io.reactivex.functions.Function;

import com.arm.mbed.cloud.sdk.annotations.API;
import com.arm.mbed.cloud.sdk.annotations.Daemon;
import com.arm.mbed.cloud.sdk.annotations.DefaultValue;
import com.arm.mbed.cloud.sdk.annotations.Module;
import com.arm.mbed.cloud.sdk.annotations.NonNull;
import com.arm.mbed.cloud.sdk.annotations.Nullable;
import com.arm.mbed.cloud.sdk.annotations.Preamble;
import com.arm.mbed.cloud.sdk.common.AbstractApi;
import com.arm.mbed.cloud.sdk.common.ApiUtils;
import com.arm.mbed.cloud.sdk.common.Callback;
import com.arm.mbed.cloud.sdk.common.CloudCaller;
import com.arm.mbed.cloud.sdk.common.CloudRequest.CloudCall;
import com.arm.mbed.cloud.sdk.common.ConnectionOptions;
import com.arm.mbed.cloud.sdk.common.GenericAdapter;
import com.arm.mbed.cloud.sdk.common.GenericAdapter.Mapper;
import com.arm.mbed.cloud.sdk.common.JsonSerialiser;
import com.arm.mbed.cloud.sdk.common.MbedCloudException;
import com.arm.mbed.cloud.sdk.common.PageRequester;
import com.arm.mbed.cloud.sdk.common.SynchronousMethod;
import com.arm.mbed.cloud.sdk.common.SynchronousMethod.AsynchronousMethod;
import com.arm.mbed.cloud.sdk.common.TimePeriod;
import com.arm.mbed.cloud.sdk.common.TranslationUtils;
import com.arm.mbed.cloud.sdk.common.UuidGenerator;
import com.arm.mbed.cloud.sdk.common.listing.ListOptions;
import com.arm.mbed.cloud.sdk.common.listing.ListResponse;
import com.arm.mbed.cloud.sdk.common.listing.Paginator;
import com.arm.mbed.cloud.sdk.common.listing.filtering.Filter;
import com.arm.mbed.cloud.sdk.common.listing.filtering.FilterOperator;
import com.arm.mbed.cloud.sdk.connect.adapters.MetricAdapter;
import com.arm.mbed.cloud.sdk.connect.adapters.PresubscriptionAdapter;
import com.arm.mbed.cloud.sdk.connect.adapters.ResourceAdapter;
import com.arm.mbed.cloud.sdk.connect.adapters.WebhookAdapter;
import com.arm.mbed.cloud.sdk.connect.model.AbstractMetricsListOptions;
import com.arm.mbed.cloud.sdk.connect.model.EndPoints;
import com.arm.mbed.cloud.sdk.connect.model.Metric;
import com.arm.mbed.cloud.sdk.connect.model.MetricsPeriodListOptions;
import com.arm.mbed.cloud.sdk.connect.model.MetricsStartEndListOptions;
import com.arm.mbed.cloud.sdk.connect.model.Presubscription;
import com.arm.mbed.cloud.sdk.connect.model.Resource;
import com.arm.mbed.cloud.sdk.connect.model.Subscription;
import com.arm.mbed.cloud.sdk.connect.model.Webhook;
import com.arm.mbed.cloud.sdk.connect.subscription.NotificationHandlersStore;
import com.arm.mbed.cloud.sdk.connect.subscription.ResourceAction;
import com.arm.mbed.cloud.sdk.connect.subscription.ResourceActionParameters;
import com.arm.mbed.cloud.sdk.connect.subscription.ResourceValueType;
import com.arm.mbed.cloud.sdk.connect.subscription.adapters.ResourceActionAdapter;
import com.arm.mbed.cloud.sdk.devicedirectory.model.Device;
import com.arm.mbed.cloud.sdk.devicedirectory.model.DeviceListOptions;
import com.arm.mbed.cloud.sdk.devicedirectory.model.DeviceState;
import com.arm.mbed.cloud.sdk.internal.mds.model.DeviceRequest;
import com.arm.mbed.cloud.sdk.internal.mds.model.NotificationMessage;
import com.arm.mbed.cloud.sdk.internal.mds.model.PresubscriptionArray;
import com.arm.mbed.cloud.sdk.internal.statistics.model.SuccessfulResponse;
import com.arm.mbed.cloud.sdk.subscribe.CloudSubscriptionManager;
import com.arm.mbed.cloud.sdk.subscribe.NotificationMessageValue;
import com.arm.mbed.cloud.sdk.subscribe.Observer;
import com.arm.mbed.cloud.sdk.subscribe.model.AsynchronousResponseNotification;
import com.arm.mbed.cloud.sdk.subscribe.model.AsynchronousResponseObserver;

import retrofit2.Call;

@Preamble(description = "Specifies Connect API")
@Module
/**
 * API exposing functionality for doing a range of device related actions:
 * 

 * 1) Listing connected devices
 * 

 * 2) Exploring and managing resources and resource values on said devices
 * 

 * 3) Setup resource subscriptions and webhooks for resource monitoring
 */
public class Connect extends AbstractApi {
    private static final String BUFFER = "BUFFER";
    private static final String TAG_VALUE_TYPE = "valueType";
    private static final String TAG_PRESUBSCRIPTION = "presubscription";
    private static final String TAG_ON_NOTIFICATION_CALLBACK = "on notification callback";
    private static final String TAG_WEBHOOK = "webhook";
    private static final Filter CONNECTED_DEVICES_FILTER = new Filter("state", FilterOperator.EQUAL,
                                                                      DeviceState.getIsConnectedState().getString());
    private static final String TAG_RESOURCE = "resource";
    private static final String FALSE = "false";
    private static final String TAG_RESOURCE_PATH = "resource path";
    private static final String TAG_METRIC_OPTIONS = "Metric options";
    private static final String TAG_DEVICE_ID = "Device Id";
    private static final String TAG_DEVICE = "Device";
    private final EndPoints endpoint;
    private final DeviceDirectory deviceDirectory;
    private final NotificationHandlersStore handlersStore;

    /**
     * Connect module constructor.
     * 

     * This module spawns threads for retrieving notifications when daemon is started @see
     * {@link #startNotifications()}.
     * 

     * By default, the executor services in charge are defined and managed internally. It is however possible to specify
     * your own executors @see #Connect(ConnectionOptions, ExecutorService, ExecutorService).
     *
     * @param options
     *            connection options @see {@link ConnectionOptions}.
     */
    public Connect(@NonNull ConnectionOptions options) {
        this(options, null, null);
    }

    /**
     * Connect module constructor.
     * 

     * As opposed to {@link #Connect(ConnectionOptions)} which uses default thread pools for retrieving notifications,
     * this constructor lets you the possibility to specify the executor services to use.
     *
     * @param options
     *            connection options @see {@link ConnectionOptions}.
     *
     * @param notificationHandlingThreadPool
     *            Threads in charge of retrieving notifications for a specific resource. If null, a default thread pool
     *            will be created internally.
     * @param notificationPullingThreadPool
     *            Threads in charge of listening to notifications. The pool can either be a scheduled thread pool or a
     *            fixed thread pool depending on what best suits your system. If null, an internal timer will be created
     *            internally.
     */
    public Connect(@NonNull ConnectionOptions options, @Nullable ExecutorService notificationHandlingThreadPool,
                   @Nullable ExecutorService notificationPullingThreadPool) {
        super(options);
        endpoint = new EndPoints(options);
        deviceDirectory = new DeviceDirectory(options);
        this.handlersStore = new NotificationHandlersStore(this,
                                                           (notificationPullingThreadPool == null) ? createDefaultDaemonThreadPool()
                                                                                                   : notificationPullingThreadPool,
                                                           notificationHandlingThreadPool, endpoint);

    }

    /**
     * Creates a default thread pool in case none was specified.
     *
     * @return thread pool
     */
    private static ScheduledExecutorService createDefaultDaemonThreadPool() {
        return Executors.newScheduledThreadPool(1, new ThreadFactory() {

            @Override
            public Thread newThread(Runnable runable) {
                final Thread thread = new Thread(runable);
                thread.setDaemon(true);
                return thread;
            }
        });
    }

    /**
     * Starts notification pull.
     * 

     * If an external callback is not set up (using `update_webhook`) then calling this function is mandatory to get or
     * set resources. Unless {@link ConnectionOptions#setAutostartDaemon(boolean)} has been set to true or left as
     * default.
     * 

     * Example:
     *
     * 
     * {@code
     * connectApi.startNotifications();
     * }
     * 
     *
     * @throws MbedCloudException
     *             if a problem occurred during the process.
     */
    @API
    @Daemon(task = "Notification pull", start = true)
    public void startNotifications() throws MbedCloudException {
        logger.logInfo(getModuleName() + ": startNotifications()");
        Webhook webhook = null;
        try {
            if (isForceClear()) {
                deleteWebhook();
            }
        } catch (MbedCloudException exception) {
            // Nothing to do
        }
        try {
            webhook = getWebhook();
        } catch (MbedCloudException exception) {
            // Nothing to do
        }
        if (webhook != null) {
            logger.throwSdkException("A webhook is currently set up [" + webhook
                                     + "]. Notification pull cannot be used at the same time. Please remove the webhook if you want to use this mechanism instead.");
        }
        handlersStore.startNotificationPull();
    }

    private void autostartDaemonIfNeeded() throws MbedCloudException {
        if (!handlersStore.isPullingActive() && endpoint.isAutostartDaemon()) {
            startNotifications();
        }
    }

    /**
     * Stops notification pull for notifications.
     * 

     * Example:
     *
     * 
     * {@code
     * connectApi.stopNotifications();
     * }
     * 
     *
     * @throws MbedCloudException
     *             if a problem occurred during the process.
     */
    @API
    @Daemon(task = "Notification pull", stop = true)
    public void stopNotifications() throws MbedCloudException {
        logger.logInfo(getModuleName() + ": stopNotifications()");
        handlersStore.stopNotificationPull();
        CloudCaller.call(this, "stopNotification()", null, new CloudCall() {

            @Override
            public Call call() {
                return endpoint.getNotifications().deleteLongPollChannel();
            }
        });
    }

    /**
     * Shuts down all daemon services.
     * 

     * Example:
     *
     * 
     * {@code
     * connectApi.shutdownConnectService();
     * }
     * 
     */
    @API
    @Daemon(task = "Notification pull", shutdown = true)
    public void shutdownConnectService() {
        logger.logInfo(getModuleName() + ": shutdownConnectService()");
        handlersStore.shutdown();
    }

    /**
     * Lists connected devices (One page).
     * 

     * Example:
     *
     * 
     * {@code
     * try {
     *     DeviceListOptions options = new DeviceListOptions();
     *
     *     Calendar date = GregorianCalendar(2017,10,30,10,20,56);
     *     options.addCreatedAtFilter(date.getTime(), FilterOperator.GREATER_THAN);
     *
     *     options.addDeviceTypeFilter("default", FilterOperator.EQUAL);
     *
     *     ListResponse devices = connectApi.listConnectedDevices(options);
     *     for (Device device : devices) {
     *         System.out.println("Device ID: " + device.getId());
     *     }
     * } catch (MbedCloudException e) {
     *     e.printStackTrace();
     * }
     * }
     * 
     *
     * @param options
     *            filter options
     * @return the list of connected devices (One page).
     * @throws MbedCloudException
     *             if a problem occurred during request processing.
     */
    @API
    public @Nullable ListResponse listConnectedDevices(DeviceListOptions options) throws MbedCloudException {
        return deviceDirectory.listDevicesWithExtraFilters("listConnectedDevices()", options, CONNECTED_DEVICES_FILTER);
    }

    /**
     * Gets an iterator over all connected devices according to filter options.
     * 

     * Example:
     *
     * 
     * {@code
     * try {
     *     DeviceListOptions options = new DeviceListOptions();
     *
     *     Calendar date = GregorianCalendar(2017,10,30,10,20,56);
     *     options.addCreatedAtFilter(date.getTime(), FilterOperator.GREATER_THAN);
     *
     *     options.addDeviceTypeFilter("default", FilterOperator.EQUAL);
     *
     *     Paginator devices = connectApi.listAllDevices(options);
     *     while (devices.hasNext()) {
     *         Device device = devices.next();
     *         System.out.println("Device ID: " + device.getId());
     *     }
     * } catch (MbedCloudException e) {
     *     e.printStackTrace();
     * }
     * }
     * 
     *
     * @param options
     *            filter options.
     * @return paginator @see {@link Paginator} for the list of devices corresponding to filter options.
     * @throws MbedCloudException
     *             if a problem occurred during request processing.
     */
    @API
    public @Nullable Paginator
           listAllConnectedDevices(@Nullable DeviceListOptions options) throws MbedCloudException {
        return new Paginator<>((options == null) ? new DeviceListOptions() : options, new PageRequester() {

            @Override
            public ListResponse requestNewPage(ListOptions opt) throws MbedCloudException {
                return listConnectedDevices((DeviceListOptions) opt);
            }
        });
    }

    /**
     * Lists device's resources.
     * 

     * Example:
     *
     * 
     * {@code
     * try {
     *     Device device = new Device();
     *     device.setId("015f4ac587f500000000000100100249");
     *
     *     List resources = connectApi.listResources(device);
     *     for (Resource resource : resources) {
     *         System.out.println("Resource path: " + resource.getPath());
     *     }
     * } catch (MbedCloudException e) {
     *     e.printStackTrace();
     * }
     * }
     * 
     *
     * @param device
     *            Device.
     * @return list of resources present on a device.
     * @throws MbedCloudException
     *             if a problem occurred during request processing.
     */
    @API
    public @Nullable List listResources(@NonNull Device device) throws MbedCloudException {
        checkNotNull(device, TAG_DEVICE);
        checkNotNull(device.getId(), TAG_DEVICE_ID);
        final String finalDeviceId = device.getId();

        return CloudCaller.call(this, "listResources()", ResourceAdapter.getListMapper(finalDeviceId),
                                new CloudCall>() {

                                    @Override
                                    public Call> call() {
                                        return endpoint.getEndpoints().getEndpointResources(finalDeviceId);
                                    }
                                });
    }

    /**
     * Lists device's observable resources.
     *
     * @see Resource#isObservable()
     *      

     *      Example:
     *
     *      
     * {@code
     * try {
     *     Device device = new Device();
     *     device.setId("015f4ac587f500000000000100100249");
     *
     *     List resources = connectApi.listObservableResources(device);
     *     for (Resource resource : resources) {
     *         System.out.println("Resource path: " + resource.getPath());
     *     }
     * } catch (MbedCloudException e) {
     *     e.printStackTrace();
     * }
     * }
     *      
     *
     * @param device
     *            Device.
     * @return list of observable resources present on a device.
     * @throws MbedCloudException
     *             if a problem occurred during request processing.
     */
    @API
    public @Nullable List listObservableResources(@NonNull Device device) throws MbedCloudException {
        final List resources = listResources(device);
        if (resources == null || resources.isEmpty()) {
            return null;
        }
        final List observableResources = new LinkedList<>();
        for (final Resource resource : resources) {
            if (resource.isObservable()) {
                observableResources.add(resource);
            }
        }
        return observableResources.isEmpty() ? null : observableResources;
    }

    /**
     * Gets device's resource.
     * 

     * Example:
     *
     * 
     * {@code
     * try {
     *     Device device = new Device();
     *     device.setId("015f4ac587f500000000000100100249");
     *
     *     String resourcePath = "/3201/0/5853";
     *
     *     Resource resource = connectApi.getResource(device, resourcePath);
     *     System.out.println("Confirmed resource path: " + resource.getPath());
     *     assert resourcePath == resource.getPath();
     * } catch (MbedCloudException e) {
     *     e.printStackTrace();
     * }
     * }
     * 
     *
     * @param device
     *            Device.
     * @param resourcePath
     *            Path of the resource to get
     * @return resource present on the device.
     * @throws MbedCloudException
     *             if a problem occurred during request processing.
     */
    @API
    public @Nullable Resource getResource(@NonNull Device device,
                                          @NonNull String resourcePath) throws MbedCloudException {
        checkNotNull(device, TAG_DEVICE);
        checkNotNull(device.getId(), TAG_DEVICE_ID);
        checkNotNull(resourcePath, TAG_RESOURCE_PATH);
        final List resources = listResources(device);
        if (resources == null || resources.isEmpty()) {
            return null;
        }
        for (final Resource resource : resources) {
            if (ApiUtils.comparePaths(resourcePath, resource.getPath())) {
                return resource;
            }
        }
        return null;
    }

    /**
     * Lists a device's subscriptions.
     * 

     * Example:
     *
     * 
     * {@code
     * try {
     *     Device device = new Device();
     *     device.setId("015f4ac587f500000000000100100249");
     *
     *     List subscriptions = connectApi.listDeviceSubscriptions(device);
     *     for (String subscription : subscriptions) {
     *         System.out.println("Device subscription: " + subscription);
     *     }
     * } catch (MbedCloudException e) {
     *     e.printStackTrace();
     * }
     * }
     * 
     *
     * @param device
     *            Device.
     * @return list of subscriptions
     * @throws MbedCloudException
     *             if a problem occurred during request processing.
     */
    @API
    public @Nullable List listDeviceSubscriptions(@NonNull Device device) throws MbedCloudException {
        checkNotNull(device, TAG_DEVICE);
        checkNotNull(device.getId(), TAG_DEVICE_ID);
        final String finalDeviceId = device.getId();

        return CloudCaller.call(this, "listDeviceSubscriptions()", PresubscriptionAdapter.getResourcePathListMapper(),
                                new CloudCall() {

                                    @Override
                                    public Call call() {
                                        return endpoint.getSubscriptions().getEndpointSubscriptions(finalDeviceId);
                                    }
                                });
    }

    /**
     * Gets the subscribe module.
     *
     * @return subscribe module.
     * @throws MbedCloudException
     *             if a problem occurred during request processing.
     */
    @API
    public CloudSubscriptionManager subscribe() throws MbedCloudException {
        autostartDaemonIfNeeded();
        return this.handlersStore.getSubscriptionManager();
    }

    /**
     * Lists metrics.
     * 

     * Example:
     *
     * 
     * {@code
     * try {
     *     Calendar startDate = GregorianCalendar(2017,10,30,10,20,56);
     *     Calendar endDate = GregorianCalendar(2017,11,31,10,20,56);
     *
     *     MetricsStartEndListOptions listOptions = new MetricsStartEndListOptions();
     *     listOptions.setStart(startDate.getTime());
     *     listOptions.setEnd(endDate.getTime());
     *     listOptions.setInterval(new TimePeriod(360)); //Once an hour
     *
     *     ListResponse metrics = connectApi.listMetrics(listOptions);
     *     //Iterates over a page
     *     for (Metric metric : metrics.getData()) {
     *         System.out.println("Time: " + dateFormat.format(metric.getTimestamp()));
     *         System.out.println("Successful bootstraps: " + metric.getSuccessfulBootstraps());
     *         System.out.println("Successful api calls: " + metric.getSuccessfulApiCalls());
     *         System.out.println("");
     *     }
     * } catch (MbedCloudException e) {
     *     e.printStackTrace();
     * }
     * }
     * 
     *
     * @param options
     *            metrics options.
     * @param 
     *            Type of metrics list options
     * @return list of metrics for the corresponding options.
     * @throws MbedCloudException
     *             if a problem occurred during request processing.
     */
    @API
    public @Nullable  ListResponse
           listMetrics(@NonNull T options) throws MbedCloudException {
        checkNotNull(options, TAG_METRIC_OPTIONS);
        final T finalOptions = options;
        final Date finalStart = options instanceof MetricsStartEndListOptions ? ((MetricsStartEndListOptions) options).getStart()
                                                                              : null;
        final Date finalEnd = options instanceof MetricsStartEndListOptions ? ((MetricsStartEndListOptions) options).getEnd()
                                                                            : null;
        final String finalPeriod = options instanceof MetricsPeriodListOptions ? ((MetricsPeriodListOptions) options).getPeriod()
                                                                                                                     .toString()
                                                                               : null;

        return CloudCaller.call(this, "listMetrics()", MetricAdapter.getListMapper(),
                                new CloudCall() {

                                    @Override
                                    public Call call() {
                                        return endpoint.getStatistic()
                                                       .getMetrics(MetricAdapter.mapIncludes(finalOptions.getInclude()),
                                                                   finalOptions.getInterval().toString(),
                                                                   TranslationUtils.toLocalDate(finalStart),
                                                                   TranslationUtils.toLocalDate(finalEnd), finalPeriod,
                                                                   finalOptions.getPageSize(), finalOptions.getAfter(),
                                                                   finalOptions.getOrder().toString());
                                    }
                                });

    }

    /**
     * Gets an iterator over all metrics according to filter options.
     * 

     * Example:
     *
     * 
     * {@code
     * try {
     *     Calendar startDate = GregorianCalendar(2017,10,30,10,20,56);
     *     Calendar endDate = GregorianCalendar(2017,11,31,10,20,56);
     *
     *     MetricsStartEndListOptions listOptions = new MetricsStartEndListOptions();
     *     listOptions.setStart(startDate.getTime());
     *     listOptions.setEnd(endDate.getTime());
     *     listOptions.setInterval(new TimePeriod(360)); //Once an hour
     *
     *     Paginator metrics = connectApi.listAllMetrics(listOptions);
     *     for (Metric metric : metrics) {
     *         System.out.println("Time: " + dateFormat.format(metric.getTimestamp()));
     *         System.out.println("Successful bootstraps: " + metric.getSuccessfulBootstraps());
     *         System.out.println("Successful api calls: " + metric.getSuccessfulApiCalls());
     *         System.out.println("");
     *     }
     * } catch (MbedCloudException e) {
     *     e.printStackTrace();
     * }
     * }
     * }
     * 
     *
     * @param options
     *            filter options.
     * @param 
     *            Type of metrics list options
     * @return paginator @see {@link Paginator} for the list of metrics corresponding to filter options.
     * @throws MbedCloudException
     *             if a problem occurred during request processing.
     */
    @API
    public @Nullable  Paginator
           listAllMetrics(@NonNull T options) throws MbedCloudException {
        checkNotNull(options, TAG_METRIC_OPTIONS);
        return new Paginator<>(options, new PageRequester() {

            @SuppressWarnings("unchecked")
            @Override
            public ListResponse requestNewPage(ListOptions opt) throws MbedCloudException {
                return listMetrics((T) opt);
            }
        });
    }

    /**
     * Creates a observer to obtain resource current value.
     * 

     * See {@link Observer}
     * 
     * @param resource
     *            resource of interest.
     * @param strategy
     *            backpressure strategy.
     * @return corresponding observer.
     * @throws MbedCloudException
     *             if a problem occurred during request processing.
     */
    public @Nullable AsynchronousResponseObserver
           createCurrentResourceValueObserver(@NonNull Resource resource,
                                              @Nullable @DefaultValue(BUFFER) BackpressureStrategy strategy) throws MbedCloudException {

        return createResourceActionObserver(createResourceAction("getResourceValueAsync()",
                                                                 ResourceActionAdapter.getGetResourceValueMapper()),
                                            resource, strategy, null, null, true);
    }

    /**
     * Creates a observer to set a resource value.
     * 

     * See {@link Observer}
     * 
     * @param resource
     *            resource of interest.
     * @param strategy
     *            backpressure strategy.
     * @param value
     *            value to set.
     * @param valueType
     *            type of the value to set.
     * @return corresponding observer.
     * @throws MbedCloudException
     *             if a problem occurred during request processing.
     */
    public @Nullable AsynchronousResponseObserver
           createSetResourceValueObserver(@NonNull Resource resource,
                                          @Nullable @DefaultValue(BUFFER) BackpressureStrategy strategy,
                                          @Nullable Object value,
                                          @NonNull ResourceValueType valueType) throws MbedCloudException {

        return createResourceActionObserver(createResourceAction("setResourceValueAsync()",
                                                                 ResourceActionAdapter.getSetResourceValueMapper()),
                                            resource, strategy, value, valueType, true);
    }

    /**
     * Creates a observer to execute a resource.
     * 

     * See {@link Observer}
     * 
     * @param resource
     *            resource of interest.
     * @param strategy
     *            backpressure strategy.
     * @param value
     *            value to set.
     * @param valueType
     *            type of the value to set.
     * @return corresponding observer.
     * @throws MbedCloudException
     *             if a problem occurred during request processing.
     */
    public @Nullable AsynchronousResponseObserver
           createExecuteResourceValueObserver(@NonNull Resource resource,
                                              @Nullable @DefaultValue(BUFFER) BackpressureStrategy strategy,
                                              @Nullable Object value,
                                              @NonNull ResourceValueType valueType) throws MbedCloudException {
        return createResourceActionObserver(createResourceAction("executeResourceAsync()",
                                                                 ResourceActionAdapter.getExecuteResourceValueMapper()),
                                            resource, strategy, value, valueType, false);
    }

    protected ResourceAction createResourceAction(String functionName,
                                                  Mapper requestMapper) {
        final AbstractApi module = this;
        final String function = functionName;
        final Mapper finalMapper = requestMapper;
        return new ResourceAction() {

            @Override
            public void execute(ResourceActionParameters arg) throws MbedCloudException {
                final ResourceActionParameters finalArgs = arg;
                CloudCaller.call(module, function, null, new CloudCall() {

                    @Override
                    public Call call() {
                        return endpoint.getAsync().createAsyncRequest(finalArgs.getResource().getDeviceId(),
                                                                      finalArgs.getAsyncId(),
                                                                      finalMapper.map(finalArgs));
                    }
                });

            }

        };
    }

    protected AsynchronousResponseObserver
              createResourceActionObserver(ResourceAction action, Resource resource, BackpressureStrategy strategy,
                                           Object value, ResourceValueType type,
                                           boolean notifyOtherObservers) throws MbedCloudException {
        checkNotNull(resource, TAG_RESOURCE);
        checkModelValidity(resource, TAG_RESOURCE);
        autostartDaemonIfNeeded();
        final ResourceActionParameters parameters = new ResourceActionParameters(UuidGenerator.generate(), resource,
                                                                                 value, type);
        final BackpressureStrategy finalStrategy = (strategy == null) ? BackpressureStrategy.BUFFER : strategy;
        final AsynchronousResponseObserver observer = handlersStore.createAsyncResponseObserver(parameters.getResource(),
                                                                                                parameters.getAsyncId(),
                                                                                                finalStrategy,
                                                                                                notifyOtherObservers);

        try {
            action.execute(parameters);
        } catch (MbedCloudException exception) {
            observer.unsubscribe();
            throw exception;
        }
        return observer;
    }

    protected Future