Esempio n. 1
0
  public static final String executePost(String url) {
    try {
      HttpPost httppost = new HttpPost(url);

      httppost.setHeader("User-Agent", USER_AGENT);
      httppost.setHeader("Accept-Charset", "utf-8");
      httppost.setHeader("Cache-Control", "max-age=3, must-revalidate, private");
      httppost.setHeader(
          "Authorization",
          "OAuth oauth_token=2d62f7b3de642cdd402f62e42fba0b25, oauth_consumer_key=a324957217164fd1d76b4b60d037abec, oauth_version=1.0, oauth_signature_method=HMAC-SHA1, oauth_timestamp=1322049404, oauth_nonce=-5195915877644743836, oauth_signature=wggOr1ia7juVbG%2FZ2ydImmiC%2Ft4%3D");

      HttpClient client = theThreadSafeHttpClient();
      HttpResponse response = client.execute(httppost);
      HttpEntity entity = response.getEntity();
      if (entity != null) {
        client.getConnectionManager().closeExpiredConnections();
        return EntityUtils.toString(entity, HTTP.UTF_8);
      }

    } catch (HttpResponseException e) {
      System.err.println(e.getMessage());

    } catch (Exception e) {
      e.printStackTrace();
    }
    return "";
  }
 public boolean isHttpResponseCode(int code) {
   if (getCause() instanceof HttpResponseException) {
     HttpResponseException responseException = (HttpResponseException) getCause();
     return responseException.getStatusCode() == code;
   }
   return false;
 }
Esempio n. 3
0
  public static String executePost(String url, Map<String, String> params, String accessTokens) {
    try {
      HttpClient httpClient = theThreadSafeHttpClient();
      HttpPost postRequest = new HttpPost(url);
      postRequest.addHeader("Accept-Charset", HTTP.UTF_8);
      postRequest.addHeader("User-Agent", MOBILE_USER_AGENT);
      postRequest.setHeader("Authorization", "OAuth oauth_token=" + accessTokens);

      Set<String> names = params.keySet();
      List<NameValuePair> postParameters = new ArrayList<NameValuePair>(names.size());
      for (String name : names) {
        System.out.println(name + "=" + params.get(name));
        postParameters.add(new BasicNameValuePair(name, params.get(name)));
      }
      postRequest.setEntity(new UrlEncodedFormEntity(postParameters, "UTF-8"));

      HttpResponse response = httpClient.execute(postRequest);
      HttpEntity entity = response.getEntity();
      if (entity != null) {
        httpClient.getConnectionManager().closeExpiredConnections();
        return EntityUtils.toString(entity, HTTP.UTF_8);
      }
    } catch (HttpResponseException e) {
      System.err.println(e.getMessage());

    } catch (Exception e) {
      e.printStackTrace();
    }
    return "";
  }
  @Override
  public void handleException(Exception e) {
    _logger.error(e.getMessage(), e);

    if (!(e instanceof HttpResponseException)) {
      super.handleException(e);

      return;
    }

    HttpResponseException hre = (HttpResponseException) e;

    int statusCode = hre.getStatusCode();

    if (statusCode != HttpStatus.SC_NOT_FOUND) {
      super.handleException(e);

      return;
    }

    SyncAccount syncAccount = SyncAccountService.fetchSyncAccount(getSyncAccountId());

    if (syncAccount.getState() == SyncAccount.STATE_DISCONNECTED) {
      super.handleException(e);

      return;
    }

    SyncFile syncFile = (SyncFile) getParameterValue("syncFile");

    SyncFileService.deleteSyncFile(syncFile, false);
  }
  private static String apiCall(HttpRequestBase method) throws NetworkErrorException {

    Log.d("apiCall()", method.getURI().toString());
    String response = null;
    method.setHeader("User-Agent", "ANDROID DEBUG DEVICE");
    try {

      try {
        try {
          response = httpClient.execute(method, new BasicResponseHandler());
        } catch (IllegalStateException e) {
          throw new NetworkErrorException("404");
        }
        Log.d(TAG, response);
      } catch (HttpResponseException e) {
        Log.d(TAG, Integer.toString(e.getStatusCode()));
        throw new NetworkErrorException(Integer.toString(e.getStatusCode()));
      }

    } catch (IOException e) {
      Log.d(TAG, "IO");
      throw new NetworkErrorException("404");
    }
    Log.d("odpowiedz: ", response);
    return response;
  }
  /**
   * Searching places
   *
   * @param latitude - latitude of place
   * @params longitude - longitude of place
   * @param radius - radius of searchable area
   * @param types - type of place to search
   * @return list of places
   */
  public PlacesList search(double latitude, double longitude, double radius, String types)
      throws Exception {

    this._latitude = latitude;
    this._longitude = longitude;
    this._radius = radius;

    try {

      HttpRequestFactory httpRequestFactory = createRequestFactory(HTTP_TRANSPORT);
      HttpRequest request = httpRequestFactory.buildGetRequest(new GenericUrl(PLACES_SEARCH_URL));
      request.getUrl().put("key", API_KEY);
      request.getUrl().put("location", _latitude + "," + _longitude);
      request.getUrl().put("radius", _radius); // in meters
      request.getUrl().put("sensor", "false");
      if (types != null) request.getUrl().put("types", types);

      PlacesList list = request.execute().parseAs(PlacesList.class);
      // Check log cat for places response status
      Log.d("Places Status", "" + list.status);
      return list;

    } catch (HttpResponseException e) {
      Log.e("Error:", e.getMessage());
      return null;
    }
  }
 /**
  * Executes the request and converts the result into an object of the desired <code>type</code>.
  * If the request results in a {@link HttpStatus#SC_NOT_FOUND}, then this method will return
  * <code>null</code>.
  *
  * @param uriStr The relative path to the endpoint
  * @param params Parameters to pass in the request
  * @param type The expected return type
  * @return The response or <code>null</code> in case no data was found
  * @throws IOException
  */
 protected <V> V getSingletonResponse(String uriStr, Map<String, String> params, Type type)
     throws IOException {
   try {
     return connector.get(uriStr, params, type);
   } catch (HttpResponseException e) {
     if (e.getStatusCode() == HttpStatus.SC_NOT_FOUND) return null;
     throw e;
   }
 }
 /**
  * Executes the request and converts the result into a map of the desired <code>type</code>. If
  * the request results in a {@link HttpStatus#SC_NOT_FOUND}, then this method will return an empty
  * map.
  *
  * @param uriStr The relative path to the endpoint
  * @param params Parameters to pass in the request
  * @param type The expected return type (must be a generic List declaration)
  * @return The response in list form or an empty list in case no data was found
  * @throws IOException
  */
 protected <K, V> Map<K, V> getMapResponse(String uriStr, Map<String, String> params, Type type)
     throws IOException {
   try {
     return connector.get(uriStr, params, type);
   } catch (HttpResponseException e) {
     if (e.getStatusCode() == HttpStatus.SC_NOT_FOUND) return Collections.emptyMap();
     throw e;
   }
 }
 public DeviceSync getDeviceSync() throws IOException, AuthenticationException {
   String uri = _locator.deviceSynchronizationUri();
   try {
     return _gson.fromJson(_client.GET(uri), DeviceSync.class);
   } catch (HttpResponseException e) {
     if (e.getStatusCode() == 401)
       throw new AuthenticationException("Unable to authenticate user with Gpodder.net", e);
     else throw e;
   }
 }
 /**
  * Returns a {@link List} of this user's {@link PodcastDevice} objects
  *
  * <p>The resulting list can be used to display a selection list to the user or to determine
  * device IDs to pull the subscription list from.
  *
  * @return a {@link List} of this user's {@link PodcastDevice} objects
  * @throws IOException
  * @throws AuthenticationException
  */
 public List<PodcastDevice> getDevices() throws IOException, AuthenticationException {
   String uri = _locator.deviceListUri();
   Type collectionType = new TypeToken<ArrayList<PodcastDevice>>() {}.getType();
   try {
     return _gson.fromJson(_client.GET(uri), collectionType);
   } catch (HttpResponseException e) {
     if (e.getStatusCode() == 401)
       throw new AuthenticationException("Unable to authenticate user with Gpodder.net", e);
     else throw e;
   }
 }
 /**
  * Downloads subscriptions since the time of the last update
  *
  * @param deviceId the id of the device to be updated
  * @param since should be a timestamp in seconds that has been retrieved previously by a call to
  *     this method or to {@link #updateSubscriptions}.
  * @return a {@link SubscriptionChanges} object with two lists (one for added and one for removed
  *     podcast URLs) and a "since" value that can be used for future calls to this method.
  * @throws IOException
  * @throws AuthenticationException
  */
 public SubscriptionChanges pullSubscriptions(String deviceId, long since)
     throws IOException, AuthenticationException {
   String uri = _locator.subscriptionUpdatesUri(deviceId, since);
   try {
     return _gson.fromJson(_client.GET(uri), SubscriptionChanges.class);
   } catch (HttpResponseException e) {
     if (e.getStatusCode() == 401)
       throw new AuthenticationException("Unable to authenticate user with Gpodder.net", e);
     else throw e;
   }
 }
 /**
  * Downloads a {@link List} of {@link EpisodeAction} objects from the server
  *
  * @param since Time stamp
  * @param podcast The podcast URL
  * @param deviceId The device identifier
  * @return a {@link EpisodeActionChanges} object with the list of new actions and a "since"
  *     timestamp that can be used for future calls to this method when retrieving episodes.
  * @throws IOException
  * @throws AuthenticationException if the user is not authenticated
  */
 public EpisodeActionChanges downloadEpisodeActions(long since, String podcast, String deviceId)
     throws IOException, AuthenticationException {
   try {
     return _gson.fromJson(
         _client.GET(_locator.downloadEpisodeActionsUri(since, podcast, deviceId)),
         EpisodeActionChanges.class);
   } catch (HttpResponseException e) {
     if (e.getStatusCode() == 401)
       throw new AuthenticationException("Unable to authenticate user with Gpodder.net", e);
     else throw e;
   }
 }
 /**
  * Update the description of a device on the server
  *
  * <p>This changes the caption and/or type of a given device on the server. If the device does not
  * exist, it is created with the given settings. The parameters caption and type are both optional
  * and when set to a value other than None will be used to update the device settings.
  *
  * @param deviceId The device identifier
  * @param caption The device name
  * @param type The device type
  * @return true if the request succeeded, false otherwise.
  * @throws IOException
  * @throws AuthenticationException
  */
 public boolean updateDeviceSettings(String deviceId, String caption, String type)
     throws IOException, AuthenticationException {
   PodcastDevice device = new PodcastDevice(deviceId, caption, type);
   StringEntity data = new StringEntity(_gson.toJson(device), "UTF-8");
   try {
     _client.POST(_locator.deviceSettingsUri(deviceId), data);
     return true;
   } catch (HttpResponseException e) {
     if (e.getStatusCode() == 401)
       throw new AuthenticationException("Unable to authenticate user with Gpodder.net", e);
     else return false;
   }
 }
    @Override
    protected JSONObject doInBackground(String... urls) {
      DefaultHttpClient client = new DefaultHttpClient();
      HttpPost post = new HttpPost(urls[0]);
      JSONObject holder = new JSONObject();
      JSONObject userObj = new JSONObject();
      String response = null;
      JSONObject json = new JSONObject();

      try {
        try {
          // setup the returned values in case
          // something goes wrong
          json.put("success", false);
          json.put("info", "Something went wrong. Retry!");

          // add the users's info to the post params
          userObj.put("email", mUserEmail);
          userObj.put("name", mUserName);
          userObj.put("password", mUserPassword);
          userObj.put("password_confirmation", mUserPasswordConfirmation);
          userObj.put("phone_first", mPhone_first);
          userObj.put("phone_second", mPhone_second);
          userObj.put("phone_third", mPhone_third);
          userObj.put("phone", mPhone_first + mPhone_second + mPhone_third);
          holder.put("user", userObj);
          StringEntity se = new StringEntity(holder.toString());
          post.setEntity(se);

          // setup the request headers
          post.setHeader("Accept", "application/json");
          post.setHeader("Content-Type", "application/json");

          ResponseHandler<String> responseHandler = new BasicResponseHandler();
          response = client.execute(post, responseHandler);
          json = new JSONObject(response);

        } catch (HttpResponseException e) {
          e.printStackTrace();
          Log.e("ClientProtocol", "" + e);
        } catch (IOException e) {
          e.printStackTrace();
          Log.e("IO", "" + e);
        }
      } catch (JSONException e) {
        e.printStackTrace();
        Log.e("JSON", "" + e);
      }

      return json;
    }
Esempio n. 15
0
    protected String doInBackground(String... params) {
      Log.i(TAG, "doInBackground");
      String respuesta = null;

      try {
        TelephonyManager telephonyManager =
            (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
        String IMEI = telephonyManager.getDeviceId();
        String IMSI = telephonyManager.getSimSerialNumber();
        String consulta;
        if (phone.getText().toString().equals("2")) {
          consulta = URLs.RESOURCE;
        } else consulta = SoapRequestMovistar.getResource(IMEI, IMSI, phone.getText().toString());

        ArrayList<String> retorno = XMLParser.getReturnCode(consulta);

        code = Integer.valueOf(retorno.get(0));

        if (code == 0) {
          respuesta = consulta;
          Log.i(TAG, retorno.get(1));
        } else respuesta = retorno.get(1);
        return respuesta;

      } catch (HttpHostConnectException e2) {
        errorMessage = "Se agotó el tiempo de espera. Por favor reintente";
        return null;
      } catch (HttpResponseException e3) {
        e3.printStackTrace();
        errorMessage = "Se agotó el tiempo de espera. Por favor reintente";
        return null;
      } catch (ParseException p) {
        p.printStackTrace();
        errorMessage = "Error en la recepción de los datos. Por favor reintente";
        return null;
      } catch (SocketTimeoutException s1) {
        s1.printStackTrace();
        errorMessage = "Se agotó el tiempo de espera. Por favor reintente";
        return null;
      } catch (ConnectTimeoutException et) {
        et.printStackTrace();
        errorMessage = "Se agotó el tiempo de espera. Por favor reintente";
        return null;
      } catch (Exception e1) {
        e1.printStackTrace();
        errorMessage = "Ha ocurrido un error con la respuesta del servidor.";
        return null;
      }
    }
Esempio n. 16
0
    @Override
    protected Void doInBackground(MyTaskParams... params) {
      String date = params[0].date;
      String nick = params[0].nick;
      String address = params[0].address;
      Double latitude = params[0].latitude;
      Double longitude = params[0].longitude;

      SoapObject request = new SoapObject(NAMESPACE, METHOD_NAME2);
      request.addProperty("date", date);
      request.addProperty("user", nick);
      request.addProperty("address", address);
      request.addProperty("lat", latitude);
      request.addProperty("longitude", longitude);

      SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);
      envelope.setOutputSoapObject(request);

      InsertUserActivity.MarshalDouble doubleMarshal = new InsertUserActivity.MarshalDouble();
      doubleMarshal.register(envelope);

      MarshalDate dateMarshal = new MarshalDate();
      dateMarshal.register(envelope);

      HttpTransportSE httpTransport = new HttpTransportSE(URL);

      httpTransport.debug = true;
      try {
        httpTransport.call(SOAP_ACTION2, envelope);
      } catch (HttpResponseException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (XmlPullParserException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } // send request
      try {
        response = (String) envelope.getResponse();
      } catch (SoapFault e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
      response = response.toString();
      return null;
    }
 public void setLabel(String feedUrl, String label)
     throws AuthenticationException, UnsupportedEncodingException, IOException {
   List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
   nameValuePairs.add(new BasicNameValuePair("s", "feed/" + feedUrl));
   nameValuePairs.add(new BasicNameValuePair("ac", "edit"));
   nameValuePairs.add(new BasicNameValuePair("a", "user/-/label/" + label));
   // nameValuePairs.add(new BasicNameValuePair("title", title));
   nameValuePairs.add(new BasicNameValuePair("T", mActionToken));
   try {
     POST(BASE_API_URI + "subscription/edit", new UrlEncodedFormEntity(nameValuePairs));
   } catch (HttpResponseException e) {
     if (e.getStatusCode() == 401)
       throw new AuthenticationException("Unable to authenticate user with Google Reader", e);
     else throw e;
   }
 }
Esempio n. 18
0
    protected JSONObject doInBackground(String... urls) {
      DefaultHttpClient client = new DefaultHttpClient();
      HttpPost post = new HttpPost(urls[0]);
      JSONObject holder = new JSONObject();
      JSONObject userObj = new JSONObject();
      String response = null;
      JSONObject json = new JSONObject();

      try {
        // Set error return values
        json.put("email", false);
        json.put("info", "Something went wrong. Retry.");

        // Set user password and email
        userObj.put("email", mEmail);
        userObj.put("password", mPassword);
        holder.put("user", userObj);

        StringEntity se = new StringEntity(holder.toString());
        post.setEntity(se);

        // Set the request header for the login
        post.setHeader("Accept", "application/json");
        post.setHeader("Content-Type", "application/json");

        ResponseHandler<String> responseHandler = new BasicResponseHandler();
        response = client.execute(post, responseHandler);
        json = new JSONObject(response);
      } catch (HttpResponseException e) {
        e.printStackTrace();
        Log.e("ClientProtocol", "", e);
        try {
          json.put("info", "Invalid Email/Password combination. Please retry.");
        } catch (JSONException j) {
          j.printStackTrace();
        }
      } catch (IOException e) {
        e.printStackTrace();
        Log.e("IO", "", e);
      } catch (JSONException e) {
        e.printStackTrace();
        Log.e("JSON", "", e);
      }

      return json;
    }
  /**
   * Searching single place full details
   *
   * @param reference - reference id of place - which you will get in search api request
   */
  public PlaceDetails getPlaceDetails(String reference) throws Exception {
    try {

      HttpRequestFactory httpRequestFactory = createRequestFactory(HTTP_TRANSPORT);
      HttpRequest request = httpRequestFactory.buildGetRequest(new GenericUrl(PLACES_DETAILS_URL));
      request.getUrl().put("key", API_KEY);
      request.getUrl().put("reference", reference);
      request.getUrl().put("sensor", "false");

      PlaceDetails place = request.execute().parseAs(PlaceDetails.class);

      return place;

    } catch (HttpResponseException e) {
      Log.e("Error in Perform Details", e.getMessage());
      throw e;
    }
  }
 public List<String> getSubscriptions(String label) throws AuthenticationException, IOException {
   JsonParser parser = new JsonParser();
   ArrayList<String> response = new ArrayList<String>();
   try {
     JsonObject result =
         (JsonObject) parser.parse(GET(BASE_API_URI + "subscription/list?output=json"));
     JsonArray subscriptions = result.getAsJsonArray("subscriptions");
     for (JsonElement subscription : subscriptions) {
       response.add(
           subscription.getAsJsonObject().get("id").getAsString().replaceFirst("feed/", ""));
     }
     return response;
   } catch (HttpResponseException e) {
     if (e.getStatusCode() == 401)
       throw new AuthenticationException("Unable to authenticate user with Google Reader", e);
     else throw e;
   }
 }
  public void failingRunReplicationWithError() throws Exception {
    Database db = startDatabase();
    URL fakeRemoteURL = new URL("http://couchbase.com/no_such_db");

    // Create a replication:
    Replication r1 = db.getPullReplication(fakeRemoteURL);
    runReplication(r1);

    // It should have failed with a 404:
    r1.start();
    assertEquals(
        Replication.ReplicationMode.REPLICATION_STOPPED,
        r1.getMode()); // UnsupportedOperationException
    assertEquals(0, r1.getCompletedChangesCount());
    assertEquals(0, r1.getChangesCount());
    assertEquals(r1.getLastError(), "domain.CBLHTTPErrorDomain");
    HttpResponseException err = (HttpResponseException) r1.getLastError();
    assertEquals(
        404, err.getStatusCode()); // don't support code error like : r1.getLastError().code
  }
  public void mark(List<String> ids, String state, String feedUrl)
      throws AuthenticationException, IOException {
    if (mActionToken == null) requestActionToken();
    if (ids.isEmpty()) return;

    List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
    for (String id : ids) {
      nameValuePairs.add(new BasicNameValuePair("i", id));
    }
    if (feedUrl != null) // Feed Url is not required, but makes the call more efficient
    nameValuePairs.add(new BasicNameValuePair("s", "feed/" + feedUrl));
    nameValuePairs.add(new BasicNameValuePair("T", mActionToken));
    nameValuePairs.add(new BasicNameValuePair("a", CURRENT_USER + state));
    try {
      POST(BASE_API_URI + "edit-tag", new UrlEncodedFormEntity(nameValuePairs));
    } catch (HttpResponseException e) {
      if (e.getStatusCode() == 401)
        throw new AuthenticationException("Unable to authenticate user with Google Reader", e);
      else throw e;
    }
  }
Esempio n. 23
0
    @Override
    protected JSONObject doInBackground(String... urls) {
      DefaultHttpClient client = new DefaultHttpClient();
      HttpPost post = new HttpPost(urls[0]);
      JSONObject holder = new JSONObject();
      JSONObject userObj = new JSONObject();
      String response = null;
      JSONObject json = new JSONObject();

      try {
        try {
          json.put("success", false);
          json.put("info", "Something went wrong. Retry!");
          userObj.put("email", mUserEmail);
          userObj.put("password", mUserPassword);
          holder.put("user", userObj);
          StringEntity se = new StringEntity(holder.toString());
          post.setEntity(se);

          post.setHeader("Accept", "application/json");
          post.setHeader("Content-type", "application/json");

          ResponseHandler<String> responseHandler = new BasicResponseHandler();
          response = client.execute(post, responseHandler);
          json = new JSONObject(response);
        } catch (HttpResponseException e) {
          e.printStackTrace();
          Log.e("ClientProtocol", "" + e);
          json.put("info", "Email and/or password are invalid. Retry!");
        } catch (IOException e) {
          e.printStackTrace();
          Log.e("IO", "" + e);
        }
      } catch (JSONException e) {
        e.printStackTrace();
        Log.e("JSON", "" + e);
      }

      return json;
    }
  /**
   * Uploads a {@link List} of {@link EpisodeAction} objects to the server
   *
   * @param actions a {@link List} of {@link EpisodeAction} objects
   * @return a timestamp that can be used for retrieving changes.
   * @throws IOException
   * @throws AuthenticationException
   */
  public long uploadEpisodeActions(List<EpisodeAction> actions)
      throws IOException, AuthenticationException {
    JsonParser parser = new JsonParser();
    StringEntity data = new StringEntity(_gson.toJson(actions));
    try {
      JsonObject response =
          (JsonObject) parser.parse(_client.POST(_locator.uploadEpisodeActionsUri(), data));

      JsonArray updates = response.getAsJsonArray("update_urls");
      for (JsonElement update : updates) {
        JsonArray element = update.getAsJsonArray();

        Log.d("UPDATE_URLS", element.get(0) + " to " + element.get(1));
      }

      return response.get("timestamp").getAsLong();
    } catch (HttpResponseException e) {
      if (e.getStatusCode() == 401)
        throw new AuthenticationException("Unable to authenticate user with Gpodder.net", e);
      else throw e;
    }
  }
Esempio n. 25
0
  private ManticoreHttpResponse httpExecute(HttpUriRequest request) {
    int statusCode = 200;
    String ret = "";
    try {
      Logger.verbose(
          LOG_TAG,
          String.format("Executing %s %s", request.getMethod(), request.getURI().toString()));
      ret = _http.execute(request, _handler, _context);
    } catch (HttpResponseException httpEx) {
      // Bad status code
      statusCode = httpEx.getStatusCode();
      ret = httpEx.getLocalizedMessage();
      Logger.warn(
          LOG_TAG,
          String.format("Error executing %s %s", request.getMethod(), request.getURI().toString()),
          httpEx);
    } catch (IOException ioEx) {
      Logger.error(LOG_TAG, "Error loading page " + request.getURI().toString(), ioEx);
      return null;
    }

    return new ManticoreHttpResponse(statusCode, ret, _handler.getHeaders());
  }