wake-up-neo.com

Wie erstelle ich eine separate Klasse für die Volley-Bibliothek und rufe alle Volley-Methoden einer anderen Aktivität auf und erhalte eine Antwort?

wie erstelle ich eine separate Klasse, in der alles über Volleyball definiert wird? In einer anderen Aktivität übergeben wir direkt URL, CONTEXT und Get Response ...

13
Kalpesh Kumawat

Erstellen Sie zunächst eine Callback-Schnittstelle, um das Ergebnis in Activity zu erhalten

public interface IResult {
    public void notifySuccess(String requestType,JSONObject response);
    public void notifyError(String requestType,VolleyError error);
}

Erstellen Sie eine separate Klasse mit Volley-Funktion, um das Ergebnis über die Schnittstelle auf die Aktivität zu reagieren

public class VolleyService {

    IResult mResultCallback = null;
    Context mContext;

    VolleyService(IResult resultCallback, Context context){
        mResultCallback = resultCallback;
        mContext = context;
    }


    public void postDataVolley(final String requestType, String url,JSONObject sendObj){
        try {
            RequestQueue queue = Volley.newRequestQueue(mContext);

            JsonObjectRequest jsonObj = new JsonObjectRequest(url,sendObj, new Response.Listener<JSONObject>() {
                @Override
                public void onResponse(JSONObject response) {
                    if(mResultCallback != null)
                        mResultCallback.notifySuccess(requestType,response);
                }
            }, new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError error) {
                    if(mResultCallback != null)
                        mResultCallback.notifyError(requestType,error);
                }
            });

            queue.add(jsonObj);

        }catch(Exception e){

        }
    }

    public void getDataVolley(final String requestType, String url){
        try {
            RequestQueue queue = Volley.newRequestQueue(mContext);

            JsonObjectRequest jsonObj = new JsonObjectRequest(Request.Method.GET, url, new Response.Listener<JSONObject>() {
                @Override
                public void onResponse(JSONObject response) {
                    if(mResultCallback != null)
                        mResultCallback.notifySuccess(requestType, response);
                }
            }, new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError error) {
                    if(mResultCallback != null)
                        mResultCallback.notifyError(requestType, error);
                }
            });

            queue.add(jsonObj);

        }catch(Exception e){

        }
    }
} 

Dann initialisieren Sie die Rückmeldeschnittstelle in der Hauptaktivität

    mResultCallback = new IResult() {
        @Override
        public void notifySuccess(String requestType,JSONObject response) {
            Log.d(TAG, "Volley requester " + requestType);
            Log.d(TAG, "Volley JSON post" + response);
        }

        @Override
        public void notifyError(String requestType,VolleyError error) {
            Log.d(TAG, "Volley requester " + requestType);
            Log.d(TAG, "Volley JSON post" + "That didn't work!");
        }
    };

Erstellen Sie nun ein Objekt der VolleyService-Klasse und übergeben Sie es mit Kontext und Callback-Schnittstelle

mVolleyService = new VolleyService(mResultCallback,this);

Rufen Sie nun die Volley-Methode für das Posting oder Abrufen von Daten auf, und übergeben Sie requestType, um den Serviceanforderer zu identifizieren, wenn das Ergebnis in die Hauptaktivität zurückversetzt wird

    mVolleyService.getDataVolley("GETCALL","http://192.168.1.150/datatest/get/data");
    JSONObject sendObj = null;

    try {
        sendObj = new JSONObject("{'Test':'Test'}");
    } catch (JSONException e) {
        e.printStackTrace();
    }
    mVolleyService.postDataVolley("POSTCALL", "http://192.168.1.150/datatest/post/data", sendObj);

Endgültige Hauptaktivität

public class MainActivity extends AppCompatActivity {
    private String TAG = "MainActivity";
    IResult mResultCallback = null;
    VolleyService mVolleyService;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initVolleyCallback();
        mVolleyService = new VolleyService(mResultCallback,this);
        mVolleyService.getDataVolley("GETCALL","http://192.168.1.150/datatest/get/data");
        JSONObject sendObj = null;

        try {
            sendObj = new JSONObject("{'Test':'Test'}");
        } catch (JSONException e) {
            e.printStackTrace();
        }
        mVolleyService.postDataVolley("POSTCALL", "http://192.168.1.150/datatest/post/data", sendObj);
    }

    void initVolleyCallback(){
        mResultCallback = new IResult() {
            @Override
            public void notifySuccess(String requestType,JSONObject response) {
                Log.d(TAG, "Volley requester " + requestType);
                Log.d(TAG, "Volley JSON post" + response);
            }

            @Override
            public void notifyError(String requestType,VolleyError error) {
                Log.d(TAG, "Volley requester " + requestType);
                Log.d(TAG, "Volley JSON post" + "That didn't work!");
            }
        };
    }

}

Das gesamte Projekt finden Sie unter folgendem Link

https://github.com/PatilRohit/VolleyCallback

31
Rohit Patil

sie haben tatsächlich einen Parameter in der obigen VolleyService-Klasse verpasst. Sie mussten hinzufügen, es ist ... JsonObjectRequest jsonObj = new JsonObjectRequest (Request.Method.GET, url, null, neuer Response.Listener () { / ... . / } null Der Parameter sollte enthalten sein, andernfalls wird ein Fehler ausgegeben 

2
Chinmai KH

Listener erstellen (da sie eine Schnittstelle sind, können sie nicht instanziiert werden, aber sie können als anonyme Klasse, die eine Schnittstelle implementiert) in der Aktivität oder dem Fragment instanziiert werden. Und übergeben Sie diese Instanzen als Parameter an die Anforderung (StringRequest, JsonObjectRequest oder ImageRequest).

public class MainActivity extends Activity {

private static final String URI = "";
// This is like BroadcastReceiver instantiation
private Listener<JSONObject> listenerResponse = new Listener<JSONObject>() {

    @Override
    public void onResponse(JSONObject arg0) {
        // Do what you want with response
    }
};

private ErrorListener listenerError = new ErrorListener() {
    @Override
    public void onErrorResponse(VolleyError arg0) {
        // Do what you want with error
    }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
}

}

Als Nächstes erstellen Sie eine Klasse mit Anforderung und übergeben diese Listener an die Anforderungsmethode dieser Klasse. Ich erkläre diesen Teil nicht. Dies ist gleichbedeutend mit dem Erstellen eines Anforderungsobjekts in beliebigen Lernprogrammen. Sie können diese Klasse jedoch nach Belieben anpassen. Sie können Singleton RequestQueue erstellen, um die Priorität zu überprüfen, oder Body-http-Body-Parameter für diese Methoden als Parameter festlegen.

public class NetworkHandler {
public static void requestJSON(Context context, String url, Listener<JSONObject> listenerResponse,  ErrorListener listenerError) {

    JsonObjectRequest jsonRequest = new JsonObjectRequest(Request.Method.GET, url, null, listenerResponse, listenerError);

    Volley.newRequestQueue(context).add(jsonRequest);
}

}

0
Thracian

öffentliche Klasse VolleyService {

IResult mResultCallback = null;
Context mContext;

VolleyService(IResult resultCallback, Context context)
{
    mResultCallback = resultCallback;
    mContext = context;
}

//--Post-Api---
public void postDataVolley(String url,final Map<String,String> param){
    try {
        StringRequest sr = new StringRequest(Request.Method.POST, url, new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                if(mResultCallback != null)
                    mResultCallback.notifySuccessPost(response);
            }
        },  new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                if(mResultCallback != null)
                    mResultCallback.notifyError(error);
            }
        }) {
            @Override
            protected Map<String, String> getParams() {
                return param;
            }

            @Override
            public Map<String, String> getHeaders() throws AuthFailureError {
                Map<String, String> params = new HashMap<String, String>();
                params.put("Content-Type", "application/x-www-form-urlencoded");
                return params;
            }
        };
        AppController.getInstance(mContext).addToRequestQueue(sr);

    }catch(Exception e){

    }
}
//==Patch-Api==
public void patchDataVolley(String url,final HashMap<String,Object> param)
{
    JsonObjectRequest request = new JsonObjectRequest(Request.Method.PATCH, url, new JSONObject(param),
            new Response.Listener<JSONObject>() {
                @Override
                public void onResponse(JSONObject response) {
                    if(mResultCallback != null)
                        mResultCallback.notifySuccessPatch(response);
                }
            },
            new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError error) {
                    if(mResultCallback != null)
                        mResultCallback.notifyError(error);
                }
            }) {
        @Override
        public Map<String, String> getHeaders() throws AuthFailureError {
            HashMap<String, String> headers = new HashMap<String, String>();
            return headers;
        }
    };
    AppController.getInstance(mContext).addToRequestQueue(request);
}

}

öffentliche Schnittstelle IResult { void notifySuccessPost (String-Antwort);

void notifySuccessPatch(JSONObject jsonObject);

void notifyError(VolleyError error);

}

JsonParserVolley.Java

(Eine separate Klasse, in der wir die Antwort erhalten werden)

public class JsonParserVolley {

final String contentType = "application/json; charset=utf-8";
String JsonURL = "Your URL";
Context context;
RequestQueue requestQueue;
String jsonresponse;

private Map<String, String> header;

public JsonParserVolley(Context context) {
    this.context = context;
    requestQueue = Volley.newRequestQueue(context);
    header = new HashMap<>();

}

public void addHeader(String key, String value) {
    header.put(key, value);
}

public void executeRequest(int method, final VolleyCallback callback) {

    StringRequest stringRequest = new StringRequest(method, JsonURL, new Response.Listener<String>() {
        @Override
        public void onResponse(String response) {
            jsonresponse = response;
            Log.e("RES", " res::" + jsonresponse);
            callback.getResponse(jsonresponse);


        }
    }, new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {

        }
    }) {
        @Override
        public Map<String, String> getHeaders() throws AuthFailureError {

            return header;
        }
    }
    ;
    requestQueue.add(stringRequest);

}

public interface VolleyCallback
{
    public void getResponse(String response);
}

}

MainActivity.Java (Code-Snippet in der onCreate-Methode geschrieben)

final JsonParserVolley jsonParserVolley = new JsonParserVolley(this);
    jsonParserVolley.addHeader("Authorization", "Your value");
    jsonParserVolley.executeRequest(Request.Method.GET, new JsonParserVolley.VolleyCallback() {

        @Override
        public void getResponse(String response) {

            jObject=response;
            Log.d("VOLLEY","RES"+jObject);

            parser();
        }
    }
    );

parser () ist die Methode, bei der die erhaltene Json-Antwort verwendet wird, um mit den Komponenten der Aktivität zu binden.

0
hetsgandhi