1

Assets/BITKit/Unity/Scripts/Http/HttpService.cs

@@ -0,0 +1,155 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using Cysharp.Threading.Tasks;
+using UnityEngine;
+using UnityEngine.Events;
+using Debug = UnityEngine.Debug;
+using Timer = System.Timers.Timer;
+
+namespace BITKit.Http
+{
+	public class HttpService : MonoBehaviour
+	{
+		[Header(Constant.Header.Settings)]
+		[SerializeReference,SubclassSelector] private IReference url;
+		[SerializeField] private double interval;
+		[SerializeField] private CollisionDetectionMode detectionMode; 
+		
+		[Header(Constant.Header.Output)]
+		[SerializeField] private UnityEvent<string> output;
+		[SerializeField] private UnityEvent<string> onException;
+		[SerializeField] private UnityEvent<int> onCalculateLength;
+		
+		[Header(Constant.Header.Optional)]
+		[SerializeField] private Optional<string> overrideResponse;
+		
+		
+		[Header(Constant.Header.Debug)]
+		[SerializeField, ReadOnly] private double time;
+		
+		
+
+		[SerializeField, ReadOnly] private bool isConnected;
+
+		private readonly Timer timer = new()
+		{
+AutoReset = true
+		};
+		private readonly HttpClient _httpClient = new();
+		private bool _enabled;
+
+		private void OnEnable()
+		{
+			_enabled = true;
+		}
+		private void OnDisable()
+		{
+			_enabled = false;
+		}
+		private void Start()
+		{
+			timer.Interval = interval*1000;
+			timer.Elapsed += (x, y) => OnUpdate();
+			timer.AutoReset = detectionMode switch
+			{
+				CollisionDetectionMode.ContinuousDynamic => true,
+				CollisionDetectionMode.ContinuousSpeculative => true,
+				CollisionDetectionMode.Continuous => true,
+				CollisionDetectionMode.Discrete => false,
+				_ => throw new ArgumentOutOfRangeException()
+			};
+			timer.Start();
+			destroyCancellationToken.ThrowIfCancellationRequested();
+		}
+		private void OnDestroy()
+		{
+			timer.Stop();
+			timer.Dispose();
+		}
+		private async void OnUpdate()
+		{
+			try
+			{
+				if (_enabled)
+				{
+
+					if (overrideResponse.Allow)
+					{
+						await UniTask.SwitchToMainThread();
+						try
+						{
+							output.Invoke(overrideResponse.Value);
+						}
+						catch (Exception e)
+						{
+							Debug.LogException(e);
+						}
+                        
+						isConnected = true;
+					}
+					else
+					{
+						Stopwatch stopwatch = new();
+						stopwatch.Start();
+						//var result = await _httpClient.GetStringAsync(url.Value);
+						var response = await _httpClient.GetAsync(url.Value,destroyCancellationToken);
+						if (destroyCancellationToken.IsCancellationRequested) return;
+						var result =await response.Content.ReadAsStringAsync();
+						if (destroyCancellationToken.IsCancellationRequested) return;
+
+						stopwatch.Stop();
+						time =System.TimeSpan.FromMilliseconds(stopwatch.ElapsedMilliseconds).TotalSeconds;
+
+						await UniTask.SwitchToMainThread();
+						if (destroyCancellationToken.IsCancellationRequested) return;
+
+						try
+						{
+							var length = int.Parse(response.Content.Headers.First(h => h.Key.Equals("Content-Length")).Value.First());
+							onCalculateLength.Invoke(length);
+						}
+						catch (InvalidOperationException)
+						{
+					
+						}
+				
+						if (response.StatusCode is not System.Net.HttpStatusCode.OK)
+						{
+							onException.Invoke(result);
+						}
+						else
+						{
+							try
+							{
+								output.Invoke(result);
+							}
+							catch (Exception e)
+							{
+								Debug.LogException(e);
+							}
+						}
+
+						isConnected = true;
+					}
+				}
+			}
+			catch(OperationCanceledException){}
+			catch (Exception e)
+			{
+				BIT4Log.LogException(e);
+				isConnected = false;
+			}
+
+			if (timer.AutoReset == false)
+			{
+				if(destroyCancellationToken.IsCancellationRequested)return;
+				timer.Start();
+			}
+		}
+	}
+}