android-volley | DEPRECATED

<?php   
  require_once 'connection.php';  
  $response = array();  
  if(isset($_GET['apicall'])){  
  switch($_GET['apicall']){  
  case 'signup':  
    if(isTheseParametersAvailable(array('username','email','password',))){  
    $username = $_POST['username'];   
    $email = $_POST['email'];   
    $password = md5($_POST['password']);  
   
    $stmt = $conn->prepare("SELECT user_id FROM ci_users WHERE username = ? OR email = ?");  
    $stmt->bind_param("ss", $username, $email);  
    $stmt->execute();  
    $stmt->store_result();  
   
    if($stmt->num_rows > 0){  
        $response['error'] = true;  
        $response['message'] = 'User already registered';  
        $stmt->close();  
    }  
    else{  
        $stmt = $conn->prepare("INSERT INTO ci_users (username, email, password,) VALUES (?, ?, ?, ?)");  
        $stmt->bind_param("ssss", $username, $email, $password);  
   
        if($stmt->execute()){  
            $stmt = $conn->prepare("SELECT user_id,id, username, email, FROM users WHERE username = ?");   
            $stmt->bind_param("s",$username);  
            $stmt->execute();  
            $stmt->bind_result($user_id, $id, $username, $email);  
            $stmt->fetch();  
   
            $user = array(  
            'id'=>$id,   
            'username'=>$username,   
            'email'=>$email,  
          
            );  
   
            $stmt->close();  
   
            $response['error'] = false;   
            $response['message'] = 'User registered successfully';   
            $response['user'] = $user;   
        }  
    }  
   
}  
else{  
    $response['error'] = true;   
    $response['message'] = 'required parameters are not available';   
}  
break;   
case 'login':  
  if(isTheseParametersAvailable(array('username', 'password'))){  
    $username = $_POST['username'];  
    $password = md5($_POST['password']);   
   
    $stmt = $conn->prepare("SELECT user_id, username, email, mobile_no FROM ci_users WHERE username = ? AND password = ?");  
    $stmt->bind_param("ss",$username, $password);  
    $stmt->execute();  
    $stmt->store_result();  
    if($stmt->num_rows > 0){  
    $stmt->bind_result($id, $username, $email, $mobile);  
    $stmt->fetch();  
    $user = array(  
    'id'=>$id,   
    'username'=>$username,   
    'email'=>$email,  
    'mobile'=>$mobile  
    );  
   
    $response['error'] = false;   
    $response['message'] = 'Login successfull';   
    $response['user'] = $user;   
 }  
 else{  
    $response['error'] = false;   
    $response['message'] = 'Invalid username or password';  
 }  
}  
break;   
default:   
 $response['error'] = true;   
 $response['message'] = 'Invalid Operation Called';  
}  
}  
else{  
 $response['error'] = true;   
 $response['message'] = 'Invalid API Call';  
}  
echo json_encode($response);  
function isTheseParametersAvailable($params){  
foreach($params as $param){  
 if(!isset($_POST[$param])){  
     return false;   
  }  
}  
return true;   
}  
?>  

override fun getUrl(url: String, callback: (result: String?) -> Unit) {
    val req = StringRequest(
        Request.Method.GET, url,
        Response.Listener<String> { res -> callback(res) },
        Response.ErrorListener { err ->
            Log.d("MD-ERROR", err.toString());
            callback(null)
        }
    )

    req.retryPolicy = DefaultRetryPolicy(
        5000,
        DefaultRetryPolicy.DEFAULT_MAX_RETRIES,
        DefaultRetryPolicy.DEFAULT_BACKOFF_MULT
    )

    this.requestQueue.add(req)
}

class HttpServerWrapper(private val port: Int, private val xrfConnector: IXrfConnector) : AsyncHttpServer() {

/**
 * Starts the server
 */
fun startServer() {
    this.addMappings()
    this.listen(this.port)
}

fun addMappings() {
    this.get("/") { _, response: AsyncHttpServerResponse ->
        response.headers.add("Access-Control-Allow-Origin", "*")

        this.xrfConnector.getMeasurements {
            val gson = Gson()
            val json = gson.toJson(it?.measurements)

            response.send(json)
            response.end()
        }
    }
}

2021-01-19 10:21:03.037 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (785  ms) [ ] http://192.168.43.9:8080/xapi/measurements?startDate=2021-01-12 0x676a9949 NORMAL 2
2021-01-19 10:21:03.038 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (+0   ) [1621] add-to-queue
2021-01-19 10:21:03.040 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (+1   ) [1613] cache-queue-take
2021-01-19 10:21:03.043 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (+4   ) [1613] cache-hit-expired
2021-01-19 10:21:03.045 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (+2   ) [1616] network-queue-take
2021-01-19 10:21:03.049 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (+583 ) [1616] network-http-complete
2021-01-19 10:21:03.062 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (+16  ) [1616] network-parse-complete
2021-01-19 10:21:03.065 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (+4   ) [1616] network-cache-written
2021-01-19 10:21:03.068 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (+0   ) [1616] post-response
2021-01-19 10:21:03.069 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (+175 ) [ 2] done
2021-01-19 10:21:11.193 26316-26432/my.app.bridge I/System.out: http://192.168.43.9:8080/xapi/measurements?startDate=2021-01-12
2021-01-19 10:21:11.201 26316-26422/my.app.bridge D/Volley: [1613] WaitingRequestManager.maybeAddToWaitingRequests: new request, sending to network http://192.168.43.9:8080/xapi/measurements?startDate=2021-01-12
2021-01-19 10:21:26.390 26316-26316/my.app.bridge D/XRF-ERROR: com.android.volley.TimeoutError
2021-01-19 10:21:26.425 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (15229 ms) [ ] http://192.168.43.9:8080/xapi/measurements?startDate=2021-01-12 0x676a9949 NORMAL 3
2021-01-19 10:21:26.428 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (+0   ) [1621] add-to-queue
2021-01-19 10:21:26.434 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (+1   ) [1613] cache-queue-take
2021-01-19 10:21:26.439 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (+5   ) [1613] cache-hit-expired
2021-01-19 10:21:26.441 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (+4   ) [1615] network-queue-take
2021-01-19 10:21:26.443 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (+5104) [1615] socket-retry [timeout=5000]
2021-01-19 10:21:26.448 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (+10080) [1615] socket-timeout-giveup [timeout=10000]
2021-01-19 10:21:26.450 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (+0   ) [1615] post-error
2021-01-19 10:21:26.455 26316-26316/my.app.bridge D/Volley: [2] MarkerLog.finish: (+35  ) [ 2] done

http://192.168.1.20:88/Home/testme?a=abc

String url = "http://192.168.1.20:88/Home/testme";
RequestQueue queue = Volley.newRequestQueue(RegisterActivity.this);
StringRequest stringRequest = new StringRequest(Request.Method.POST, url,
                new Response.Listener<String>() {
                    @Override
                    public void onResponse(String response) {
                        tVMessage.setText(response);
                    }
                }, new Response.ErrorListener() {
                   @Override
                    public void onErrorResponse(VolleyError error) {
                              tVMessage.setText("That didn't work!"+error.getMessage());
                    }
        }){
            @Override
            protected  Map<String,String> getParams() {
                Map<String,String> params = new HashMap<String, String>();
                params.put("a","test value");
                return params;
            }

           @Override
            public  Map<String,String> getHeaders() {
               Map<String,String> params = new HashMap<String, String>();
               params.put("Content-Type","application/x-www-form-urlencoded");
                return params;
            }
        };
        queue.add(stringRequest);

{"success":false,"data":{"message":"Wrong user credentials.","errorCode":48}}

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ProgressBar;

import com.android.volley.AuthFailureError;
import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.Response.Listener;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.JsonObjectRequest;
import com.android.volley.toolbox.StringRequest;
import com.android.volley.toolbox.Volley;

import org.json.JSONException;
import org.json.JSONObject;

import java.util.HashMap;
import java.util.Map;

public class MainActivity extends AppCompatActivity {

    /**
     * Logcat tag
     */
    private static final String TAG = MainActivity.class.getSimpleName();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        final EditText usernameEditText = findViewById(R.id.username);
        final EditText passwordEditText = findViewById(R.id.password);
        final Button loginButton = findViewById(R.id.login);
        final ProgressBar loadingProgressBar = findViewById(R.id.loading);

        loginButton.setOnClickListener(new View.OnClickListener() {

            private static final String URL_LOGIN = "http://logintest.moveon.pro";
            //private static final String URL_LOGIN = "http://logintest.moveon.pro/?rest_route=/simple-jwt-login/v1/auth&email=Email&password=Password";
            private static final String route = "/simple-jwt-login/v1/auth";

            @Override
            public void onClick(View v) {

                // Build the request payload -- tried not working better
                final JSONObject jsonObject = new JSONObject();
                try {
                    jsonObject.put("rest_route", "/simple-jwt-login/v1/auth");
                    jsonObject.put("email", "john@domain.com");
                    jsonObject.put("password", "ghjghjk");
                 } catch (JSONException e) {
                    e.printStackTrace();
                }

                // Instantiate the RequestQueue.
                RequestQueue queue = Volley.newRequestQueue(getApplicationContext());

                //Tried different ways of sending the request :
                //String url = "http://logintest.moveon.pro/?rest_route=/simple-jwt-login/v1/auth&email=Email&password=Password";
                //String url = "http://logintest.moveon.pro/wp-json/?rest_route=/simple-jwt-login/v1/auth&email=Email&password=Password";
                String url = "http://logintest.moveon.pro/";

                int test = 3;
                if (test == 0) {
                    // Request a string response from the provided URL.
                    StringRequest sr = new StringRequest(Request.Method.POST, url,
                            new Response.Listener<String>() {
                                @Override
                                public void onResponse(String response) {
                                    Log.e("HttpClient", "success! response: " + response.toString());
                                    // Display the first 500 characters of the response string.
                                    usernameEditText.setText("Response is: " + response.toString().substring(0, 500));
                                }
                            },
                            new Response.ErrorListener() {
                                @Override
                                public void onErrorResponse(VolleyError error) {
                                    usernameEditText.setText("That didn't work!");
                                    Log.e("HttpClient", "error: " + error.toString());
                                }
                            }) {
                        @Override
                        protected Map<String, String> getParams() {
                            Map<String, String> params = new HashMap<String, String>();
                            params.put("rest_route", "/simple-jwt-login/v1/auth");
                            params.put("email", "asdasd");
                            params.put("password", "ghjghjk");
                            return params;
                        }

                        //Tried with adding params in Body... but not working better
                        @Override
                        public byte[] getBody() throws AuthFailureError {
                            HashMap<String, String> params2 = new HashMap<String, String>();
                            params2.put("rest_route", "/simple-jwt-login/v1/auth");
                            params2.put("email", "john@domain.com");
                            params2.put("password", "ghjghjk");
                            return new JSONObject(params2).toString().getBytes();
                        }

                        //Tried defining the Body content in different ways... but not working better
                        @Override
                        public String getBodyContentType() {
                            return "application/json; charset=UTF-8";
                        }
                        @Override
                        public Map<String, String> getHeaders() throws AuthFailureError {
                            HashMap<String, String> headers = new HashMap<String, String>();
                            //headers.put("Content-Type", "application/x-www-form-urlencoded;  charset=UTF-8");
                            //headers.put("Content-Type","application/x-www-form-urlencoded");
                            headers.put("Content-Type", "application/json;  charset=UTF-8");
                            return headers;

                        }

                    };
                    // Add the request to the RequestQueue.
                    queue.add(sr);

                } else if (test == 1) {


                    Map<String, String> params = new HashMap<String, String>();
                    params.put("rest_route", "/simple-jwt-login/v1/auth");
                    params.put("email", "asdasd");
                    params.put("password", "ghjghjk");
                    JSONObject parameters = new JSONObject(params);


                    // Request a string response from the provided URL.
                    JsonObjectRequest stringRequest1 = new JsonObjectRequest(Request.Method.POST, url, parameters,
                            new Listener<JSONObject>() {
                                @Override
                                public void onResponse(JSONObject response) {
                                    // Display the first 500 characters of the response string.
                                    usernameEditText.setText("Response is: " + response.toString().substring(0, 500));

                                }
                            }, new Response.ErrorListener() {
                        @Override
                        public void onErrorResponse(VolleyError error) {
                            usernameEditText.setText("That didn't work!");
                        }
                    }) {
                        @Override
                        protected Map<String, String> getParams() {
                            Map<String, String> params = new HashMap<String, String>();
                            params.put("rest_route", "/simple-jwt-login/v1/auth");
                            params.put("email", "asdasd");
                            params.put("password", "ghjghjk");
                            return params;
                        }

                        @Override
                        public Map<String, String> getHeaders() throws AuthFailureError {
                            HashMap<String, String> headers = new HashMap<String, String>();
                            headers.put("Content-Type", "application/x-www-form-urlencoded;  charset=UTF-8");
                            //headers.put("Content-Type", "application/json");
                            return headers;

                        }
                    };
                    // Add the request to the RequestQueue.
                    queue.add(stringRequest1);

                } else if (test == 3) {

                    Map<String, String> params = new HashMap();
                    params.put("rest_route", "/simple-jwt-login/v1/auth");
                    params.put("email", "john@domain.com");
                    params.put("password", "ghjghjk");

                    CustomVolleyRequest strReq = new CustomVolleyRequest(Request.Method.POST, url, params, new Response.Listener<JSONObject>() {
                        @Override
                        public void onResponse(JSONObject response) {
                            Log.e("HttpClient", "success! response: " + response.toString());
                            // Display the first 500 characters of the response string.
                            usernameEditText.setText("Response is: " + response.toString().substring(0, 500));
                        }
                    },
                            new Response.ErrorListener() {
                                @Override
                                public void onErrorResponse(VolleyError error) {
                                    usernameEditText.setText("That didn't work!");
                                    Log.e("HttpClient", "error: " + error.toString());
                                }
                            }) ;
                }
            }
        });

    }

}

package com.example.logintest;

import java.io.UnsupportedEncodingException;
import java.util.Map;

import org.json.JSONException;
import org.json.JSONObject;

import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.Response.ErrorListener;
import com.android.volley.Response.Listener;
import com.android.volley.toolbox.HttpHeaderParser;

public class CustomVolleyRequest extends Request<JSONObject> {

    private Listener<JSONObject> listener;
    private Map<String, String> params;

    public CustomVolleyRequest(String url, Map<String, String> params, Listener<JSONObject> responseListener, ErrorListener errorListener) {
        super(Method.GET, url, errorListener);
        this.listener = responseListener;
        this.params = params;
    }

    public CustomVolleyRequest(int method, String url, Map<String, String> params, Listener<JSONObject> responseListener, ErrorListener errorListener) {
        super(method, url, errorListener);
        this.listener = responseListener;
        this.params = params;
    }

    protected Map<String, String> getParams()
            throws com.android.volley.AuthFailureError {
        return params;
    }


    @Override
    protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) {
        try {
            String jsonString = new String(response.data,
                    HttpHeaderParser.parseCharset(response.headers));
            return Response.success(new JSONObject(jsonString),
                    HttpHeaderParser.parseCacheHeaders(response));
        } catch (UnsupportedEncodingException e) {
            return Response.error(new ParseError(e));
        } catch (JSONException je) {
            return Response.error(new ParseError(je));
        }
    }

    @Override
    protected void deliverResponse(JSONObject response) {
        // TODO Auto-generated method stub
        listener.onResponse(response);
    }
}

MultipartRequest request = new MultipartRequest(putURLPath,
                    hashMap,
                    null,
                    new Response.Listener<String>() {
                        @Override
                        public void onResponse(String response) {
                            try {
                                Log.d(TAG, "FILE_UPLOAD_RESPONSE: " + response);
                                Logger.writeToFile(TAG, "FILE_UPLOAD_RESPONSE: " + response);

                                if (fileUploadListener != null)
                                    fileUploadListener.onAttachmentFileUpload(generateImageUploadResponse(false, getURLPath), message, isRetry);
//                                fileDownload(getURLPath);
                            } catch (Exception e) {
                                e.printStackTrace();
                                if (fileUploadListener != null)
                                    fileUploadListener.onAttachmentFileUpload(generateImageUploadResponse(true, ""), message, isRetry);
                            }
                        }
                    }, new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError error) {
                    Logger.writeToFile(TAG, "FILE_UPLOAD_RESPONSE--Error: " + error.getMessage());
                   /* byte[] bytes = ((NetworkResponse)((AuthFailureError)error).networkResponse).data;
                    WAAFILogger.d(TAG, "XML: " + bytes.);*/
                    if (fileUploadListener != null)
                        fileUploadListener.onAttachmentFileUpload(generateImageUploadResponse(true, ""), message, isRetry);
                    error.printStackTrace();
                }
            }, new IMultipartProgressListener() {
                @Override
                public void transferred(long transferred, int progress) {
                    WAAFILogger.d(TAG, "Transferred : " + transferred + "\n" + " Progress : " + progress);

                    try {
                        if (fileUploadListener != null) {
                            fileUploadListener.onProgressChanged(message, progress);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                }
            }, bytesArray) {

                @Override
                public String getBodyContentType() {
                    return fileInfo.fileMimeType;
                }

                @Override
                public Map<String, String> getHeaders() throws AuthFailureError {
                    Map<String, String> params = new HashMap<String, String>();
                    params.put("content-length", String.valueOf(bytesArray.length));
                    params.put("host", IMConstant.XMPP_SERVER + ":9000");

                    Logger.writeToFile(TAG, params.get("content-length"));
                    Logger.writeToFile(TAG, params.get("host"));
                    return params;
                }

            };


            request.setRetryPolicy(com.safarifone.settings.Settings.policy);
            VolleyQueManager.getInstance().addToRequestQueue(request);

public class MultipartRequest extends Request<String> {

    private final byte[] byteArray;
    MultipartEntityBuilder entity = MultipartEntityBuilder.create();
    //        CounterHttpEntity httpentity;
    HttpEntity httpentity;
    //        CountingHttpEntity httpentity;
    private FileUploadManager.IMultipartProgressListener mProgressListener;

    private final Response.Listener<String> mListener;
    private HashMap<String, File> mFiles;
    private HashMap<String, String> mBody;
    private long fileLength = 0L;

    public MultipartRequest(String url,
                            HashMap<String, File> mFiles,
                            HashMap<String, String> body,
                            Response.Listener<String> listener,
                            Response.ErrorListener errorListener,
                            FileUploadManager.IMultipartProgressListener progressListener, byte[] bytesArray) {

        super(Method.PUT, url, errorListener);

        this.mListener = listener;
        this.mFiles = mFiles;
        this.mBody = body;
        this.fileLength = /*getFileLength()*/ bytesArray.length;
        this.mProgressListener = progressListener;
        this.byteArray = bytesArray;

        entity.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
        try {
            entity.setCharset(CharsetUtils.get("UTF-8"));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        buildMultipartEntity();

        httpentity = entity.build();
        /*httpentity.setFileLength(fileLength);
        httpentity.setmProgressListener(progressListener);*/

    }

    private void buildMultipartEntity() {    
        for (Map.Entry<String, File> entry : mFiles.entrySet()) {
            if (entry.getValue() != null) {
                entity.addPart(entry.getKey(), new FileBody(entry.getValue()));
            }
        }

        if (mBody != null) {
            for (Map.Entry<String, String> entry : mBody.entrySet()) {
                if (entry.getValue() != null) {
                    entity.addTextBody(entry.getKey(), entry.getValue());
                }
            }
        }
    }

    private int getFileLength() {
        int lgth = 0;
        for (Map.Entry<String, File> entry : mFiles.entrySet()) {
            if (entry.getValue() != null) {
                lgth += entry.getValue().length();
            }
        }
        System.out.println("lgth = " + lgth);
        return lgth;
    }

    @Override
    public String getBodyContentType() {
        return super.getBodyContentType();
        /*return httpentity.getContentType().getValue();*/
    }

    @Override
    public byte[] getBody() throws AuthFailureError {
        Thread thread = new Thread() {
            @Override
            public void run() {
                super.run();
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                try {
                    bos.write(byteArray, 0, byteArray.length);
                    httpentity.writeTo(new CountingOutputStream(bos, fileLength,
                            mProgressListener));
                } catch (IOException e) {
                    VolleyLog.e("IOException writing to ByteArrayOutputStream");
                }
            }
        };
        thread.start();

        return /*bos.toByteArray()*/ byteArray;
    }

    @Override
    protected Response<String> parseNetworkResponse(NetworkResponse response) {

        try {
            String jsonString = new String(response.data,
                    HttpHeaderParser.parseCharset(response.headers));

            return Response.success(jsonString,
                    HttpHeaderParser.parseCacheHeaders(response));

        } catch (UnsupportedEncodingException e) {
            return Response.error(new ParseError(e));
        }
    }

    @Override
    protected void deliverResponse(String response) {
        mListener.onResponse(response);
    }

    public static class CountingOutputStream extends FilterOutputStream {
        private final FileUploadManager.IMultipartProgressListener progressListener;
        private long transferred;
        private long fileLength;
        private int lastProgress = 0;

        public CountingOutputStream(final OutputStream out, long fileLength,
                                    final FileUploadManager.IMultipartProgressListener listener) {
            super(out);
            this.fileLength = fileLength;
            this.progressListener = listener;
            this.transferred = 0;
        }

        public void write(byte[] buffer, int offset, int length) throws IOException {
            out.write(buffer, offset, length);
            if (progressListener != null) {
                this.transferred += length;
                int progress = (int) ((transferred * 1000.0f) / fileLength);
                if (lastProgress != progress) {
                    this.progressListener.transferred(this.transferred, progress);
                }
            }
        }

        public void write(int oneByte) throws IOException {
            out.write(oneByte);
            if (progressListener != null) {
                this.transferred++;
                int progress = (int) ((transferred * 1000.0f) / fileLength);
                if (lastProgress != progress) {
                    this.progressListener.transferred(this.transferred, progress);
                }
            }
        }
    }

}