android-studio - HttpClient non verrà importato in Android Studio




android-gradle apache-httpclient-4.x (19)

Ho una semplice lezione scritta in Android Studio:

package com.mysite.myapp;

import org.apache.http.client.HttpClient;

public class Whatever {
    public void headBangingAgainstTheWallExample () {
        HttpClient client = new DefaultHttpClient();
    }
}

e da questo ottengo il seguente errore di compilazione:

Cannot resolve symbol HttpClient

HttpClient non è incluso HttpClient di Android Studio? Anche se non lo è, l'ho aggiunto alla mia build Gradle in questo modo:

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:23.0.0'
    compile 'org.apache.httpcomponents:httpclient:4.5'
}

Con o senza l'ultima riga di compilazione, l'errore è lo stesso. Cosa mi manca?


Answers

Errore: (30, 0) Metodo DSL non trovato: 'classpath ()' Possibili cause:

  • Il progetto 'cid' potrebbe utilizzare una versione del plug-in Android Gradle che non contiene il metodo (ad esempio 'testCompile' è stato aggiunto in 1.1.0). Aggiorna il plug-in alla versione 2.3.3 e sincronizza il progetto
  • Il progetto 'cid' può utilizzare una versione di Gradle che non contiene il metodo. Apri il file wrapper Gradle
  • Il file di build può mancare un plugin Gradle. Applica il plugin Gradle

  • HttpClient è stato ritirato al livello API 22 e rimosso nel livello API 23. È ancora possibile utilizzarlo in API Livello 23 e successivi se è necessario, tuttavia è meglio passare ai metodi supportati per gestire HTTP. Quindi, se stai compilando con 23, aggiungi questo nel tuo build.gradle:

    android {
        useLibrary 'org.apache.http.legacy'
    }
    

    in API 22 diventano deprecati e in API 23 li rimuovono completamente, una soluzione semplice se non hai bisogno di tutte le novità delle nuove aggiunte è semplicemente utilizzare i file .jar di apache che sono stati integrati prima dell'API 22, ma come file .jar separati:

    1. http://hc.apache.org/downloads.cgi
    2. download httpclient 4.5.1, the zile file
    3. unzip all files
    4. drag in your project httpclient-4.5.1.jar, httpcore-4.4.3.jar and httpmime-4.5.1.jar
    5. project, right click, open module settings, app, dependencies, +, File dependency and add the 3 files
    6. now everything should compile properly
    

    La versione Android 6.0 (livello API 23) rimuove il supporto per il client HTTP Apache. Quindi non puoi usare questa libreria direttamente nell'API 23. Ma c'è un modo per usarlo. Aggiungi useLibrary 'org.apache.http.legacy' nel tuo file build.gradle come sotto-

    android {
        useLibrary 'org.apache.http.legacy'
    }
    

    Se questo non funziona, puoi applicare il seguente

    - Copia org.apache.http.legacy.jar che si trova in / platforms / android-23 / percorso facoltativo della directory di Android SDK nella cartella app / libs del progetto.

    - Aggiungi ora i file di compilazione ('libs / org.apache.http.legacy.jar') all'interno della sezione delle dipendenze {} del file build.gradle.


    Devi aggiungere solo una riga

    useLibrary 'org.apache.http.legacy'
    

    per esempio in build.gradle (Modulo: app)

    apply plugin: 'com.android.application'
    
    android {
        compileSdkVersion 24
        buildToolsVersion "25.0.0"
    
        useLibrary 'org.apache.http.legacy'
    
        defaultConfig {
            applicationId "com.avenues.lib.testotpappnew"
            minSdkVersion 15
            targetSdkVersion 24
            versionCode 1
            versionName "1.0"
            testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
        }
        buildTypes {
            release {
                minifyEnabled false
                proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            }
        }
    }
    
    dependencies {
        compile fileTree(dir: 'libs', include: ['*.jar'])
        androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
            exclude group: 'com.android.support', module: 'support-annotations'
        })
        compile 'com.android.support:appcompat-v7:24.2.1'
        testCompile 'junit:junit:4.12'
    }
    

    1- scaricare i file jar Apache (come da questa risposta) file 4.5.zip da:
    https://hc.apache.org/downloads.cgi?Preferred=http%3A%2F%2Fapache.arvixe.com%2F

    2- aprire il file zip i file jar nella cartella libs. Puoi trovarlo se vai in cima al tuo progetto dove dice "Android" troverai un elenco quando lo fai clic. Così,

    Android -> Progetto -> app -> librerie

    Quindi metti i barattoli lì.

    3- In build.gradle (Modulo: app) aggiungi

    compile fileTree(dir: 'libs', include: ['*.jar'])
    

    nel

     dependency { 
       }
    

    4- Nella classe java aggiungi queste importazioni:

    import org.apache.http.HttpResponse;
    
    import org.apache.http.client.HttpClient;
    
    import org.apache.http.client.methods.HttpGet;
    
    import org.apache.http.impl.client.DefaultHttpClient;
    
    import org.apache.http.params.CoreProtocolPNames;
    

    ApacheHttp Client viene rimosso in sdk v23. Puoi utilizzare HttpURLConnection o Http Client di terze parti come OkHttp.

    ref: https://developer.android.com/preview/behavior-changes.html#behavior-apache-http-client


    Aggiungi queste due linee sotto dipendenze

    compile 'org.apache.httpcomponents:httpcore:4.4.1'
    compile 'org.apache.httpcomponents:httpclient:4.5'
    

    poi

    useLibrary 'org.apache.http.legacy'
    

    sotto l'androide


    Quale target API hai nel tuo progetto? AndroidHttpClient è solo per API Livello 8 <. e per favore date un'occhiata here

    goditi il ​​tuo codice :)


    La risposta di TejaDroid nel link qui sotto mi ha aiutato. Impossibile importare org.apache.http.HttpResponse in Android Studio

    dependencies {
        compile fileTree(include: ['*.jar'], dir: 'libs')
        compile 'com.android.support:appcompat-v7:23.0.1'
    
        compile 'org.jbundle.util.osgi.wrapped:org.jbundle.util.osgi.wrapped.org.apache.http.client:4.1.2'
        ...
    }
    

    Come accennato in precedenza, org.apache.http.client.HttpClient non è più supportato in:

    SDK (livello API) n. 23.

    Devi usare java.net.HttpURLConnection .

    Se vuoi rendere più semplice il tuo codice (e la tua vita) quando usi HttpURLConnection , ecco un Wrapper di questa classe che ti permetterà di fare semplici operazioni con GET , POST e PUT usando JSON , come ad esempio fare un HTTP PUT .

    HttpRequest request = new HttpRequest(API_URL + PATH).addHeader("Content-Type", "application/json");
    int httpCode = request.put(new JSONObject().toString());
    if (HttpURLConnection.HTTP_OK == httpCode) {
        response = request.getJSONObjectResponse();
    } else {
      // log error
    }
    httpRequest.close()
    

    Sentiti libero di usarlo.

    package com.calculistik.repository;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.util.HashMap;
    import java.util.Map;
    
    import org.json.JSONArray;
    import org.json.JSONException;
    import org.json.JSONObject;
    
    /**
     * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
     * <p>
     * Copyright © 2017, Calculistik . All rights reserved.
     * <p>
     * Oracle and Java are registered trademarks of Oracle and/or its
     * affiliates. Other names may be trademarks of their respective owners.
     * <p>
     * The contents of this file are subject to the terms of either the GNU
     * General Public License Version 2 only ("GPL") or the Common
     * Development and Distribution License("CDDL") (collectively, the
     * "License"). You may not use this file except in compliance with the
     * License. You can obtain a copy of the License at
     * https://netbeans.org/cddl-gplv2.html or
     * nbbuild/licenses/CDDL-GPL-2-CP. See the License for the specific
     * language governing permissions and limitations under the License.
     * When distributing the software, include this License Header
     * Notice in each file and include the License file at
     * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this particular file
     * as subject to the "Classpath" exception as provided by Oracle in the
     * GPL Version 2 section of the License file that accompanied this code. If
     * applicable, add the following below the License Header, with the fields
     * enclosed by brackets [] replaced by your own identifying information:
     * "Portions Copyrighted [year] [name of copyright owner]"
     * <p>
     * Contributor(s):
     * Created by alejandro tkachuk @aletkachuk
     * www.calculistik.com
     */
    public class HttpRequest {
    
        public static enum Method {
            POST, PUT, DELETE, GET;
        }
    
        private URL url;
        private HttpURLConnection connection;
        private OutputStream outputStream;
        private HashMap<String, String> params = new HashMap<String, String>();
    
        public HttpRequest(String url) throws IOException {
            this.url = new URL(url);
            connection = (HttpURLConnection) this.url.openConnection();
        }
    
        public int get() throws IOException {
            return this.send();
        }
    
        public int post(String data) throws IOException {
            connection.setDoInput(true);
            connection.setRequestMethod(Method.POST.toString());
            connection.setDoOutput(true);
            outputStream = connection.getOutputStream();
            this.sendData(data);
            return this.send();
        }
    
        public int post() throws IOException {
            connection.setDoInput(true);
            connection.setRequestMethod(Method.POST.toString());
            connection.setDoOutput(true);
            outputStream = connection.getOutputStream();
            return this.send();
        }
    
        public int put(String data) throws IOException {
            connection.setDoInput(true);
            connection.setRequestMethod(Method.PUT.toString());
            connection.setDoOutput(true);
            outputStream = connection.getOutputStream();
            this.sendData(data);
            return this.send();
        }
    
        public int put() throws IOException {
            connection.setDoInput(true);
            connection.setRequestMethod(Method.PUT.toString());
            connection.setDoOutput(true);
            outputStream = connection.getOutputStream();
            return this.send();
        }
    
        public HttpRequest addHeader(String key, String value) {
            connection.setRequestProperty(key, value);
            return this;
        }
    
        public HttpRequest addParameter(String key, String value) {
            this.params.put(key, value);
            return this;
        }
    
        public JSONObject getJSONObjectResponse() throws JSONException, IOException {
            return new JSONObject(getStringResponse());
        }
    
        public JSONArray getJSONArrayResponse() throws JSONException, IOException {
            return new JSONArray(getStringResponse());
        }
    
        public String getStringResponse() throws IOException {
            BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            StringBuilder response = new StringBuilder();
            for (String line; (line = br.readLine()) != null; ) response.append(line + "\n");
            return response.toString();
        }
    
        public byte[] getBytesResponse() throws IOException {
            byte[] buffer = new byte[8192];
            InputStream is = connection.getInputStream();
            ByteArrayOutputStream output = new ByteArrayOutputStream();
            for (int bytesRead; (bytesRead = is.read(buffer)) >= 0; )
                output.write(buffer, 0, bytesRead);
            return output.toByteArray();
        }
    
        public void close() {
            if (null != connection)
                connection.disconnect();
        }
    
        private int send() throws IOException {
            int httpStatusCode = HttpURLConnection.HTTP_BAD_REQUEST;
    
            if (!this.params.isEmpty()) {
                this.sendData();
            }
            httpStatusCode = connection.getResponseCode();
    
            return httpStatusCode;
        }
    
        private void sendData() throws IOException {
            StringBuilder result = new StringBuilder();
            for (Map.Entry<String, String> entry : params.entrySet()) {
                result.append((result.length() > 0 ? "&" : "") + entry.getKey() + "=" + entry.getValue());//appends: key=value (for first param) OR &key=value(second and more)
            }
            sendData(result.toString());
        }
    
        private HttpRequest sendData(String query) throws IOException {
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream, "UTF-8"));
            writer.write(query);
            writer.close();
            return this;
        }
    
    }
    

    Se vuoi importare qualche classe come:

    import org.apache.http.NameValuePair;
    import org.apache.http.client.HttpClient; 
    import org.apache.http.client.entity.UrlEncodedFormEntity;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.impl.client.DefaultHttpClient;
    import org.apache.http.message.BasicNameValuePair;
    import org.apache.http.params.BasicHttpParams;
    import org.apache.http.params.HttpConnectionParams;
    import org.apache.http.params.HttpParams;
    

    È possibile aggiungere la seguente riga in build.gradle (dipendenze Gradle)

    dependencies {
        implementation fileTree(dir: 'libs', include: ['*.jar'])
        implementation 'com.android.support:appcompat-v7:27.1.0'
        implementation 'com.android.support:support-v4:27.1.0'
    
        .
        .
        .
    
        implementation 'org.jbundle.util.osgi.wrapped:org.jbundle.util.osgi.wrapped.org.apache.http.client:4.1.2'
    
    }
    

    Basta usare questo: -

    android {
             .
             .
             .
     useLibrary 'org.apache.http.legacy'
             .
             .
             .
              }
    

    Prova questo ha funzionato per me Aggiungi questa dipendenza al file build.gradle

    compile 'org.jbundle.util.osgi.wrapped:org.jbundle.util.osgi.wrapped.org.apache.http.client:4.1.2'
    

    Penso che a seconda della versione di Android Studio che hai, è importante aggiornare anche il tuo studio Android, stavo diventando frustrato anche seguendo i consigli di tutti ma senza fortuna, fino a quando non ho dovuto aggiornare la mia versione Android da 1.3 a 1.5, gli errori sono scomparsi come Magia.


    Per utilizzare Apache HTTP per SDK Livello 23:

    Livello superiore build.gradle - /build.gradle

    buildscript {
        ...
        dependencies {
            classpath 'com.android.tools.build:gradle:1.5.0' 
            // Lowest version for useLibrary is 1.3.0
            // Android Studio will notify you about the latest stable version
            // See all versions: http://jcenter.bintray.com/com/android/tools/build/gradle/
        }
        ...
    }
    

    Notifica da parte di Android Studio sull'aggiornamento gradle:

    Modulo specifico build.gradle - /app/build.gradle

    android {
        compileSdkVersion 23
        buildToolsVersion "23.0.2"
        ...
        useLibrary 'org.apache.http.legacy'
        ...
    }
    

    Puoi semplicemente aggiungerlo alle dipendenze di Gradle:

    compile "org.apache.httpcomponents:httpcore:4.3.2"
    

    HttpClient non è supportato in sdk 23 e 23+.

    Se devi usare in sdk 23, aggiungi sotto il codice al tuo gradle:

    android {
        useLibrary 'org.apache.http.legacy'
    }
    

    Funziona per me. Spero utile per voi


    L'emulatore sembra rallentare quando è inattivo. Ciò è reso evidente passando rapidamente il mouse sui tasti sul lato e osservando le risposte di illuminazione. Per ovviare al problema, -icount auto passaggio -icount auto da -icount auto a QEMU all'avvio dell'emulatore. Puoi creare un file batch chiamato my_avd.bat per farlo per te:

    emulator @my_avd -no-boot-anim -qemu -icount auto
    • @my_avd : avvia un dispositivo virtuale denominato "my_avd"
    • -no-boot-anim - disabilita l'animazione per un avvio più veloce
    • -qemu args... - passa argomenti a qemu
    • -icount [N|auto] - abilita il contatore di istruzioni virtuale con tick di clock 2 ^ N per istruzione

    Ciò ha reso le animazioni burrose e rapide adb install dieci volte.





    android android-studio android-gradle apache-httpclient-4.x