GenericNetworkTransmitter.cs

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using System;
using System.Collections.Generic;
using UnityEngine;

#if !UNITY_EDITOR && UNITY_WSA && !(ENABLE_IL2CPP && NET_STANDARD_2_0)
using Windows.Networking.Sockets;
using Windows.Storage.Streams;
using Windows.Networking;
using Windows.Foundation;
using System.Threading.Tasks;
#endif

namespace HoloToolkit.Unity.SharingWithUNET
{
    public class GenericNetworkTransmitter : Singleton<GenericNetworkTransmitter>
    {
        [Tooltip("The connection port on the machine to use.")]
        public int SendConnectionPort = 11000;

        public delegate void OnDataReady(byte[] data);

#if UNITY_WSA && !(ENABLE_IL2CPP && NET_STANDARD_2_0)
        public event OnDataReady DataReadyEvent;
#endif

        private string serverIp;

        private bool waitingForConnection = false;

        private byte[] mostRecentDataBuffer;

#if !UNITY_EDITOR && UNITY_WSA && !(ENABLE_IL2CPP && NET_STANDARD_2_0)
        private StreamSocket networkConnection;

        private StreamSocketListener networkListener;

        private float timeToDeferFailedConnections = 10.0f;
#endif

        public void SetData(byte[] data)
        {
            mostRecentDataBuffer = data;
        }

        public void SetServerIp(string newServerIp)
        {
            serverIp = newServerIp.Trim();
        }

        public bool RequestAndGetData()
        {
            return ConnectListener();
        }

        private Queue<Action> DeferredActionQueue = new Queue<Action>();

        private void Update()
        {
            lock (DeferredActionQueue)
            {
                while (DeferredActionQueue.Count > 0)
                {
                    DeferredActionQueue.Dequeue()();
                }
            }
        }

        // A lot of the work done in this class can only be done in UWP. The editor is not a UWP app.
#if !UNITY_EDITOR && UNITY_WSA && !(ENABLE_IL2CPP && NET_STANDARD_2_0)
        private void RequestDataRetry()
        {
            if (!RequestAndGetData())
            {
                Invoke("RequestDataRetry", timeToDeferFailedConnections);
            }
        }
#endif

        public void ConfigureAsServer()
        {
#if !UNITY_EDITOR && UNITY_WSA && !(ENABLE_IL2CPP && NET_STANDARD_2_0)
            Task t = new Task(() =>
            {
                networkListener = new StreamSocketListener();
                networkListener.ConnectionReceived += NetworkListener_ConnectionReceived;
                networkListener.BindServiceNameAsync(SendConnectionPort.ToString()).GetResults();
            }
                );
            t.Start();
#else
            Debug.Log("This script is not intended to be run from the Unity Editor");
            // In order to avoid compiler warnings in the Unity Editor we have to access a few of our fields.
            Debug.Log(string.Format("serverIP = {0} waitingForConnection = {1} mostRecentDataBuffer = {2}", serverIp, waitingForConnection, mostRecentDataBuffer == null ? "No there" : "there"));
#endif
        }

        private bool ConnectListener()
        {
#if !UNITY_EDITOR && UNITY_WSA && !(ENABLE_IL2CPP && NET_STANDARD_2_0)
            if (waitingForConnection)
            {
                Debug.Log("Not a good time to connect listener");
                return false;
            }

            waitingForConnection = true;
            Debug.Log("Connecting to " + serverIp);
            HostName networkHost = new HostName(serverIp);
            networkConnection = new StreamSocket();

            IAsyncAction outstandingAction = networkConnection.ConnectAsync(networkHost, SendConnectionPort.ToString());
            AsyncActionCompletedHandler aach = new AsyncActionCompletedHandler(RcvNetworkConnectedHandler);
            outstandingAction.Completed = aach;

            return true;
#else
            return false;
#endif
        }

#if !UNITY_EDITOR && UNITY_WSA && !(ENABLE_IL2CPP && NET_STANDARD_2_0)
        private void NetworkListener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            // If we have data, send it. 
            if (mostRecentDataBuffer != null)
            {
                IOutputStream stream = args.Socket.OutputStream;
                using (DataWriter writer = new DataWriter(stream))
                {
                    writer.WriteInt32(mostRecentDataBuffer.Length);
                    writer.WriteBytes(mostRecentDataBuffer);
                    writer.StoreAsync().AsTask().Wait();
                    writer.FlushAsync().AsTask().Wait();
                }
            }
            else
            {
                Debug.LogError("No data to send but we've been connected to.  This is unexpected.");
            }
        }

        private async void RcvNetworkConnectedHandler(IAsyncAction asyncInfo, AsyncStatus status)
        {
            // Status completed is successful.
            if (status == AsyncStatus.Completed)
            {
                DataReader networkDataReader;

                // Since we are connected, we can read the data being sent to us.
                using (networkDataReader = new DataReader(networkConnection.InputStream))
                {
                    // read four bytes to get the size.
                    DataReaderLoadOperation drlo = networkDataReader.LoadAsync(4);
                    while (drlo.Status == AsyncStatus.Started)
                    {
                        // just waiting.
                    }

                    int dataSize = networkDataReader.ReadInt32();
                    if (dataSize < 0)
                    {
                        Debug.Log("Super bad super big data size");
                    }

                    // Need to allocate a new buffer with the dataSize.
                    mostRecentDataBuffer = new byte[dataSize];

                    // Read the data.
                    await networkDataReader.LoadAsync((uint)dataSize);
                    networkDataReader.ReadBytes(mostRecentDataBuffer);

                    // And fire our data ready event.
                    DataReadyEvent?.Invoke(mostRecentDataBuffer);
                }
            }
            else
            {
                Debug.Log("Failed to establish connection for rcv. Error Code: " + asyncInfo.ErrorCode);
                // In the failure case we'll requeue the data and wait before trying again.


                // And set the defer time so the update loop can do the 'Unity things' 
                // on the main Unity thread.
                DeferredActionQueue.Enqueue(() =>
                {
                    Invoke("RequestDataRetry", timeToDeferFailedConnections);
                });
            }

            networkConnection.Dispose();
            waitingForConnection = false;
        }
#endif
    }
}