private void DownloadMeta(CancellationToken cancellationToken)
{
_logger.LogDebug("Downloading resource meta...");
var downloader = _createNewHttpDownloader(_destinationMetaPath, _resource.GetMetaUrls());
downloader.Download(cancellationToken);
_logger.LogDebug("Resource meta downloaded.");
}
private void Initialize(PatcherData data)
{
_cache = new UnityCache(data.AppSecret);
if (IsCachedBannerAvailable())
{
_logger.LogDebug(string.Format("A cached banner image is available at {0}", CachedBannerPath));
LoadBannerImage(CachedBannerPath, OldImage);
}
var patcher = Patcher.Instance;
patcher.AppInfo
.SkipWhile(info => info.Id == default(int))
.Select(info => new Data
{
BannerData = new PatcherBannerData
{
ImageUrl = info.PatcherBannerImage,
Dimensions = info.PatcherBannerImageDimensions,
ModificationDate = info.PatcherBannerImageUpdatedAt
},
BannerFilePath = Path.Combine(data.AppDataPath, BannerImageFilename)
})
.ObserveOnMainThread()
.Subscribe(OnBannerDataUpdate);
//TODO: Dispose subscription
}
private void EnforceCorrectScreenSize()
{
string screenSizeFilePath = Path.Combine(Application.dataPath, ScreenSizeFilename);
_logger.LogDebug("Reading correct screen size from " + screenSizeFilePath);
if (!File.Exists(screenSizeFilePath))
{
_logger.LogWarning(screenSizeFilePath + " file does not exist.");
return;
}
var screenResolutionText = File.ReadAllText(screenSizeFilePath).Split(' ');
try
{
int width = int.Parse(screenResolutionText[0]);
int height = int.Parse(screenResolutionText[1]);
PlayerPrefs.SetInt("Screenmanager Resolution Width", width);
PlayerPrefs.SetInt("Screenmanager Resolution Height", height);
PlayerPrefs.SetInt("Screenmanager Is Fullscreen mode", 0);
Screen.SetResolution(width, height, false);
}
catch (System.Exception e)
{
_logger.LogError("Failed to correct screen sizing due to an exception.", e);
}
}
public IHttpResponse Get(HttpGetRequest getRequest)
{
try
{
_logger.LogDebug("Sending GET request to " + getRequest.Address);
if (getRequest.Range != null)
{
throw new NotImplementedException();
}
_logger.LogTrace("timeout = " + getRequest.Timeout);
var result = new WWWResult();
var waitHandle = UnityDispatcher.InvokeCoroutine(GetWWW(getRequest, result));
waitHandle.WaitOne(TimeSpan.FromMilliseconds(getRequest.Timeout));
lock (result)
{
if (!result.IsDone)
{
throw new WebException("Timeout.", WebExceptionStatus.Timeout);
}
var statusCode = ReadStatusCode(result);
_logger.LogDebug("Successfuly received response.");
return(new UnityHttpResponse(result.Text, statusCode, ResponseEncoding));
}
}
catch (Exception e)
{
_logger.LogError("Failed to get response.", e);
throw;
}
}
public override void Prepare([NotNull] UpdaterStatus status, CancellationToken cancellationToken)
{
if (status == null)
{
throw new ArgumentNullException("status");
}
try
{
_logger.LogDebug("Preparing diff installation...");
base.Prepare(status, cancellationToken);
_localData.PrepareForWriting();
_previousContentSummary = _remoteMetaData.GetContentSummary(_versionId - 1, cancellationToken);
_contentSummary = _remoteMetaData.GetContentSummary(_versionId, cancellationToken);
_diffSummary = _remoteMetaData.GetDiffSummary(_versionId, cancellationToken);
double unarchivePackageWeight = StatusWeightHelper.GetUnarchivePackageWeight(_diffSummary.Size);
_logger.LogTrace("unarchivePackageWeight = " + unarchivePackageWeight);
_unarchivePackageStatusReporter = new OperationStatus
{
Weight = { Value = unarchivePackageWeight }
};
status.RegisterOperation(_unarchivePackageStatusReporter);
double addFilesWeight = StatusWeightHelper.GetAddDiffFilesWeight(_diffSummary);
_logger.LogTrace("addFilesWeight = " + addFilesWeight);
_addFilesStatusReporter = new OperationStatus
{
Weight = { Value = addFilesWeight }
};
status.RegisterOperation(_addFilesStatusReporter);
double modifiedFilesWeight = StatusWeightHelper.GetModifyDiffFilesWeight(_diffSummary);
_logger.LogTrace("modifiedFilesWeight = " + modifiedFilesWeight);
_modifiedFilesStatusReporter = new OperationStatus
{
Weight = { Value = modifiedFilesWeight }
};
status.RegisterOperation(_modifiedFilesStatusReporter);
double removeFilesWeight = StatusWeightHelper.GetRemoveDiffFilesWeight(_diffSummary);
_logger.LogTrace("removeFilesWeight = " + removeFilesWeight);
_removeFilesStatusReporter = new OperationStatus
{
Weight = { Value = removeFilesWeight }
};
status.RegisterOperation(_removeFilesStatusReporter);
_logger.LogDebug("Diff installation prepared.");
}
catch (Exception e)
{
_logger.LogError("Failed to prepare diff installation.", e);
throw;
}
}
private bool TrySendRequest(ApiConnectionServer server, Request request, ServerType serverType,
out IApiResponse response)
{
Logger.LogDebug(
string.Format(
"Trying to get response from server ({0}): '{1}:{2}' (uses HTTPS: {3})...",
serverType,
server.Host,
server.RealPort,
server.UseHttps));
response = null;
List <Exception> exceptionsList;
switch (serverType)
{
case ServerType.MainServer:
exceptionsList = request.MainServerExceptions;
break;
case ServerType.CacheServer:
exceptionsList = request.CacheServersExceptions;
break;
default:
throw new ArgumentOutOfRangeException(serverType.ToString(), serverType, null);
}
try
{
var uri = new UriBuilder
{
Scheme = server.UseHttps ? "https" : "http",
Host = server.Host,
Path = request.Path,
Query = request.Query,
Port = server.RealPort
}.Uri;
var httpResponse = MakeResponse(uri, request);
Logger.LogDebug("Received response. Checking whether it is valid...");
Logger.LogTrace(
string.Format(
"Response status code: {0}",
httpResponse.StatusCode));
if (IsResponseValid(httpResponse, serverType))
{
Logger.LogDebug("Response is valid.");
response = new ApiResponse(httpResponse);
return(true);
}
Logger.LogWarning("Response is not valid.");
if (IsResponseUnexpectedError(httpResponse, serverType))
{
throw new ApiResponseException((int)httpResponse.StatusCode);
}
throw new ApiServerConnectionException(
string.Format(
"Server \'{0}\' returned code {1}",
server.Host,
(int)httpResponse.StatusCode));
}
catch (WebException webException)
{
Logger.LogWarning("Error while connecting to the API server.", webException);
exceptionsList.Add(webException);
return(false);
}
catch (ApiServerConnectionException e)
{
Logger.LogWarning("Error while connecting to the API server.", e);
exceptionsList.Add(e);
return(false);
}
}
