package com.metaio.cloud.plugin.data;

import android.content.Context;
import android.os.AsyncTask;
import android.os.AsyncTask.Status;
import com.metaio.cloud.plugin.MetaioCloudPlugin;
import com.metaio.cloud.plugin.MetaioCloudPlugin.Settings;
import com.metaio.cloud.plugin.util.MetaioCloudUtils;
import com.metaio.sdk.jni.ASWorldReturnCode;
import com.metaio.sdk.jni.AS_MetaioWorldRequestCommand;
import com.metaio.sdk.jni.IARELObject;
import com.metaio.sdk.jni.JunaioDataSource;
import com.metaio.sdk.jni.MetaioWorldClientCURL;
import com.metaio.sdk.jni.MetaioWorldRequest;
import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.sql.Date;
import java.util.ArrayList;
import java.util.Locale;
import org.apache.http.impl.cookie.DateUtils;

public class MetaioCloudDataManager
{
  public static String BILLBOARD_CACHE_DIR;
  private static MetaioCloudDataManager instance;
  private boolean isUpdatingPOIs;
  private Callback mCallback;
  private MetaioWorldClientTask mCurrentTask;
  private int mLastNetworkError;
  private String mPassword;
  private ArrayList<MetaioWorldRequest> mRequests;
  private IARELObject mSelectedPOI;
  private String mUsername;

  private MetaioCloudDataManager()
  {
    String str = MetaioCloudUtils.getUDID();
    if (str == null)
      str = "0123456789";
    MetaioCloudPlugin.log("JunaioDataManager: setting UDID: " + str);
    MetaioCloudPlugin.getDataSource().getJunaioClient().setUDID(str);
    initialize();
    MetaioCloudPlugin.log("JunaioDataManager: setting UserAgent: " + MetaioCloudUtils.getUserAgentString());
    MetaioCloudPlugin.getDataSource().getJunaioClient().setUserAgent(MetaioCloudUtils.getUserAgentString());
    if (MetaioCloudPlugin.mCookiesFile != null)
      MetaioCloudPlugin.getDataSource().getJunaioClient().setCookiesFile(MetaioCloudPlugin.mCookiesFile);
    this.mUsername = "";
    this.mPassword = "";
    this.mCurrentTask = null;
    this.mRequests = new ArrayList();
    this.mCallback = null;
    this.isUpdatingPOIs = false;
    this.mSelectedPOI = null;
  }

  private void executeNextRequest()
  {
    if (this.mRequests.size() > 0)
    {
      MetaioCloudPlugin.log("JunaioDataManager: executing next request..." + ((MetaioWorldRequest)this.mRequests.get(0)).getCommand());
      this.mCurrentTask = new MetaioWorldClientTask(null);
      MetaioWorldClientTask localMetaioWorldClientTask = this.mCurrentTask;
      MetaioWorldRequest[] arrayOfMetaioWorldRequest = new MetaioWorldRequest[1];
      arrayOfMetaioWorldRequest[0] = ((MetaioWorldRequest)this.mRequests.remove(0));
      localMetaioWorldClientTask.execute(arrayOfMetaioWorldRequest);
      MetaioCloudPlugin.log("JunaioDataManager: remaining requests: " + this.mRequests.size());
    }
  }

  public static MetaioCloudDataManager getDataManager()
  {
    if (instance == null);
    try
    {
      if (instance == null)
        instance = new MetaioCloudDataManager();
      return instance;
    }
    finally
    {
    }
  }

  private static String md5(String paramString)
  {
    StringBuilder localStringBuilder;
    try
    {
      byte[] arrayOfByte = MessageDigest.getInstance("MD5").digest(paramString.getBytes("UTF-8"));
      localStringBuilder = new StringBuilder(2 * arrayOfByte.length);
      int i = arrayOfByte.length;
      for (int j = 0; j < i; j++)
      {
        int k = 0xFF & arrayOfByte[j];
        if (k < 16)
          localStringBuilder.append('0');
        localStringBuilder.append(Integer.toHexString(k));
      }
    }
    catch (NoSuchAlgorithmException localNoSuchAlgorithmException)
    {
      throw new RuntimeException("Huh, MD5 should be supported?", localNoSuchAlgorithmException);
    }
    catch (UnsupportedEncodingException localUnsupportedEncodingException)
    {
      throw new RuntimeException("Huh, UTF-8 should be supported?", localUnsupportedEncodingException);
    }
    return localStringBuilder.toString();
  }

  private void processRequest(MetaioWorldRequest paramMetaioWorldRequest)
  {
    if (this.mCallback != null)
    {
      this.mCallback.onRequestCompleted(paramMetaioWorldRequest, this.mLastNetworkError);
      return;
    }
    MetaioCloudPlugin.log(5, "JunaioDataManager.onPostExecute: callback is null");
    paramMetaioWorldRequest.delete();
  }

  public void addRequest(MetaioWorldRequest paramMetaioWorldRequest)
  {
    try
    {
      if (paramMetaioWorldRequest.getTimeout() == 0)
        paramMetaioWorldRequest.setTimeout(60000);
      if ((this.mCurrentTask != null) && (this.mCurrentTask.getStatus() != AsyncTask.Status.FINISHED))
      {
        boolean bool = this.mRequests.add(paramMetaioWorldRequest);
        MetaioCloudPlugin.log("JunaioDataManager.addRequest: request queued: " + bool + ", total requests: " + this.mRequests.size() + " request command: " + paramMetaioWorldRequest.getCommand());
      }
      while (true)
      {
        return;
        MetaioCloudPlugin.log("JunaioDataManager.addRequest: executing request..." + paramMetaioWorldRequest.getCommand());
        this.mCurrentTask = new MetaioWorldClientTask(null);
        this.mCurrentTask.execute(new MetaioWorldRequest[] { paramMetaioWorldRequest });
      }
    }
    finally
    {
    }
  }

  public void cancelAllRequests()
  {
    this.mRequests.clear();
    if (this.mCurrentTask != null)
    {
      this.mCurrentTask.cancel();
      this.mCurrentTask = null;
    }
  }

  public void cancelCurrentRequest()
  {
    if (this.mCurrentTask != null)
    {
      MetaioCloudPlugin.log("JunaioDataManager.cancelCurrentRequest...");
      this.mCurrentTask.cancel();
      this.mCurrentTask = null;
    }
  }

  public void cancelRequest(MetaioWorldRequest paramMetaioWorldRequest)
  {
    if (!this.mRequests.remove(paramMetaioWorldRequest))
    {
      this.mCurrentTask.cancel();
      this.mCurrentTask = null;
    }
    while (this.mCallback == null)
      return;
    this.mCallback.onRequestCancelled(paramMetaioWorldRequest);
  }

  public String getLastNetworkErrorMessage(Context paramContext)
  {
    String str;
    if ((this.mLastNetworkError == ASWorldReturnCode.AS_WORLD_API_FORBIDDEN.swigValue()) || (this.mLastNetworkError == ASWorldReturnCode.AS_WORLD_API_NOTFOUND.swigValue()) || (this.mLastNetworkError == ASWorldReturnCode.AS_WORLD_API_UNAUTHORIZED.swigValue()))
      str = MetaioCloudPlugin.getResourceString(paramContext.getApplicationContext(), "MSGE_UNAUTHORIZED_ACCESS");
    while (true)
    {
      if (MetaioCloudPlugin.Settings.enableErrorLog)
        str = str + " (" + this.mLastNetworkError + ")";
      return str;
      if (this.mLastNetworkError == ASWorldReturnCode.AS_WORLD_API_INTERNALSERVERERROR.swigValue())
      {
        str = MetaioCloudPlugin.getResourceString(paramContext.getApplicationContext(), "MSGE_INTERNAL_SERVER");
      }
      else
      {
        int i = this.mLastNetworkError;
        int j = ASWorldReturnCode.AS_WORLD_API_XMLPARSINGERROR.swigValue();
        str = null;
        if (i != j)
          if (this.mLastNetworkError == ASWorldReturnCode.AS_WORLD_API_TIMEOUT.swigValue())
            str = MetaioCloudPlugin.getResourceString(paramContext.getApplicationContext(), "MSGE_TIMEOUT");
          else if (this.mLastNetworkError >= ASWorldReturnCode.AS_WORLD_API_CURLERROR.swigValue())
            str = MetaioCloudPlugin.getResourceString(paramContext.getApplicationContext(), "MSGE_NO_INTERNET");
          else
            str = MetaioCloudPlugin.getResourceString(paramContext.getApplicationContext(), "MSGE_NETWORK");
      }
    }
  }

  public String getPassword()
  {
    return this.mPassword;
  }

  public IARELObject getSelectedPOI()
  {
    return this.mSelectedPOI;
  }

  public String getUsername()
  {
    return this.mUsername;
  }

  public void initialize()
  {
    String str1 = Locale.getDefault().getLanguage() + "-" + Locale.getDefault().getCountry();
    MetaioCloudPlugin.log("Accept-Language: " + str1);
    MetaioCloudPlugin.getDataSource().getJunaioClient().setLanguage(str1);
    String str2 = DateUtils.formatDate(new Date(System.currentTimeMillis()));
    MetaioCloudPlugin.getDataSource().getJunaioClient().setDate(str2);
    BILLBOARD_CACHE_DIR = MetaioCloudPlugin.mCacheDir + "/" + "billboards";
    MetaioCloudPlugin.log("BILLBOARD_CACHE_DIR: " + BILLBOARD_CACHE_DIR);
  }

  public boolean isEditorUser()
  {
    return isLoggedin("metaio");
  }

  public boolean isGuestUser()
  {
    return isLoggedin("junaioclient@metaio.com");
  }

  public boolean isLoggedin(String paramString)
  {
    try
    {
      int i = this.mUsername.compareTo(paramString);
      if (i == 0)
        return true;
    }
    catch (Exception localException)
    {
    }
    return false;
  }

  public boolean isUpdatingPOIs()
  {
    try
    {
      boolean bool = this.isUpdatingPOIs;
      return bool;
    }
    finally
    {
      localObject = finally;
      throw localObject;
    }
  }

  public void registerCallback(Callback paramCallback)
  {
    if (paramCallback != null)
    {
      MetaioCloudPlugin.log("registerCallback " + paramCallback.getClass().getCanonicalName());
      this.mCallback = paramCallback;
      if (this.mCallback != null)
        break label55;
    }
    label55: 
    while (this.mCurrentTask != null)
    {
      return;
      MetaioCloudPlugin.log("registerCallback null");
      break;
    }
    executeNextRequest();
  }

  public void selectPOI(IARELObject paramIARELObject)
  {
    if ((this.mSelectedPOI != null) && (MetaioCloudPlugin.getDataSource().getPOIForID(paramIARELObject.getID()) != null))
      this.mSelectedPOI.delete();
    this.mSelectedPOI = paramIARELObject.clone();
  }

  public void setClientAuthentication(String paramString1, String paramString2, boolean paramBoolean)
  {
    this.mUsername = paramString1.toLowerCase();
    String str = md5(this.mUsername);
    if (paramBoolean);
    for (this.mPassword = paramString2; ; this.mPassword = md5(paramString2))
    {
      MetaioCloudPlugin.getDataSource().setAuthentication(str, this.mPassword);
      return;
    }
  }

  public static abstract interface Callback
  {
    public abstract void onRequestCancelled(MetaioWorldRequest paramMetaioWorldRequest);

    public abstract void onRequestCompleted(MetaioWorldRequest paramMetaioWorldRequest, int paramInt);

    public abstract void onRequestStarted();
  }

  private class MetaioWorldClientTask extends AsyncTask<MetaioWorldRequest, Integer, MetaioWorldRequest>
  {
    private MetaioWorldClientTask()
    {
    }

    public void cancel()
    {
      cancel(true);
    }

    protected MetaioWorldRequest doInBackground(MetaioWorldRequest[] paramArrayOfMetaioWorldRequest)
    {
      synchronized (MetaioCloudDataManager.this)
      {
        if ((paramArrayOfMetaioWorldRequest[0].getCommand() == AS_MetaioWorldRequestCommand.AS_MetaioWorldRequestType_POI_SEARCH) || (paramArrayOfMetaioWorldRequest[0].getCommand() == AS_MetaioWorldRequestCommand.AS_MetaioWorldRequestType_POI_VISUAL_SEARCH) || (paramArrayOfMetaioWorldRequest[0].getCommand() == AS_MetaioWorldRequestCommand.AS_MetaioWorldRequestType_POI_EVENT))
        {
          MetaioCloudDataManager.access$202(MetaioCloudDataManager.this, true);
          MetaioCloudPlugin.log("Performing request: " + paramArrayOfMetaioWorldRequest[0].getCommand());
          MetaioCloudDataManager.access$302(MetaioCloudDataManager.this, MetaioCloudPlugin.getDataSource().getJunaioClient().performRequest(paramArrayOfMetaioWorldRequest[0]));
          MetaioCloudPlugin.log("Request performed: " + MetaioCloudDataManager.this.mLastNetworkError);
          return paramArrayOfMetaioWorldRequest[0];
        }
        MetaioCloudDataManager.access$202(MetaioCloudDataManager.this, false);
      }
    }

    protected void onCancelled(MetaioWorldRequest paramMetaioWorldRequest)
    {
      while (true)
      {
        synchronized (MetaioCloudDataManager.this)
        {
          MetaioCloudDataManager.access$202(MetaioCloudDataManager.this, false);
          MetaioCloudPlugin.log("MetaioWorldClientTask.onCancelled...");
          if (MetaioCloudDataManager.this.mCallback != null)
          {
            MetaioCloudDataManager.this.mCallback.onRequestCancelled(paramMetaioWorldRequest);
            MetaioCloudDataManager.access$502(MetaioCloudDataManager.this, null);
            MetaioCloudDataManager.this.executeNextRequest();
            return;
          }
        }
        MetaioCloudPlugin.log(5, "JunaioDataManager.onCancelled: callback is null");
        if (paramMetaioWorldRequest != null)
          paramMetaioWorldRequest.delete();
      }
    }

    protected void onPostExecute(MetaioWorldRequest paramMetaioWorldRequest)
    {
      MetaioCloudPlugin.log("MetaioWorldClientTask.onPostExecute...");
      synchronized (MetaioCloudDataManager.this)
      {
        MetaioCloudDataManager.access$202(MetaioCloudDataManager.this, false);
        MetaioCloudDataManager.this.processRequest(paramMetaioWorldRequest);
        MetaioCloudDataManager.access$502(MetaioCloudDataManager.this, null);
        MetaioCloudDataManager.this.executeNextRequest();
        return;
      }
    }

    protected void onPreExecute()
    {
      if (MetaioCloudDataManager.this.mCallback != null)
        MetaioCloudDataManager.this.mCallback.onRequestStarted();
    }

    protected void onProgressUpdate(Integer[] paramArrayOfInteger)
    {
    }
  }
}

/* Location:           C:\Documents and Settings\Cesar Cabello Cea\Mis documentos\Downloads\apk-downloader\com.ikea.kompis-6_dex2jar.jar
 * Qualified Name:     com.metaio.cloud.plugin.data.MetaioCloudDataManager
 * JD-Core Version:    0.6.2
 */