WorldAnalysisREST.cs

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using ETSI.ARF.OpenAPI.WorldAnalysis;
using ETSI.ARF.WorldAnalysis;
using static WorldAnalysisInterface;
using ETSI.ARF.WorldAnalysis.REST;

using UnityEngine.Events;

//Implementation of the WorldAnalysis interface
public partial class WorldAnalysisREST : MonoBehaviour, WorldAnalysisInterface
{
    [Serializable]
    public class StringEvent : UnityEvent<string> { }

    //
    // Inspector variables
    //

    // Name to register the client to the World Analysis
    public string modulename = "UnityValidationApp";


    /// <summary>
    /// WorldSAnalysisServer
    /// </summary>
    public WorldAnalysisServer waServer;
    public string token = "ETSI-ARF-STF";
    public string sessionID = "ARF-STF669";

    [Space(8)]
    public bool isDebug = false;

    //
    // Private members
    //
    private WorldAnalysisClient apiClient;          // For sync calls
    private WorldAnalysisClient apiClientAsync;     // For async calls

    //
    // Management of subscriptions
    //
    /// <summary>
    /// Dictionnary of susbscription informations for poses, for each item, stored using the UUID of the item (anchor/trackable)
    /// </summary>
    private Dictionary<Guid, SubscriptionInfo> subscriptionsPoses;

    public struct SubscriptionInfo
    {
        public ETSI.ARF.OpenAPI.WorldAnalysis.Pose pose;

        public Guid uuid;           // id of subscription (id is defined by the WA server)
        public Guid uuidTarget;     // id trackable or anchor
        public float timeValidity;  //The duration of the validity of the subscription
        public PoseCallback callback;
    }

    #region Unity_Methods

    /// <summary>
    /// Unity Awake Method
    /// </summary>
    protected void Awake()
    {
        Instance = this;
        //m_relocalizationInformations = new Dictionary<Guid, ETSI.ARF.OpenAPI.WorldStorage.RelocalizationInformation>();
        //m_computedPoses = new Dictionary<Guid, ETSI.ARF.OpenAPI.WorldAnalysis.Pose>(); 
        subscriptionsPoses = new Dictionary<Guid, SubscriptionInfo>();

        // sync
        var httpClient = new BasicHTTPClient(waServer.URI);
        apiClient = new WorldAnalysisClient(httpClient);

        // async
        //var httpClientAsync = new UnityWebRequestHttpClient(waServer.URI);
        //apiClientAsync = new WorldAnalysisClient(httpClientAsync);
    }

    /// <summary>
    /// Unity Start Method
    /// </summary>
    protected void Start()
    {
    }

    /// <summary>
    /// Unity Update Method
    /// </summary>
    protected void Update()
    {
        ManageSubscriptionValidity();

        // todo: Call subscription callback(s) here or in the websocket?!?
        foreach (KeyValuePair<Guid, SubscriptionInfo> subPose in subscriptionsPoses)
        {
        }
    }

    private void OnDestroy()
    {
        WebSocketClient_Close();
    }

    #endregion

    #region Test methods
    public void PrintCapabilities(Capability[] capabilities)
    {
        string res = "";
        Debug.Log("[REST] Got " + capabilities.Length + " capabilities.");
        foreach (var item in capabilities)
        {
            res += "\nCapability: " + item.TrackableType + " Version: " + item.EncodingInformation.Version;
        }
        res += "\nEnd of capabilities.";
        Debug.Log("[REST] Capabilities: " + res);
    }
    #endregion

    #region Lifecycle
    /// <summary>
    /// Check the validity of all subscriptions and delete one if needed
    /// </summary>
    protected void ManageSubscriptionValidity()
    {
        if (subscriptionsPoses.Count == 0) return;

        List<Guid> subscriptionToDelete = new List<Guid>();
        foreach (KeyValuePair<Guid, SubscriptionInfo> sub in subscriptionsPoses)
        {
            float validity = sub.Value.timeValidity;
            if (Time.time > validity)
            {
                subscriptionToDelete.Add(sub.Key);
            }
        }
        foreach (Guid s in subscriptionToDelete)
        {
            Debug.Log("ETSI ARF : Subscription deleted " + s);
            subscriptionsPoses.Remove(s);
        }
    }
    #endregion

    #region ARF_API
    //
    // Implementation of the endpoints
    //
    public AskFrameRateResult SetPoseEstimationFramerate(string token, PoseConfigurationTrackableType type, EncodingInformationStructure encodingInformation, int minimumFramerate)
    {
        PoseConfiguration poseConfig = new PoseConfiguration();
        poseConfig.TrackableType = type;
        poseConfig.EncodingInformation = encodingInformation;
        poseConfig.Framerate = minimumFramerate;
        apiClient.ConfigureFramerate(token, sessionID, poseConfig);
        return AskFrameRateResult.OK;
    }

    public PoseEstimationResult GetLastPose(string token, Guid uuid, Mode_WorldAnalysis mode, out ETSI.ARF.OpenAPI.WorldAnalysis.Pose pose)
    {
        pose = apiClient.GetPose(token, sessionID, uuid, mode);
        return pose != null ? PoseEstimationResult.OK : PoseEstimationResult.NOT_SUPPORTED;
    }


    public PoseEstimationResult[] GetLastPoses(string token, Guid[] uuids, Mode_WorldAnalysis[] modes, out ETSI.ARF.OpenAPI.WorldAnalysis.Pose[] poses)
    {
        if (uuids.Length != modes.Length)
        {
            Debug.LogError("[REST] ETSI ARF: Get poses: uuids and modes array do no have the same length");
            poses = null;
            return null;
        }
        PoseEstimationResult[] resul = new PoseEstimationResult[uuids.Length];
        poses = new ETSI.ARF.OpenAPI.WorldAnalysis.Pose[uuids.Length];
        List<UuidAndMode> uuidList = new List<UuidAndMode>();
        Poses poses_ = apiClient.GetPoses(token, sessionID, uuidList.ToArray());
        List<ETSI.ARF.OpenAPI.WorldAnalysis.Pose> posesList = poses_.Poses1 as List<ETSI.ARF.OpenAPI.WorldAnalysis.Pose>;

        if (poses_ != null && posesList != null && posesList.Count > 0)
        {
            for (int i = 0; i < uuids.Length; i++)
            {
                PoseEstimationResult poseResult = new PoseEstimationResult();
                resul[i] = poseResult;
                poses[i] = posesList[i];
            }
            return resul;
        }
        else
        {
            poses = null;
            return null;
        }
    }

    private string CreateWebsocket_URL(string originalURL)
    {
        string uri = originalURL;
        
        //
        // Overwrite server setting for testing local/extra servers
        //
        //if (isDebug) uri = "ws://localhost:61788/ws"; // for tests
        //if (isDebug) uri = "wss://localhost:44301/ws"; // for tests

        return uri;
    }

    public InformationSubscriptionResult SubscribeToPose(string token, Guid uuid, Mode_WorldAnalysis mode, PoseCallback callback, ref int validity, out Guid subscriptionUUID)
    {
        // Todo: Maintain the callback to the subscription id
        // Get capabilities?
        // Get reloc info?

        SubscriptionSingleRequest body = new SubscriptionSingleRequest();
        body.Target = uuid;
        body.Mode = mode;
        body.Validity = validity;
        body.WebhookUrl = callback != null ? "" : "https:\\..."; // empty -> app will use websockets (client)!

        // Get subscription info from the REST server
        SubscriptionSingle response = apiClient.SubscribeToPose(token, sessionID, body);
        subscriptionUUID = response.Uuid;
        validity = response.Validity;

        //SubscriptionMultipleRequest body_m = new SubscriptionMultipleRequest();
        //body_m.Targets = new List<object>();
        //body_m.Mode = new List<Mode_WorldAnalysis>();
        //body_m.Validity = validity;
        //body_m.WebhookUrl = callback == null ? "" : "https:\\..."; // empty -> app will use websockets (client)!
        //SubscriptionMultiple response = apiClient.SubscribeToPose(token, sessionID, body_m);

        // We add the subscription
        SubscriptionInfo sub = new SubscriptionInfo();
        sub.uuid = subscriptionUUID;
        sub.uuidTarget = uuid;
        sub.timeValidity = Time.time + (validity / 1000.0f);
        sub.callback = callback;

        sub.pose = new ETSI.ARF.OpenAPI.WorldAnalysis.Pose();
        sub.pose.Mode = mode;

        subscriptionsPoses.Add(sub.uuid, sub);

        if (!string.IsNullOrEmpty(response.WebhookUrl))
        {
            // Create a REST server so that the WA server can send pose update to it
            string webhookUrl = response.WebhookUrl;

            // Close other communication channel
            WebSocketClient_Close();

            // How to auto-generate the C# REST webhook server for pose for Unity?
            WebHookServer_Create(webhookUrl);
        }
        else if (!string.IsNullOrEmpty(response.WebsocketUrl))
        {
            // Create the WebSockets client here (NOT in the scene scripts)

            // Close other communication channel
            WebHookServer_Close();

            // Open the websocket
            if (webSocket == null) WebSocketClient_Create(CreateWebsocket_URL(response.WebsocketUrl));  // only one instance
        }
        else throw new Exception("[REST] No valid URL in server reponse.");
        return InformationSubscriptionResult.OK;
    }

    public InformationSubscriptionResult[] SubscribeToPoses(string token, Guid[] uuids, Mode_WorldAnalysis[] modes, PoseCallback callback, ref int validity, out Guid[] subscriptionUUIDs)
    {
        if (uuids.Length != 0 && uuids.Length == modes.Length)
        {
            InformationSubscriptionResult[] resul = new InformationSubscriptionResult[uuids.Length];
            subscriptionUUIDs = new Guid[uuids.Length];
            for (int i = 0; i < uuids.Length; i++)
            {
                resul[i] = SubscribeToPose(token, uuids[i], modes[i], callback, ref validity, out subscriptionUUIDs[i]);
            }
            return resul;
        }
        else
        {
            Debug.LogError("[REST] ETSI ARF: Subscribe poses: uuids and modes array do no have the same length");
            subscriptionUUIDs = null;
            return null;
        }
    }

    public InformationSubscriptionResult GetSubsription(string token, Guid subscriptionUUID, out PoseCallback callback, out Guid target, out Mode_WorldAnalysis mode, out int validity)
    {
        // default
        callback = null;
        target = Guid.Empty;
        mode = Mode_WorldAnalysis.TRACKABLES_TO_DEVICE;
        validity = 0;

        if (subscriptionsPoses.ContainsKey(subscriptionUUID))
        {
            // Check the server subscription
            SubscriptionSingle sub = apiClient.GetSubscription(token, sessionID, subscriptionUUID);

            // Check local one
            if (sub.Uuid == subscriptionUUID)
            {
                SubscriptionInfo subInfo = subscriptionsPoses[subscriptionUUID];
                callback = subInfo.callback;
                target = subInfo.uuidTarget;
                mode = subInfo.pose.Mode;
                float validitySeconds = subInfo.timeValidity - Time.time;
                validity = (int)validitySeconds * 1000;// conversion in ms

                // Compare both
                if (target == sub.Target && mode == sub.Mode && validity == sub.Validity)
                    return InformationSubscriptionResult.OK;
                else
                    return InformationSubscriptionResult.NOT_ALLOWED;
            }
        }
        return InformationSubscriptionResult.UNKNOWN_ID;
    }

    public InformationSubscriptionResult UpdateSubscription(string token, Guid subscriptionUUID, Mode_WorldAnalysis mode, int validity, PoseCallback callback)
    {
        // default
        callback = null;
        mode = Mode_WorldAnalysis.TRACKABLES_TO_DEVICE;
        validity = 0;

        if (subscriptionsPoses.ContainsKey(subscriptionUUID))
        {
            SubscriptionInfo sub = subscriptionsPoses[subscriptionUUID];
            PoseCallback oldCB = sub.callback;

            Body newSub = new Body();
            newSub.Mode = mode;
            newSub.Validity = validity;
            newSub.WebhookUrl = callback == null ? "" : "https:\\..."; // empty -> app will use websockets (client)!

            // Update subscription info in the REST server
            SubscriptionSingle response = apiClient.UpdateSubscription(token, sessionID, subscriptionUUID, newSub);

            // Update local data
            sub.pose.Mode = response.Mode;
            sub.callback = callback;
            sub.timeValidity = Time.time + (validity / 1000.0f);

            //
            // Recreate server/connection to ws only if someone changed!
            //
            if (oldCB != null && callback == null && !string.IsNullOrEmpty(response.WebhookUrl))
            {
                // Create a REST server so that the WA server can send pose update to it
                string webhookUrl = response.WebhookUrl;

                // Close other communication channel
                WebSocketClient_Close();

                // How to auto-generate the C# REST server for pose for Unity?
                WebHookServer_Create(webhookUrl);
            }
            else if (oldCB == null && callback != null && !string.IsNullOrEmpty(response.WebsocketUrl))
            {
                // Create the WebSockets client here (NOT in the scene scripts)

                // Close other communication channel
                WebHookServer_Close();

                // Open the websocket?
                if (webSocket == null) WebSocketClient_Create(CreateWebsocket_URL(response.WebsocketUrl));
            }
            else throw new Exception("[REST] No valid URL in server reponse.");

            return InformationSubscriptionResult.OK;
        }
        return InformationSubscriptionResult.UNKNOWN_ID;
    }

    public InformationSubscriptionResult UnsubscribeFromPose(Guid subscriptionUUID)
    {
        if (subscriptionsPoses.ContainsKey(subscriptionUUID))
        {
            apiClient.UnsubscribeFromPose(token, sessionID, subscriptionUUID);
            subscriptionsPoses.Remove(subscriptionUUID);

            if (subscriptionsPoses.Count == 0)
            {
                // Close the connection via websockets
                WebSocketClient_Close();
            }
            return InformationSubscriptionResult.OK;
        }
        return InformationSubscriptionResult.UNKNOWN_ID;
    }

    public CapabilityResult GetCapabilities(string token, out Capability[] capabilities)
    {
        Capabilities cap = apiClient.GetCapabilities(token, sessionID);
        if (cap == null || cap.Capabilities1 == null || cap.Capabilities1.Count == 0)
        {
            capabilities = null;
            return CapabilityResult.FAIL;
        }
        else
        {
            capabilities = new Capability[cap.Capabilities1.Count];
            cap.Capabilities1.CopyTo(capabilities, 0);
            return CapabilityResult.OK;
        }
    }

    public CapabilityResult GetCapability(string token, Guid uuid, out bool isSupported, out TypeWorldStorage type, out Capability[] capability)
    {
        isSupported = false;
        type = TypeWorldStorage.UNKNOWN;
        capability = null;

        Supports cap = apiClient.GetSupport(token, sessionID, uuid);
        if (cap == null || cap.Capabilities == null || cap.Capabilities.Count == 0)
        {
            isSupported = false;
            capability = null;
            return CapabilityResult.FAIL;
        }
        else
        {
            isSupported = true;
            capability = new Capability[cap.Capabilities.Count];
            cap.Capabilities.CopyTo(capability, 0);
            return CapabilityResult.OK;
        }
    }

    #endregion
}