package com.worklight.wlclient;

import android.content.Context;
import android.content.Intent;
import com.worklight.common.Logger;
import com.worklight.common.WLConfig;
import com.worklight.nativeandroid.common.WLUtils;
import com.worklight.wlclient.api.WLClient;
import com.worklight.wlclient.api.WLErrorCode;
import com.worklight.wlclient.api.WLFailResponse;
import com.worklight.wlclient.api.WLRequestOptions;
import com.worklight.wlclient.api.WLResponse;
import com.worklight.wlclient.api.challengehandler.ChallengeHandler;
import com.worklight.wlclient.api.challengehandler.WLChallengeHandler;
import com.worklight.wlclient.ui.UIActivity;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.zip.GZIPOutputStream;
import org.apache.http.Header;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.message.BasicNameValuePair;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

public class WLRequest
{
  private static final String ACCESS_DENIED_ID = "WLClient.accessDenied";
  private static final String AUTH_FAIL_ID = "WLClient.authFailure";
  private static final String CLOSE_BUTTON_ID = "WLClient.close";
  private static final String ERROR_ID = "WLClient.error";
  private static final Set<WLRequestPiggybacker> PIGGYBACKERS = Collections.synchronizedSet(new HashSet());
  private static final String RESOURCE_BUNDLE = "com/worklight/wlclient/messages";
  private static Logger logger = Logger.getInstance(WLRequest.class.getName());
  private WLConfig config;
  private Context context;
  private HttpPost postRequest;
  private WLRequestListener requestListener;
  protected WLRequestOptions requestOptions;
  private String requestURL = null;
  private HashMap<String, Object> wlAnswers = new HashMap();

  public WLRequest(WLRequestListener paramWLRequestListener, WLRequestOptions paramWLRequestOptions, WLConfig paramWLConfig, Context paramContext)
  {
    this.requestListener = paramWLRequestListener;
    this.requestOptions = paramWLRequestOptions;
    this.config = paramWLConfig;
    this.context = paramContext;
  }

  private void addExpectedAnswers(HttpPost paramHttpPost)
  {
    if (this.wlAnswers.isEmpty())
      return;
    JSONObject localJSONObject = new JSONObject();
    Iterator localIterator = this.wlAnswers.entrySet().iterator();
    while (true)
      if (localIterator.hasNext())
      {
        Map.Entry localEntry = (Map.Entry)localIterator.next();
        String str = (String)localEntry.getKey();
        Object localObject = localEntry.getValue();
        if (localObject == null)
          break;
        try
        {
          localJSONObject.accumulate(str, localObject);
        }
        catch (JSONException localJSONException)
        {
          logger.error(localJSONException.getMessage(), localJSONException);
          throw new RuntimeException(localJSONException);
        }
      }
    paramHttpPost.addHeader("Authorization", localJSONObject.toString());
    this.wlAnswers.clear();
  }

  private void addExtraHeaders(HttpPost paramHttpPost)
  {
    ArrayList localArrayList = this.requestOptions.getHeaders();
    if (localArrayList == null);
    while (true)
    {
      return;
      Iterator localIterator = localArrayList.iterator();
      while (localIterator.hasNext())
        paramHttpPost.addHeader((Header)localIterator.next());
    }
  }

  private void addHeaders(WLConfig paramWLConfig, HttpPost paramHttpPost)
  {
    paramHttpPost.addHeader("X-Requested-With", "XMLHttpRequest");
    paramHttpPost.addHeader("x-wl-app-version", paramWLConfig.getApplicationVersion());
    paramHttpPost.addHeader("Accept-Language", Locale.getDefault().toString());
    paramHttpPost.addHeader("x-wl-platform-version", paramWLConfig.getPlatformVersion());
  }

  private void addParams(WLRequestOptions paramWLRequestOptions, HttpPost paramHttpPost)
  {
    ArrayList localArrayList = new ArrayList();
    if ((paramWLRequestOptions.getParameters() != null) && (!paramWLRequestOptions.getParameters().isEmpty()))
    {
      Iterator localIterator2 = paramWLRequestOptions.getParameters().keySet().iterator();
      while (localIterator2.hasNext())
      {
        String str = (String)localIterator2.next();
        localArrayList.add(new BasicNameValuePair(str, (String)paramWLRequestOptions.getParameters().get(str)));
      }
    }
    localArrayList.add(new BasicNameValuePair("isAjaxRequest", "true"));
    localArrayList.add(new BasicNameValuePair("x", String.valueOf(Math.random())));
    UrlEncodedFormEntity localUrlEncodedFormEntity;
    JSONObject localJSONObject;
    try
    {
      localUrlEncodedFormEntity = new UrlEncodedFormEntity(localArrayList, "UTF-8");
      if (!paramHttpPost.getURI().getPath().endsWith("apps/services/loguploader"))
        break label406;
      paramHttpPost.setHeader("x-wl-compressed", "true");
      paramHttpPost.setHeader("Content-Encoding", "gzip");
      paramHttpPost.setHeader("Content-Type", "application/json");
      localJSONObject = new JSONObject();
      Iterator localIterator1 = localArrayList.iterator();
      while (true)
        if (localIterator1.hasNext())
        {
          NameValuePair localNameValuePair = (NameValuePair)localIterator1.next();
          try
          {
            localJSONObject.put(localNameValuePair.getName(), localNameValuePair.getValue());
          }
          catch (JSONException localJSONException)
          {
            throw new RuntimeException(localJSONException);
          }
        }
    }
    catch (UnsupportedEncodingException localUnsupportedEncodingException2)
    {
      logger.error(localUnsupportedEncodingException2.getMessage(), localUnsupportedEncodingException2);
      throw new RuntimeException(localUnsupportedEncodingException2);
    }
    ByteArrayOutputStream localByteArrayOutputStream = new ByteArrayOutputStream();
    try
    {
      GZIPOutputStream localGZIPOutputStream = new GZIPOutputStream(localByteArrayOutputStream);
      localGZIPOutputStream.write(localJSONObject.toString().getBytes("UTF-8"));
      localGZIPOutputStream.finish();
      localGZIPOutputStream.close();
      paramHttpPost.setEntity(new ByteArrayEntity(localByteArrayOutputStream.toByteArray()));
      return;
    }
    catch (UnsupportedEncodingException localUnsupportedEncodingException1)
    {
      logger.error(localUnsupportedEncodingException1.getMessage(), localUnsupportedEncodingException1);
      throw new RuntimeException(localUnsupportedEncodingException1);
    }
    catch (IOException localIOException)
    {
      logger.error(localIOException.getMessage(), localIOException);
      throw new RuntimeException(localIOException);
    }
    label406: paramHttpPost.setEntity(localUrlEncodedFormEntity);
  }

  public static void addRequestPiggybacker(WLRequestPiggybacker paramWLRequestPiggybacker)
  {
    PIGGYBACKERS.add(paramWLRequestPiggybacker);
  }

  private boolean checkResponseForChallenges(WLResponse paramWLResponse)
  {
    ResourceBundle localResourceBundle = WLUtils.getMessagesBundle();
    if (isWl401(paramWLResponse))
    {
      JSONObject localJSONObject4 = paramWLResponse.getResponseJSON();
      ArrayList localArrayList = new ArrayList();
      while (true)
      {
        JSONObject localJSONObject6;
        WLChallengeHandler localWLChallengeHandler2;
        try
        {
          JSONObject localJSONObject5 = localJSONObject4.getJSONObject("challenges");
          JSONArray localJSONArray2 = localJSONObject5.names();
          int j = 0;
          if (j < localJSONArray2.length())
          {
            localArrayList.add(localJSONArray2.getString(j));
            j++;
            continue;
          }
          setExpectedAnswers(localArrayList);
          Iterator localIterator = localArrayList.iterator();
          if (localIterator.hasNext())
          {
            String str3 = (String)localIterator.next();
            localJSONObject6 = localJSONObject5.getJSONObject(str3);
            localWLChallengeHandler2 = WLClient.getInstance().getWLChallengeHandler(str3);
            if (localWLChallengeHandler2 != null)
              break label233;
            logger.error("Application will exit, because unexpected challenge handler arrived while using realm " + str3 + ". Register the challenge handler using registerChallengeHandler().");
            showErrorDialogue(localResourceBundle.getString("WLClient.error"), localResourceBundle.getString("WLClient.authFailure"), localResourceBundle.getString("WLClient.close"));
            continue;
          }
        }
        catch (JSONException localJSONException2)
        {
          logger.debug("Wrong JSON arrived when processing a challenge in a 401 response. With " + localJSONException2.getMessage(), localJSONException2);
        }
        return true;
        label233: localWLChallengeHandler2.startHandleChallenge(this, localJSONObject6);
      }
    }
    JSONObject localJSONObject1;
    if (isWl403(paramWLResponse))
      localJSONObject1 = paramWLResponse.getResponseJSON();
    while (true)
    {
      int i;
      try
      {
        JSONObject localJSONObject2 = localJSONObject1.getJSONObject("WL-Authentication-Failure");
        JSONArray localJSONArray1 = localJSONObject2.names();
        i = 0;
        if (i < localJSONArray1.length())
        {
          String str1 = localJSONArray1.getString(i);
          JSONObject localJSONObject3 = localJSONObject2.getJSONObject(str1);
          WLChallengeHandler localWLChallengeHandler1 = WLClient.getInstance().getWLChallengeHandler(str1);
          if (localWLChallengeHandler1 != null)
          {
            localWLChallengeHandler1.handleFailure(localJSONObject3);
            localWLChallengeHandler1.clearWaitingList();
          }
          else
          {
            StringBuilder localStringBuilder = new StringBuilder(localResourceBundle.getString("WLClient.accessDenied"));
            String str2 = localResourceBundle.getString("WLClient.missingHandler");
            if (str2 != null)
              localStringBuilder.append("\n" + localResourceBundle.getString("WLClient.reason") + ":" + str2 + " - " + str1);
            logger.error("Connect to Worklight server failed due to missing challenge handler to handle " + str1);
            showErrorDialogue(localResourceBundle.getString("WLClient.error"), localStringBuilder.toString(), localResourceBundle.getString("WLClient.close"));
          }
        }
      }
      catch (JSONException localJSONException1)
      {
        logger.debug("Wrong JSON arrived when processing a challenge in a 403 response. with " + localJSONException1.getMessage(), localJSONException1);
      }
      return true;
      return handleCustomChallenges(paramWLResponse);
      i++;
    }
  }

  private void checkResponseForSuccesses(WLResponse paramWLResponse)
  {
    JSONObject localJSONObject1 = paramWLResponse.getResponseJSON();
    if (localJSONObject1 == null);
    while (true)
    {
      return;
      try
      {
        if (localJSONObject1.has("WL-Authentication-Success"))
        {
          JSONObject localJSONObject2 = localJSONObject1.getJSONObject("WL-Authentication-Success");
          if (localJSONObject2 != null)
          {
            JSONArray localJSONArray = localJSONObject2.names();
            for (int i = 0; i < localJSONObject2.length(); i++)
            {
              String str = localJSONArray.getString(i);
              JSONObject localJSONObject3 = localJSONObject2.getJSONObject(str);
              WLChallengeHandler localWLChallengeHandler = WLClient.getInstance().getWLChallengeHandler(str);
              if (localWLChallengeHandler != null)
              {
                localWLChallengeHandler.handleSuccess(localJSONObject3);
                localWLChallengeHandler.releaseWaitingList();
              }
            }
          }
        }
      }
      catch (Exception localException)
      {
        triggerUnexpectedOnFailure(localException);
      }
    }
  }

  private boolean handleCustomChallenges(WLResponse paramWLResponse)
  {
    ChallengeHandler localChallengeHandler = WLClient.getInstance().getChallengeHandler(paramWLResponse);
    boolean bool = false;
    if (localChallengeHandler != null)
    {
      localChallengeHandler.startHandleChallenge(this, paramWLResponse);
      bool = true;
    }
    return bool;
  }

  private boolean isWl401(WLResponse paramWLResponse)
  {
    if (paramWLResponse.getStatus() == 401)
    {
      Header localHeader = paramWLResponse.getHeader("WWW-Authenticate");
      if ((localHeader != null) && (localHeader.getValue().equalsIgnoreCase("WL-Composite-Challenge")))
        return true;
    }
    return false;
  }

  private boolean isWl403(WLResponse paramWLResponse)
  {
    try
    {
      int i = paramWLResponse.getStatus();
      boolean bool = false;
      if (i == 403)
      {
        JSONObject localJSONObject = paramWLResponse.getResponseJSON();
        bool = false;
        if (localJSONObject != null)
        {
          Object localObject = paramWLResponse.getResponseJSON().get("WL-Authentication-Failure");
          bool = false;
          if (localObject != null)
            bool = true;
        }
      }
      return bool;
    }
    catch (JSONException localJSONException)
    {
      logger.error(localJSONException.getMessage(), localJSONException);
    }
    return false;
  }

  private void processFailureResponse(WLResponse paramWLResponse)
  {
    WLFailResponse localWLFailResponse = new WLFailResponse(paramWLResponse);
    localWLFailResponse.setOptions(this.requestOptions);
    synchronized (PIGGYBACKERS)
    {
      Iterator localIterator = PIGGYBACKERS.iterator();
      if (localIterator.hasNext())
        ((WLRequestPiggybacker)localIterator.next()).onFailure(localWLFailResponse);
    }
    this.requestListener.onFailure(localWLFailResponse);
  }

  private void processSuccessResponse(WLResponse paramWLResponse)
  {
    synchronized (PIGGYBACKERS)
    {
      Iterator localIterator = PIGGYBACKERS.iterator();
      if (localIterator.hasNext())
        ((WLRequestPiggybacker)localIterator.next()).onSuccess(paramWLResponse);
    }
    this.requestListener.onSuccess(paramWLResponse);
  }

  public static void removeRequestPiggybacker(WLRequestPiggybacker paramWLRequestPiggybacker)
  {
    PIGGYBACKERS.remove(paramWLRequestPiggybacker);
  }

  private void resendIfNeeded()
  {
    int i = 1;
    if (this.wlAnswers == null)
      i = 1;
    while (true)
    {
      if (i != 0)
        resendRequest();
      return;
      Iterator localIterator = this.wlAnswers.values().iterator();
      if (localIterator.hasNext())
      {
        if (localIterator.next() != null)
          break;
        i = 0;
      }
    }
  }

  private void resendRequest()
  {
    if (this.requestURL != null)
    {
      sendRequest(this.requestURL);
      return;
    }
    logger.debug("resendRequest failed: requestURL is null.");
  }

  private void sendRequest(String paramString)
  {
    this.postRequest = new HttpPost(paramString);
    addHeaders(this.config, this.postRequest);
    addExtraHeaders(this.postRequest);
    addParams(this.requestOptions, this.postRequest);
    addExpectedAnswers(this.postRequest);
    try
    {
      AsynchronousRequestSender.getInstance().sendWLRequestAsync(this);
      return;
    }
    catch (Exception localException)
    {
      logger.error(localException.getMessage(), localException);
      triggerUnexpectedOnFailure(localException);
    }
  }

  private void setExpectedAnswers(List<String> paramList)
  {
    Iterator localIterator = paramList.iterator();
    while (localIterator.hasNext())
    {
      String str = (String)localIterator.next();
      this.wlAnswers.put(str, null);
    }
  }

  private void showErrorDialogue(String paramString1, String paramString2, String paramString3)
  {
    Context localContext = WLClient.getInstance().getContext();
    Intent localIntent = new Intent(localContext, UIActivity.class);
    localIntent.putExtra("action", "exit");
    localIntent.putExtra("dialogue_message", paramString2);
    localIntent.putExtra("dialogue_title", paramString1);
    localIntent.putExtra("positive_button_text", paramString3);
    localContext.startActivity(localIntent);
  }

  private void triggerUnexpectedOnFailure(Exception paramException)
  {
    getRequestListener().onFailure(new WLFailResponse(WLErrorCode.UNEXPECTED_ERROR, paramException.getMessage(), getOptions()));
  }

  public WLConfig getConfig()
  {
    return this.config;
  }

  public Context getContext()
  {
    return this.context;
  }

  public WLRequestOptions getOptions()
  {
    return this.requestOptions;
  }

  public HttpPost getPostRequest()
  {
    return this.postRequest;
  }

  public WLRequestListener getRequestListener()
  {
    return this.requestListener;
  }

  public void makeRequest(String paramString)
  {
    makeRequest(paramString, false);
  }

  public void makeRequest(String paramString, boolean paramBoolean)
  {
    synchronized (PIGGYBACKERS)
    {
      Iterator localIterator = PIGGYBACKERS.iterator();
      if (localIterator.hasNext())
        ((WLRequestPiggybacker)localIterator.next()).processOptions(paramString, this.requestOptions);
    }
    this.requestURL = null;
    if (!paramBoolean);
    for (this.requestURL = (this.config.getAppURL().toExternalForm() + paramString); ; this.requestURL = (this.config.getRootURL() + "/" + paramString))
    {
      sendRequest(this.requestURL);
      return;
    }
  }

  public void removeExpectedAnswer(String paramString)
  {
    this.wlAnswers.remove(paramString);
    resendIfNeeded();
  }

  // ERROR //
  public void requestFinished(WLResponse paramWLResponse)
  {
    // Byte code:
    //   0: aload_0
    //   1: aload_1
    //   2: invokespecial 641	com/worklight/wlclient/WLRequest:checkResponseForSuccesses	(Lcom/worklight/wlclient/api/WLResponse;)V
    //   5: aload_0
    //   6: aload_1
    //   7: invokespecial 643	com/worklight/wlclient/WLRequest:checkResponseForChallenges	(Lcom/worklight/wlclient/api/WLResponse;)Z
    //   10: istore 4
    //   12: iload 4
    //   14: ifne +168 -> 182
    //   17: aload_1
    //   18: invokevirtual 473	com/worklight/wlclient/api/WLResponse:getStatus	()I
    //   21: sipush 200
    //   24: if_icmpne +187 -> 211
    //   27: aload_1
    //   28: invokevirtual 344	com/worklight/wlclient/api/WLResponse:getResponseJSON	()Lorg/json/JSONObject;
    //   31: astore 7
    //   33: aload 7
    //   35: ifnull +142 -> 177
    //   38: aload 7
    //   40: ldc_w 645
    //   43: invokevirtual 488	org/json/JSONObject:get	(Ljava/lang/String;)Ljava/lang/Object;
    //   46: astore 8
    //   48: aload 8
    //   50: ifnull +127 -> 177
    //   53: aload 8
    //   55: checkcast 95	org/json/JSONObject
    //   58: astore 9
    //   60: ldc_w 647
    //   63: invokestatic 651	java/lang/Class:forName	(Ljava/lang/String;)Ljava/lang/Class;
    //   66: pop
    //   67: invokestatic 373	com/worklight/wlclient/api/WLClient:getInstance	()Lcom/worklight/wlclient/api/WLClient;
    //   70: invokevirtual 655	com/worklight/wlclient/api/WLClient:getPush	()Lcom/worklight/wlclient/api/WLPush;
    //   73: astore 11
    //   75: aload 9
    //   77: ldc_w 657
    //   80: invokevirtual 452	org/json/JSONObject:has	(Ljava/lang/String;)Z
    //   83: istore 12
    //   85: aconst_null
    //   86: astore 13
    //   88: iload 12
    //   90: ifeq +16 -> 106
    //   93: aload 9
    //   95: ldc_w 657
    //   98: invokevirtual 488	org/json/JSONObject:get	(Ljava/lang/String;)Ljava/lang/Object;
    //   101: checkcast 122	java/lang/String
    //   104: astore 13
    //   106: aload 11
    //   108: aload 13
    //   110: invokevirtual 662	com/worklight/wlclient/api/WLPush:updateToken	(Ljava/lang/String;)V
    //   113: aload 11
    //   115: invokevirtual 665	com/worklight/wlclient/api/WLPush:clearSubscribedEventSources	()V
    //   118: aload 9
    //   120: ldc_w 667
    //   123: invokevirtual 452	org/json/JSONObject:has	(Ljava/lang/String;)Z
    //   126: ifeq +19 -> 145
    //   129: aload 11
    //   131: aload 9
    //   133: ldc_w 667
    //   136: invokevirtual 488	org/json/JSONObject:get	(Ljava/lang/String;)Ljava/lang/Object;
    //   139: checkcast 356	org/json/JSONArray
    //   142: invokevirtual 671	com/worklight/wlclient/api/WLPush:updateSubscribedEventSources	(Lorg/json/JSONArray;)V
    //   145: aload 11
    //   147: invokevirtual 674	com/worklight/wlclient/api/WLPush:clearSubscribedTags	()V
    //   150: aload 9
    //   152: ldc_w 676
    //   155: invokevirtual 452	org/json/JSONObject:has	(Ljava/lang/String;)Z
    //   158: ifeq +19 -> 177
    //   161: aload 11
    //   163: aload 9
    //   165: ldc_w 676
    //   168: invokevirtual 488	org/json/JSONObject:get	(Ljava/lang/String;)Ljava/lang/Object;
    //   171: checkcast 356	org/json/JSONArray
    //   174: invokevirtual 679	com/worklight/wlclient/api/WLPush:updateSubscribedTags	(Lorg/json/JSONArray;)V
    //   177: aload_0
    //   178: aload_1
    //   179: invokespecial 681	com/worklight/wlclient/WLRequest:processSuccessResponse	(Lcom/worklight/wlclient/api/WLResponse;)V
    //   182: return
    //   183: astore_2
    //   184: aload_0
    //   185: aload_2
    //   186: invokespecial 463	com/worklight/wlclient/WLRequest:triggerUnexpectedOnFailure	(Ljava/lang/Exception;)V
    //   189: return
    //   190: astore_3
    //   191: aload_0
    //   192: aload_3
    //   193: invokespecial 463	com/worklight/wlclient/WLRequest:triggerUnexpectedOnFailure	(Ljava/lang/Exception;)V
    //   196: return
    //   197: astore 6
    //   199: getstatic 55	com/worklight/wlclient/WLRequest:logger	Lcom/worklight/common/Logger;
    //   202: ldc_w 683
    //   205: invokevirtual 392	com/worklight/common/Logger:error	(Ljava/lang/String;)V
    //   208: goto -31 -> 177
    //   211: aload_1
    //   212: invokevirtual 473	com/worklight/wlclient/api/WLResponse:getStatus	()I
    //   215: sipush 201
    //   218: if_icmpeq +13 -> 231
    //   221: aload_1
    //   222: invokevirtual 473	com/worklight/wlclient/api/WLResponse:getStatus	()I
    //   225: sipush 204
    //   228: if_icmpne +38 -> 266
    //   231: getstatic 55	com/worklight/wlclient/WLRequest:logger	Lcom/worklight/common/Logger;
    //   234: new 379	java/lang/StringBuilder
    //   237: dup
    //   238: invokespecial 380	java/lang/StringBuilder:<init>	()V
    //   241: ldc_w 685
    //   244: invokevirtual 386	java/lang/StringBuilder:append	(Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   247: aload_1
    //   248: invokevirtual 473	com/worklight/wlclient/api/WLResponse:getStatus	()I
    //   251: invokevirtual 688	java/lang/StringBuilder:append	(I)Ljava/lang/StringBuilder;
    //   254: invokevirtual 389	java/lang/StringBuilder:toString	()Ljava/lang/String;
    //   257: invokevirtual 533	com/worklight/common/Logger:debug	(Ljava/lang/String;)V
    //   260: aload_0
    //   261: aload_1
    //   262: invokespecial 681	com/worklight/wlclient/WLRequest:processSuccessResponse	(Lcom/worklight/wlclient/api/WLResponse;)V
    //   265: return
    //   266: aload_0
    //   267: aload_1
    //   268: invokespecial 690	com/worklight/wlclient/WLRequest:processFailureResponse	(Lcom/worklight/wlclient/api/WLResponse;)V
    //   271: return
    //   272: astore 5
    //   274: goto -97 -> 177
    //
    // Exception table:
    //   from	to	target	type
    //   0	5	183	java/lang/Exception
    //   5	12	190	java/lang/Exception
    //   27	33	197	java/lang/ClassNotFoundException
    //   38	48	197	java/lang/ClassNotFoundException
    //   53	85	197	java/lang/ClassNotFoundException
    //   93	106	197	java/lang/ClassNotFoundException
    //   106	145	197	java/lang/ClassNotFoundException
    //   145	177	197	java/lang/ClassNotFoundException
    //   27	33	272	org/json/JSONException
    //   38	48	272	org/json/JSONException
    //   53	85	272	org/json/JSONException
    //   93	106	272	org/json/JSONException
    //   106	145	272	org/json/JSONException
    //   145	177	272	org/json/JSONException
  }

  public void submitAnswer(String paramString, Object paramObject)
  {
    this.wlAnswers.put(paramString, paramObject);
    resendIfNeeded();
  }

  public static abstract interface RequestPaths
  {
    public static final String AUTHENTICATE = "authenticate";
    public static final String DELETE_USER_PREF = "deleteup";
    public static final String EVENTS = "events";
    public static final String GET_CONFIG = "apps/services/configprofile";
    public static final String HEART_BEAT = "heartbeat";
    public static final String INIT = "init";
    public static final String INVOKE_PROCEDURE = "query";
    public static final String LOGIN = "login";
    public static final String LOGOUT = "logout";
    public static final String LOG_ACTIVITY = "logactivity";
    public static final String NOTIFICATION = "notifications";
    public static final String SEND_INVOKE_PROCEDURE = "invoke";
    public static final String SET_USER_PREFS = "setup";
    public static final String SSL_CLIENT_AUTH = "sslclientauth";
    public static final String UPLOAD_LOGS = "apps/services/loguploader";
  }
}

/* Location:           C:\Documents and Settings\Cesar Cabello Cea\Mis documentos\Downloads\apk-downloader\com.ikea.kompis-6_dex2jar.jar
 * Qualified Name:     com.worklight.wlclient.WLRequest
 * JD-Core Version:    0.6.2
 */