HttpClientインスタンスの取り回しを効率化する

Covid19Radar/Covid19Radar/App.xaml.cs

@@ -183,21 +183,25 @@ private static void RegisterCommonTypes(IContainer container)
             container.Register<ILoggerService, LoggerService>(Reuse.Singleton);
             container.Register<ILogFileService, LogFileService>(Reuse.Singleton);
             container.Register<ILogPathService, LogPathService>(Reuse.Singleton);
-            container.Register<ILogUploadService, LogUploadService>(Reuse.Singleton);
             container.Register<IEssentialsService, EssentialsService>(Reuse.Singleton);
-            container.Register<IUserDataService, UserDataService>(Reuse.Singleton);
             container.Register<ITermsUpdateService, TermsUpdateService>(Reuse.Singleton);
             container.Register<IHttpClientService, HttpClientService>(Reuse.Singleton);
             container.Register<IMigrationService, MigrationService>(Reuse.Singleton);
 
 #if USE_MOCK
+            container.Register<IUserDataService, UserDataServiceMock>(Reuse.Singleton);
+            container.Register<ILogUploadService, LogUploadServiceMock>(Reuse.Singleton);
+            container.Register<IDiagnosisKeyRegisterServer, DiagnosisKeyRegisterServerMock>(Reuse.Singleton);
             container.Register<IExposureDataRepository, ExposureDataRepositoryMock>(Reuse.Singleton);
-            container.Register<IHttpDataService, HttpDataServiceMock>(Reuse.Singleton);
             container.Register<IStorageService, StorageServiceMock>(Reuse.Singleton);
+            container.Register<IExposureRiskCalculationConfigurationRepository, ExposureRiskCalculationConfigurationRepositoryMock>(Reuse.Singleton);
 #else
+            container.Register<IUserDataService, UserDataService>(Reuse.Singleton);
+            container.Register<ILogUploadService, LogUploadService>(Reuse.Singleton);
+            container.Register<IDiagnosisKeyRegisterServer, DiagnosisKeyRegisterServer>(Reuse.Singleton);
             container.Register<IExposureDataRepository, ExposureDataRepository>(Reuse.Singleton);
-            container.Register<IHttpDataService, HttpDataService>(Reuse.Singleton);
             container.Register<IStorageService, StorageService>(Reuse.Singleton);
+            container.Register<IExposureRiskCalculationConfigurationRepository, ExposureRiskCalculationConfigurationRepository>(Reuse.Singleton);
 #endif
 
 #if DEBUG
@@ -208,14 +212,12 @@ private static void RegisterCommonTypes(IContainer container)
             container.Register<IDebugExposureDataCollectServer, DebugExposureDataCollectServerNop>(Reuse.Singleton);
 #endif
 
-            container.Register<IDiagnosisKeyRegisterServer, DiagnosisKeyRegisterServer>(Reuse.Singleton);
             container.Register<IDialogService, DialogService>(Reuse.Singleton);
             container.Register<ISecureStorageService, SecureStorageService>(Reuse.Singleton);
             container.Register<IExposureDetectionService, ExposureDetectionService>(Reuse.Singleton);
             container.Register<IExposureRiskCalculationService, ExposureRiskCalculationService>(Reuse.Singleton);
             container.Register<IDiagnosisKeyRepository, DiagnosisKeyRepository>(Reuse.Singleton);
             container.Register<IExposureConfigurationRepository, ExposureConfigurationRepository>(Reuse.Singleton);
-            container.Register<IExposureRiskCalculationConfigurationRepository, ExposureRiskCalculationConfigurationRepository>(Reuse.Singleton);
             container.Register<ICheckVersionService, CheckVersionService>(Reuse.Singleton);
 
 #if EVENT_LOG_ENABLED

Covid19Radar/Covid19Radar/Repository/DiagnosisKeyRepository.cs

@@ -41,20 +41,20 @@ public class DiagnosisKeyRepository : IDiagnosisKeyRepository
 
         private readonly ILoggerService _loggerService;
 
-        private readonly HttpClient _httpClient;
+        private readonly IHttpClientService _httpClientService;
 
         public DiagnosisKeyRepository(
             IHttpClientService httpClientService,
             ILoggerService loggerService
             )
         {
-            _httpClient = httpClientService.Create();
+            _httpClientService = httpClientService;
             _loggerService = loggerService;
         }
 
         public async Task<(HttpStatusCode, IList<DiagnosisKeyEntry>)> GetDiagnosisKeysListAsync(string url, CancellationToken cancellationToken)
         {
-            HttpResponseMessage response = await _httpClient.GetAsync(url, cancellationToken);
+            HttpResponseMessage response = await _httpClientService.CdnClient.GetAsync(url, cancellationToken);
             if (response.IsSuccessStatusCode)
             {
                 string content = await response.Content.ReadAsStringAsync();
@@ -74,7 +74,7 @@ public async Task<string> DownloadDiagnosisKeysAsync(DiagnosisKeyEntry diagnosis
         {
             Uri uri = new Uri(diagnosisKeyEntry.Url);
 
-            HttpResponseMessage response = await _httpClient.GetAsync(uri, cancellationToken);
+            HttpResponseMessage response = await _httpClientService.CdnClient.GetAsync(uri, cancellationToken);
             if (response.IsSuccessStatusCode)
             {
                 string fileName = uri.Segments[uri.Segments.Length - 1];

Covid19Radar/Covid19Radar/Repository/ExposureConfigurationRepository.cs

@@ -40,7 +40,7 @@ public class ExposureConfigurationRepository : IExposureConfigurationRepository
         private readonly IDateTimeUtility _dateTimeUtility;
         private readonly ILoggerService _loggerService;
 
-        private readonly HttpClient _httpClient;
+        private readonly IHttpClientService _httpClientService;
 
         private readonly string _configDir;
 
@@ -63,8 +63,7 @@ ILoggerService loggerService
             _dateTimeUtility = dateTimeUtility;
             _loggerService = loggerService;
 
-            _httpClient = httpClientService.Create();
-            _httpClient.Timeout = TimeSpan.FromSeconds(TIMEOUT_SECONDS);
+            _httpClientService = httpClientService;
 
             _configDir = PrepareConfigDir();
             _currentExposureConfigurationPath = localPathService.CurrentExposureConfigurationPath;
@@ -147,7 +146,7 @@ private async Task<ExposureConfiguration> GetExposureConfigurationInternalAsync(
 
             ExposureConfiguration newExposureConfiguration = null;
 
-            var response = await _httpClient.GetAsync(url);
+            var response = await _httpClientService.StaticJsonContentClient.GetAsync(url);
             if (response.IsSuccessStatusCode)
             {
                 string exposureConfigurationAsJson = await response.Content.ReadAsStringAsync();

Covid19Radar/Covid19Radar/Repository/ExposureRiskCalculationConfigurationRepository.cs

@@ -21,13 +21,11 @@ public interface IExposureRiskCalculationConfigurationRepository
 
     public class ExposureRiskCalculationConfigurationRepository : IExposureRiskCalculationConfigurationRepository
     {
-        private const double TIMEOUT_SECONDS = 10.0;
-
         private readonly ILocalPathService _localPathService;
         private readonly IServerConfigurationRepository _serverConfigurationRepository;
         private readonly ILoggerService _loggerService;
 
-        private readonly HttpClient _httpClient;
+        private readonly IHttpClientService _httpClientService;
 
         private readonly string _configDir;
 
@@ -46,8 +44,7 @@ ILoggerService loggerService
             _serverConfigurationRepository = serverConfigurationRepository;
             _loggerService = loggerService;
 
-            _httpClient = httpClientService.Create();
-            _httpClient.Timeout = TimeSpan.FromSeconds(TIMEOUT_SECONDS);
+            _httpClientService = httpClientService;
 
             _configDir = PrepareConfigDir();
             _currentPath = localPathService.CurrentExposureRiskCalculationConfigurationPath;
@@ -126,7 +123,7 @@ private async Task<V1ExposureRiskCalculationConfiguration> GetExposureRiskCalcul
 
             try
             {
-                var response = await _httpClient.GetAsync(url);
+                var response = await _httpClientService.StaticJsonContentClient.GetAsync(url);
                 if (response.IsSuccessStatusCode)
                 {
                     string exposureRiskCalculationConfigurationAsJson = await response.Content.ReadAsStringAsync();
@@ -227,7 +224,7 @@ private void Swap(string sourcePath, string destPath)
             {
                 File.Move(sourcePath, destPath);
             }
-            catch(IOException exception)
+            catch (IOException exception)
             {
                 _loggerService.Exception("IOException", exception);
 
@@ -252,4 +249,10 @@ private async Task<string> LoadAsync(string path)
         private async Task SaveAsync(string exposureConfigurationAsJson, string outPath)
             => await File.WriteAllTextAsync(outPath, exposureConfigurationAsJson);
     }
+
+    public class ExposureRiskCalculationConfigurationRepositoryMock : IExposureRiskCalculationConfigurationRepository
+    {
+        public Task<V1ExposureRiskCalculationConfiguration> GetExposureRiskCalculationConfigurationAsync(bool preferCache)
+            => Task.FromResult(new V1ExposureRiskCalculationConfiguration());
+    }
 }

Covid19Radar/Covid19Radar/Services/CheckVersionService.cs

@@ -3,7 +3,6 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 using System;
-using System.Net.Http;
 using System.Threading.Tasks;
 using Covid19Radar.Resources;
 using Covid19Radar.Services.Logs;
@@ -24,7 +23,7 @@ public Task<bool> IsUpdateVersionExistAsync()
 
     public class CheckVersionService : ICheckVersionService
     {
-        private readonly HttpClient _httpClient;
+        private readonly IHttpClientService _httpClientService;
         private readonly IEssentialsService _essentialsService;
         private readonly ILoggerService _loggerService;
 
@@ -34,7 +33,7 @@ public CheckVersionService(
             ILoggerService loggerService
             )
         {
-            _httpClient = httpClientService.Create();
+            _httpClientService = httpClientService;
             _essentialsService = essentialsService;
             _loggerService = loggerService;
         }
@@ -46,7 +45,7 @@ public async Task<bool> IsUpdateVersionExistAsync()
             var uri = AppResources.UrlVersion;
             try
             {
-                var json = await _httpClient.GetStringAsync(uri);
+                var json = await _httpClientService.StaticJsonContentClient.GetStringAsync(uri);
                 var key = _essentialsService.IsIos ? "ios" : "android";
                 var versionString = JObject.Parse(json).Value<string>(key);
 

Covid19Radar/Covid19Radar/Services/DebugExposureDataCollectServer.cs

@@ -75,7 +75,7 @@ public class DebugExposureDataCollectServer : IDebugExposureDataCollectServer
     {
         private readonly ILoggerService _loggerService;
         private readonly IServerConfigurationRepository _serverConfigurationRepository;
-        private readonly HttpClient _httpClient;
+        private readonly IHttpClientService _httpClientService;
 
         public DebugExposureDataCollectServer(
             ILoggerService loggerService,
@@ -85,7 +85,7 @@ IHttpClientService httpClientService
         {
             _loggerService = loggerService;
             _serverConfigurationRepository = serverConfigurationRepository;
-            _httpClient = httpClientService.Create();
+            _httpClientService = httpClientService;
         }
 
         public async Task UploadExposureDataAsync(
@@ -173,7 +173,7 @@ string exposureDataCollectServerEndpoint
 
                 Uri uri = new Uri(exposureDataCollectServerEndpoint);
 
-                HttpResponseMessage response = await _httpClient.PutAsync(uri, httpContent);
+                HttpResponseMessage response = await _httpClientService.ApiClient.PutAsync(uri, httpContent);
                 if (response.IsSuccessStatusCode)
                 {
                     var responseJson = await response.Content.ReadAsStringAsync();

Covid19Radar/Covid19Radar/Services/DiagnosisKeyRegisterServer.cs

@@ -6,30 +6,37 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Net;
+using System.Net.Http;
+using System.Text;
 using System.Threading.Tasks;
 using Chino;
 using Covid19Radar.Common;
 using Covid19Radar.Model;
+using Covid19Radar.Repository;
 using Covid19Radar.Services.Logs;
+using Newtonsoft.Json;
 using Xamarin.Essentials;
 
 namespace Covid19Radar.Services
 {
     public class DiagnosisKeyRegisterServer : IDiagnosisKeyRegisterServer
     {
         private readonly ILoggerService _loggerService;
-        private readonly IHttpDataService _httpDataService;
+        private readonly IHttpClientService _httpClientService;
         private readonly IDeviceVerifier _deviceVerifier;
+        private readonly IServerConfigurationRepository _serverConfigurationRepository;
 
         public DiagnosisKeyRegisterServer(
             ILoggerService loggerService,
-            IHttpDataService httpDataService,
-            IDeviceVerifier deviceVerifier
+            IHttpClientService httpClientService,
+            IDeviceVerifier deviceVerifier,
+            IServerConfigurationRepository serverConfigurationRepository
             )
         {
             _loggerService = loggerService;
-            _httpDataService = httpDataService;
+            _httpClientService = httpClientService;
             _deviceVerifier = deviceVerifier;
+            _serverConfigurationRepository = serverConfigurationRepository;
         }
 
         public async Task<HttpStatusCode> SubmitDiagnosisKeysAsync(
@@ -68,14 +75,51 @@ string idempotencyKey
                     processNumber,
                     idempotencyKey
                     );
-                return await _httpDataService.PutSelfExposureKeysAsync(diagnosisInfo);
+                return await PutSelfExposureKeysAsync(diagnosisInfo);
             }
             finally
             {
                 _loggerService.EndMethod();
             }
         }
 
+        public async Task<HttpStatusCode> PutSelfExposureKeysAsync(DiagnosisSubmissionParameter request)
+        {
+            _loggerService.StartMethod();
+
+            try
+            {
+                await _serverConfigurationRepository.LoadAsync();
+
+                var diagnosisKeyRegisterApiUrls = _serverConfigurationRepository.DiagnosisKeyRegisterApiUrls;
+                if (diagnosisKeyRegisterApiUrls.Count() == 0)
+                {
+                    _loggerService.Error("DiagnosisKeyRegisterApiUrls count 0");
+                    throw new InvalidOperationException("DiagnosisKeyRegisterApiUrls count 0");
+                }
+                else if (diagnosisKeyRegisterApiUrls.Count() > 1)
+                {
+                    _loggerService.Warning("Multi DiagnosisKeyRegisterApiUrl are detected.");
+                }
+
+                var url = diagnosisKeyRegisterApiUrls.First();
+                var content = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");
+
+                return await PutAsync(url, content);
+            }
+            finally
+            {
+                _loggerService.EndMethod();
+            }
+        }
+
+        private async Task<HttpStatusCode> PutAsync(string url, HttpContent body)
+        {
+            var result = await _httpClientService.ApiClient.PutAsync(url, body);
+            await result.Content.ReadAsStringAsync();
+            return result.StatusCode;
+        }
+
         private async Task<DiagnosisSubmissionParameter> CreateSubmissionAsync(
             bool hasSymptom,
             DateTime symptomOnsetDate,
@@ -164,6 +208,21 @@ private static string GetPadding(Random random = null)
         }
     }
 
+    public class DiagnosisKeyRegisterServerMock : IDiagnosisKeyRegisterServer
+    {
+        public Task<HttpStatusCode> SubmitDiagnosisKeysAsync(
+            bool hasSymptom,
+            DateTime symptomOnsetDate,
+            IList<TemporaryExposureKey> temporaryExposureKeys,
+            string processNumber,
+            string idempotencyKey
+            )
+            => Task.FromResult(HttpStatusCode.NoContent);
+
+        public Task<HttpStatusCode> PutSelfExposureKeysAsync(DiagnosisSubmissionParameter request)
+            => Task.FromResult(HttpStatusCode.NoContent);
+    }
+
     public class DiagnosisKeyRegisterException : Exception
     {
         private const string DataKeyCode = "code";