/// <summary>
/// Serializes the json document to file.
/// </summary>
/// <returns><c>true</c>, if json document to file was serialized, <c>false</c> otherwise.</returns>
/// <param name="filePath">File path.</param>
/// <param name="encodeMethod">Encode method.</param>
public static bool SerializeJsonDocToFile(string filePath, IDictionary <string, object> jsonDoc, Func <string, string> encodeMethod)
{
bool result = false;
try {
if (null != jsonDoc)
{
string resultStr = SimpleJson.SimpleJson.SerializeObject(jsonDoc);
if (!string.IsNullOrEmpty(resultStr))
{
if (null != encodeMethod)
{
resultStr = encodeMethod(resultStr);
}
if (!string.IsNullOrEmpty(resultStr))
{
File.WriteAllText(filePath, resultStr);
result = true;
}
}
}
}
catch (Exception ex) {
Logger.Log("[Util] Error in persisting file: " + ex.Message);
result = false;
}
return(result);
}
/// <summary>
/// Tests the internet connection.
/// </summary>
/// <returns>The internet connection.</returns>
public static IEnumerator TestInternetConnection()
{
long startTime = 0;
long timeTaken = 0;
float maxTime = 5.0F;
float secondsToWait = 10F;
#if INTERNET_CHECK_USING_PING
while (true)
{
yield return(Job.CreateAsCoroutine(
ExecutePingCommand("74.125.224.72", maxTime,
time => {
Logger.Log("RECEIVED PING - " + time);
if (time < maxTime)
{
IsInternetReachable = true;
secondsToWait = 20F;
}
else
{
IsInternetReachable = false;
secondsToWait = 5F;
}
})));
yield return(new WaitForSeconds(secondsToWait));
}
#else
while (true)
{
startTime = DateTime.Now.Ticks;
//Util.Logger.Log("START TICK - " + startTime);
yield return(Coroutiner.StartCoroutine(
Util.ExecuteGetCommand("http://www.google.com",
www => {
timeTaken = DateTime.Now.Ticks - startTime;
//Util.Logger.Log("END TICK - " + DateTime.Now.Ticks);
//Util.Logger.Log("TIME TAKEN - " + timeTaken);
if (!string.IsNullOrEmpty(www.error))
{
//Util.Logger.Log("ERROR - " + www.error);
IsInternetReachable = false;
secondsToWait = 5;
}
else
{
IsInternetReachable = true;
secondsToWait = 20;
}
})));
yield return(new WaitForSeconds(secondsToWait));
}
#endif
}
/// <summary>
/// Executes the post command.
/// </summary>
/// <returns>
/// The post command.
/// </returns>
/// <param name='url'>
/// URL.
/// </param>
/// <param name='data'>
/// Data.
/// </param>
/// <param name='responseCode'>
/// Response code.
/// </param>
public static IEnumerator ExecutePostCommand(string url, string data, Action <WWW> callback)
{
var form = new WWWForm();
form.headers ["Content-Type"] = "application/json";
Logger.Log(string.Format("[HTTP POST] Request {0} {1}", url, data));
using (WWW www = new WWW(url, Encoding.UTF8.GetBytes(data), form.headers)) {
yield return(www);
Logger.Log(string.Format("[HTTP POST] Response {0}", (!string.IsNullOrEmpty(www.error)) ? (" Error - " + www.error) : www.text));
if (www.isDone && null != callback)
{
callback(www);
}
}
}
/// <summary>
/// Deserialize json document from cache or resource.
/// </summary>
/// <returns>The deserialized json document from cache or resource.</returns>
/// <param name="resourceName">Resource name.</param>
public static IDictionary <string, object> DeSerializeJsonDocFromCacheOrResource(string resourceName)
{
IDictionary <string, object> result = null;
string filePath = Path.Combine(Application.persistentDataPath, resourceName);
if (File.Exists(filePath))
{
Logger.Log("[DE-SERIALIZE] OPENING FILE :" + filePath);
result = DeSerializeJsonDocFromFile(filePath, null);
}
if (null == result)
{
Logger.Log("[DE-SERIALIZE] OPENING RESOURCE :" + resourceName);
result = DeSerializeJsonDocFromResource(resourceName);
}
return(result);
}
/// <summary>
/// Executes the post command with basic auth.
/// </summary>
/// <returns>The post command with basic auth.</returns>
/// <param name="url">URL.</param>
/// <param name="username">Username.</param>
/// <param name="password">Password.</param>
/// <param name="data">Data.</param>
/// <param name="callback">Callback.</param>
public static IEnumerator ExecutePostCommandWithBasicAuth(string url, string username, string password, string data, Action <WWW> callback)
{
var form = new WWWForm();
var headers = form.headers;
headers ["Content-Type"] = "application/json";
headers ["Authorization"] = "Basic " + System.Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes(string.Format("{0}:{1}", username, password)));
Logger.Log(string.Format("[HTTP POST] Request {0} {1}:{2} {3}", url, username, password, data));
using (WWW www = new WWW(url, Encoding.UTF8.GetBytes(data), headers)) {
yield return(www);
Logger.Log(string.Format("[HTTP POST] Response {0}", (!string.IsNullOrEmpty(www.error)) ? (" Error - " + www.error) : www.text));
if (www.isDone && null != callback)
{
callback(www);
}
}
}
/// <summary>
/// Executes the ping command.
/// </summary>
/// <returns>The ping command.</returns>
/// <param name="address">Address.</param>
/// <param name="timeOut">Time out.</param>
/// <param name="callback">Callback.</param>
public static IEnumerator ExecutePingCommand(string address, float timeOut, Action <float> callback)
{
Ping ping = new Ping(address);
float timeDiff = 0.1f;
float time = 0.0f;
while (!ping.isDone)
{
yield return(new WaitForSeconds(timeDiff));
time += timeDiff;
if (time >= timeOut)
{
break;
}
}
Logger.Log("PING:" + time.ToString("0.0") + " TIMEOUT:" + timeOut + " IsDone:" + ping.isDone + " Time:" + ping.time);
if (null != callback)
{
callback(time);
}
}
/// <summary>
/// Executes the get command.
/// </summary>
/// <returns>
/// The get command.
/// </returns>
/// <param name='url'>
/// URL.
/// </param>
/// <param name='callback'>
/// Callback.
/// </param>
public static IEnumerator ExecuteGetCommand(string url, Action <WWW> callback)
{
Logger.Log(string.Format("[HTTP GET] Request {0}", url));
if (!Util.IsInternetReachable)
{
if (null != callback)
{
callback(null);
}
yield break;
}
using (WWW www = new WWW(url)) {
yield return(www);
//Logger.Log (string.Format("[HTTP GET] Response {0} {1}", requestNo, (!string.IsNullOrEmpty (www.error)) ? (" Error - " + www.error) : www.text));
if (www.isDone && null != callback)
{
callback(www);
}
}
}
