Software Público Brasileiro

using UnityEngine;
using System.Collections;
using System;
using UnityEngine.UI;
using LAViD.VLibras.Utils;

public class PlayerManager : GenericPlayerManager {

#if UNITY_IOS
	//private const string BASE_URL = "http://150.165.205.9/anims/IOS/";//old
    private const string BASE_URL = "http://dicionario.vlibras.gov.br/IOS/";
#else
    //private const string BASE_URL = "http://150.165.205.9/anims/ANDROID/";//old
    private const string BASE_URL = "http://dicionario.vlibras.gov.br/ANDROID/";
#endif

	//private const string SERVER_URL = "http://vlibras.lavid.ufpb.br/glosa?texto=";//old
	private const string SERVER_URL = "http://traducao.vlibras.gov.br/translate?text=";
	private const int VERSION = 1;

    public enum ERROR_STATUS_MESSAGE
    {
        INTERNET_CONNECTION_FAILURE,
        TRANSLATOR_CONNECTION_FAILURE,
        CONNECTION_TIMEOUT_FAILURE
    }

	private string[] randomAnimationNames = new string[] {
		"[RELAXAR]",
		"[BOCEJAR]",
		"[COCHILAR]",
		"[ESPREGUI_ADA]"
	};

    protected VoiceRecognition voiceRecognizer;
	public InputField translateScreenText;
	public ScreenManager screenManager;
	private string dictWord = null;
	private string regionPath = "";
    private int regionHash = 1;

    public static string get_connection_status_message(ERROR_STATUS_MESSAGE msg)
    {
        switch(msg)
        {
            case ERROR_STATUS_MESSAGE.TRANSLATOR_CONNECTION_FAILURE:
                return "Problema na conexão. Usaremos português sinalizado e datilologia.";
            case ERROR_STATUS_MESSAGE.INTERNET_CONNECTION_FAILURE:
                return "Não há acesso à internet. Usaremos português sinalizado e datilologia.";
            case ERROR_STATUS_MESSAGE.CONNECTION_TIMEOUT_FAILURE:
                return "Não há acesso à internet. Usaremos português sinalizado e datilologia.";
                //return "A conexão está lenta. Usaremos português sinalizado e datilologia.";
            default:
                return "Ocorreu um erro. Estamos trabalhando para solucioná-lo!";
        }

    }

	public override void Start()
	{
		base.setRandomAnimations(randomAnimationNames);
		base.Start();
		
		voiceRecognizer = new VoiceRecognition();

#if UNITY_EDITOR
        Caching.CleanCache();
#endif

        Screen.fullScreen = false;
		// Hide input text preview
		// TouchScreenKeyboard.hideInput = true;
	}

	public void playDict(string word)
	{
        PlayerLogger.Log("Requesting dictionary: " + word);

		this.dictWord = word;
		base.gloss = word;
		base.playNow(word);

		this.screenManager.hideScreen();
		this.screenManager.setPauseMenuState(false);
	}

	public void playTranslate()
	{
		stopTranslation();

		string text = translateScreenText.text;
		translateScreenText.text = "";

		StartCoroutine("translate", text);

		this.screenManager.setPauseMenuState(false);
	}

	public void stopTranslation()
	{
		StopCoroutine("translate");
		this.randomAnimations.unlockFor("translate");
	}

	public void catchTranslationError()
	{
		this.randomAnimations.unlockFor("translate");
		base.repeat();
	}

	public void setRegion(string path)
    {
		this.regionPath = String.IsNullOrEmpty(path) ? "" : path;
        this.regionHash = this.regionPath == "" ? 1 : (int)this.regionPath[0] * 255 + (int)this.regionPath[1];
    }

	public void clearRegion() {
		setRegion("");
	}

	protected override WWW loadAssetBundle(string aniName)
	{
        string address = BASE_URL + regionPath + WWW.EscapeURL(aniName);
        
        PlayerLogger.Log("PM", "lAB", "Requesting bundle: " + address);
		return WWW.LoadFromCacheOrDownload(address, this.regionHash);
	}

	private System.Object LOCKER_STATE = new System.Object();

    public override void onPlayingStateChange()
	{
		lock (LOCKER_STATE) {
			this.screenManager.changeStates(base.isPlaying(), base.isPaused(), ! String.IsNullOrEmpty(base.gloss));
		}
	}

    public override void onConnectionError(string gloss, string word)
	{
		if (gloss.Equals(this.dictWord))
		{
            this.dictWord = "";
            this.screenManager.showConnectionErrorDialog(
                PlayerManager.ERROR_STATUS_MESSAGE.INTERNET_CONNECTION_FAILURE);

			base.stopAll();
		}
	}

	// Called from microphone icon at main interface
	public void callVoiceRecognizer()
	{
		PlayerLogger.Log("Requesting voice recognizer");
		
		string gloss = voiceRecognizer.callRecognition();
		this.translateScreenText.text = gloss;
		PlayerLogger.Log("Voice recognizer answer: " + gloss);

		this.screenManager.switchScreen("translate");
	}
	


    protected override WWW getCheckConnectionRequest()
    {
        return new WWW(BASE_URL);


        /*WWW connection = new WWW(SERVER_URL);
        yield return connection;
        //while (!glossRequest.isDone)

        if (connection.error == null)
        {
            if (connection.responseHeaders.Count > 0)
                PlayerLogger.Log(connection.responseHeaders["STATUS"]);
            else
                PlayerLogger.Log("No STATUS");
        }
        else PlayerLogger.Log("ERROR: " + connection.error);

        return false;*/


        /*HttpWebRequest request = (HttpWebRequest)WebRequest.Create(BASE_URL);
        request.Method = "HEAD";
        request.Timeout = 2000;

        try {
            HttpWebResponse response = (HttpWebResponse) request.GetResponse();
        }
        catch (WebException e)
        {
            if (e.Response != null)
            {
                PlayerLogger.Log(((HttpWebResponse)e.Response).StatusCode);
                return ((HttpWebResponse)e.Response).StatusCode == HttpStatusCode.NotFound;
            }
        }
        catch (Exception)
        {
        }

        return false;*/
    }

    protected override IEnumerator WaitForResponse(WWW www)
    {
        PlayerLogger.Log("PM", "WFR", "Stating time check.");

#if UNITY_ANDROID
        const float timeoutLimit = 10f;
#elif UNITY_IOS
        const float timeoutLimit = 3f;
#endif
        
        float timer = 0;
        
        while ( ! www.isDone)
        {
            if (timer > timeoutLimit)
            {
                PlayerLogger.Log("PM", "WFR", "Timeout.");
                yield break;
            }

#if UNITY_ANDROID
            timer += Time.deltaTime;
            yield return null;
#elif UNITY_IOS
            timer += 0.1f;
            yield return new WaitForSeconds(0.1f);
#endif
        }

        PlayerLogger.Log("PM", "WFR", "Done.");
    }

	private IEnumerator translate(string gloss)
	{
		base.randomAnimations.lockFor("translate");
		this.screenManager.setLoadingSnippetState(true);

		WWW glossRequest = new WWW(SERVER_URL + WWW.EscapeURL(gloss));

        PlayerLogger.Log("PM", "t", "Gloss: " + gloss);
        PlayerLogger.Log("PM", "t", "Request: " + SERVER_URL + WWW.EscapeURL(gloss));
        
        yield return WaitForResponse(glossRequest);

        try {
            if ( ! glossRequest.isDone)
            {
                this.screenManager.showConnectionErrorDialog(
                    PlayerManager.ERROR_STATUS_MESSAGE.CONNECTION_TIMEOUT_FAILURE);

                PlayerLogger.Log("PM", "t", "Timeout.");
            }
            else if (glossRequest.error != null)
            {
                this.screenManager.showConnectionErrorDialog(
                    PlayerManager.ERROR_STATUS_MESSAGE.INTERNET_CONNECTION_FAILURE);

                PlayerLogger.Log("PM", "t", "(WWW) Error: " + glossRequest.error);
            }
            else if (glossRequest.responseHeaders.Count == 0 || !glossRequest.responseHeaders["STATUS"].EndsWith("200 OK"))
            {
                PlayerLogger.Log("PM", "t", "Unsuccessful answer.");

                this.screenManager.showConnectionErrorDialog(
                    PlayerManager.ERROR_STATUS_MESSAGE.TRANSLATOR_CONNECTION_FAILURE);
            }
            else if (String.IsNullOrEmpty(glossRequest.text))
            {
                PlayerLogger.Log("PM", "t", "Empty answer.");
            }
            else
            {
                PlayerLogger.Log("PM", "t", "Answer: " + glossRequest.text);

                gloss = glossRequest.text;

                base.gloss = gloss;
                base.playNow(base.gloss);

                yield break;
            }

            base.gloss = gloss.ToUpper();
        }
        finally
        {
            this.screenManager.setLoadingSnippetState(false);
            base.randomAnimations.unlockFor("translate");
        }
    }

}