GCM(Google Cloud Messaging) Integration in android

Work is under progress...

public interface APIResponseReceiver {

    int onDataReceived(String response);

    void getResult(int resultCode);
}

import android.content.Context;
import android.util.Log;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Map;


/** * Created by Yograj Shinde on 1/9/15,2:30 PM. */public class CallAPI {

    private final String TAG = "Mehboob";
    private Context mContext;
    private String response = "";
    private URL mUrl;
    private HttpURLConnection httpURLConnection;

    public CallAPI(Context context) {
        this.mContext = context;
    }

    /**     * This method will upload image and return response     */    public String uploadImage(String url, String imagePath, String keyName ,HashMap<String, String> postDataParams) {
        DataOutputStream dos;
        String lineEnd = "\r\n";
        String twoHyphens = "--";
        String boundary = "*****";
        int bytesRead, bytesAvailable, bufferSize;
        byte[] buffer;
        int maxBufferSize = 1024 * 1024; // 1 * 1024 * 1024
        File sourceFile = new File(imagePath);
        FileInputStream fileInputStream;
        response = "";

        try {
            mUrl = new URL(url);
        } catch (MalformedURLException e) {
            e.printStackTrace();
            mUrl = null;
        }
        if (mUrl != null) {
            Log.d(TAG, "File path:- " + imagePath);
            if (sourceFile.isFile()) {
                try {
                    fileInputStream = new FileInputStream(sourceFile);

                    // Open a HTTP  connection to  the URL                    httpURLConnection = (HttpURLConnection) mUrl.openConnection();
                    httpURLConnection.setDoInput(true);
                    httpURLConnection.setDoOutput(true);
                    httpURLConnection.setUseCaches(false); // Don't use cached copy                    httpURLConnection.setRequestMethod("POST");
                    httpURLConnection.setRequestProperty("Connection", "Keep-Alive");
                    httpURLConnection.setRequestProperty("Content-Type", "multipart/form-data;boundary=" + boundary);

                    dos = new DataOutputStream(httpURLConnection.getOutputStream());

                    //Add HashMap Data here                   // dos.writeBytes(getPostDataString(postDataParams));                    for (Map.Entry<String, String> entry : postDataParams.entrySet()) {

                        // add parameters                        dos.writeBytes(twoHyphens + boundary + lineEnd);
                        dos.writeBytes("Content-Disposition: form-data; name=" + entry.getKey()
                                + lineEnd);
                        dos.writeBytes(lineEnd);

                        // assign value                        dos.writeBytes(entry.getValue());
                        dos.writeBytes(lineEnd);
                        dos.writeBytes(twoHyphens + boundary + lineEnd);
                    }

                    // send image                    dos.writeBytes(twoHyphens + boundary + lineEnd);
                    dos.writeBytes("Content-Disposition: form-data; name=\""+keyName+"\";filename=\"" + sourceFile.getName() + "\"" + lineEnd);
                    dos.writeBytes(lineEnd);

                    // create a buffer of  maximum size                    bytesAvailable = fileInputStream.available();

                    bufferSize = Math.min(bytesAvailable, maxBufferSize);
                    buffer = new byte[bufferSize];

                    // read file and write it into form...                    bytesRead = fileInputStream.read(buffer, 0, bufferSize);

                    while (bytesRead > 0) {
                        dos.write(buffer, 0, bufferSize);
                        bytesAvailable = fileInputStream.available();
                        bufferSize = Math.min(bytesAvailable, maxBufferSize);
                        bytesRead = fileInputStream.read(buffer, 0, bufferSize);
                    }

                    // send multipart form data necessary after file data...                    dos.writeBytes(lineEnd);
                    dos.writeBytes(twoHyphens + boundary + twoHyphens + lineEnd);

                    int serverResponseCode = httpURLConnection.getResponseCode();
                    Log.i(TAG, "Server Response Code:- " + serverResponseCode);
                    Log.i(TAG, "Server Response Message:- " + httpURLConnection.getResponseMessage());

                    InputStream inputStream = httpURLConnection.getInputStream();
                    response = convertStreamToString(inputStream);

                    //close the streams                    fileInputStream.close();
                    dos.flush();
                    dos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return response;
    }

    /**     * This method will call webservice and returns response     */    public String getAPIResponse(String url, HashMap<String, String> postDataParams) {
        response = "";
        try {
            mUrl = new URL(url);
        } catch (MalformedURLException e) {
            e.printStackTrace();
            mUrl = null;
        }
        if (mUrl != null) {


            try {
                // Open a HTTP  connection to  the URL                httpURLConnection = (HttpURLConnection) mUrl.openConnection();
                httpURLConnection.setDoInput(true);
                httpURLConnection.setDoOutput(true);
                httpURLConnection.setUseCaches(false);
                httpURLConnection.setConnectTimeout(15000);
                httpURLConnection.setReadTimeout(20000);
                httpURLConnection.setRequestMethod("POST");
                httpURLConnection.setRequestProperty("Content-Type",
                        "application/x-www-form-urlencoded");
                DataOutputStream wr = new DataOutputStream(httpURLConnection.getOutputStream());
                wr.writeBytes(getPostDataString(postDataParams));
                wr.flush();
                wr.close();
                InputStream inputStream = httpURLConnection.getInputStream();
                response = convertStreamToString(inputStream);
                httpURLConnection.disconnect();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return response;
    }

    private String convertStreamToString(InputStream inputstream) {
        String line;
        StringBuilder total = new StringBuilder();
        BufferedReader rd = new BufferedReader(new InputStreamReader(
                inputstream));
        try {
            while ((line = rd.readLine()) != null) {
                total.append(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return total.toString();
    }

    private String getPostDataString(HashMap<String, String> params) throws UnsupportedEncodingException {
        StringBuilder result = new StringBuilder();
        boolean first = true;
        if (params == null || params.isEmpty()) {
            result.append("");
        } else {
            for (Map.Entry<String, String> entry : params.entrySet()) {
                if (first)
                    first = false;
                else                    result.append("&");

                result.append(URLEncoder.encode(entry.getKey(), "UTF-8"));
                result.append("=");
                result.append(URLEncoder.encode(entry.getValue(), "UTF-8"));
            }
        }
        Log.d(TAG, "Param:- " + result.toString());
        return result.toString();
    }
}








package com.eeshana.qisma.network;

import android.app.ProgressDialog;
import android.content.Context;
import android.os.AsyncTask;
import android.util.Log;

import com.eeshana.qisma.R;
import com.eeshana.qisma.utilities.CommonUsage;
import com.eeshana.qisma.utilities.Config;

import java.util.HashMap;


/** * Created by Yograj Shinde on 23/7/15,12:58 PM. */public class MyAsyncTask {
    private Context mContext;
    private ProgressDialog pDialog;
    private CallAPI callAPI;
    private String mURL;
    private HashMap<String, String> arr_param = new HashMap<>();
    private APIResponseReceiver apiResponseReceiver;
    public static String errorMSG = "";
    private CommonUsage mCommonUsage;

    public MyAsyncTask(Context mContext, String url, HashMap<String, String> arr_param, APIResponseReceiver responseReceiver) {
        this.mContext = mContext;
        this.arr_param = arr_param;
        this.apiResponseReceiver = responseReceiver;
        mURL = url;
        mCommonUsage = CommonUsage.getCommonUsageObj(mContext);
        callAPI = new CallAPI(mContext);
        new MyAsync().execute(arr_param);
    }

    class MyAsync extends AsyncTask<HashMap<String, String>, Integer, Integer> {

        @Override        protected void onPreExecute() {
            super.onPreExecute();
            mCommonUsage.showProgressDialog(mContext.getResources().getString(R.string.please_wait));
        }

        @Override        protected Integer doInBackground(HashMap... params) {
            String response = "";
            int resultCode = Config.RESULT_FAIL;
            try {
                response = callAPI.getAPIResponse(mURL, params[0]);
            } catch (Exception e) {
                e.printStackTrace();
                response = "";
            }
            Log.d(Config.TAG, "API Response:- " + response);
            resultCode = apiResponseReceiver.onDataReceived(response);
            return resultCode;
        }


        @Override        protected void onPostExecute(Integer resultCode) {
            super.onPostExecute(resultCode);
            mCommonUsage.dismissmPdialog();

            switch (resultCode) {
                case Config.RESULT_SERVER_ERROR:
                    mCommonUsage.showToast(mContext.getResources().getString(R.string.response_null_error));
                    break;
                case Config.RESULT_PARSE_ERROR:
                    mCommonUsage.showToast(mContext.getResources().getString(R.string.response_parse_error));
                    break;
                case Config.RESULT_FAIL:
                    //mCommonUsage.showToast(errorMSG);                    Log.i("API Status","API Other that 1 msg"+errorMSG);
                    apiResponseReceiver.getResult(Config.RESULT_FAIL);
                    break;
                case Config.RESULT_SUCCESS:
                    apiResponseReceiver.getResult(Config.RESULT_SUCCESS);
                    break;
            }
        }
    }
}






@Overridepublic int onDataReceived(String response) {
    if (response == null || response.equalsIgnoreCase("")) {
        return Config.RESULT_SERVER_ERROR;
    } else {
        try {
            JSONObject jsonObjResult = new JSONObject(response.trim());
            int status = jsonObjResult.getInt("status");
            if (status == 1) {
                if (jsonObjResult.has("data"))
                {
                    
                }

                return Config.RESULT_SUCCESS;
            } else {
               

                Log.i("Got Status","0 here");
                String error;
                if (jsonObjResult.has("statusInfo")) {
                    error = jsonObjResult.getString("statusInfo");
                } else {
                    error = getResources().getString(R.string.response_fail_error);
                }
                MyAsyncTask.errorMSG = error;
                return Config.RESULT_FAIL;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Config.RESULT_PARSE_ERROR;
        }
    }
}



@Overridepublic void getResult(int resultCode) {

    if (resultCode == Config.RESULT_SUCCESS) {
       }
}




public interface Config {

    String GCM_SENDER_ID = "";
    String TAG = "Mehboob App";

    // Result codes    int RESULT_FAIL = 0;
    int RESULT_SUCCESS = 1;
    int RESULT_SERVER_ERROR = 2;
    int RESULT_PARSE_ERROR = 3;

}


HashMap<String, String> param = new HashMap<String, String>();
param.put(ParamKeys.FB_ID, object.getString("id").toString());

if (comObj.isDeviceHasNetwork()) {
    isFbLodgedIn = true;
    new MyAsyncTask(LoginActivity.this, WebServiceURL.VERIFY_FB_ID, param, LoginActivity.this);
} else {
    comObj.showToast(getString(R.string.no_internet_connection));
}




public class CommonUsage {

    private static Context _mContext;
    private static CommonUsage _commonUsageObj;
    private ProgressDialog mProgressDialog;

    public static SharedPreferences common_user_data;

    //Default constructor    public CommonUsage(){}

    public static CommonUsage getCommonUsageObj(Context con){

        _mContext = con;
        if(_commonUsageObj == null)
            _commonUsageObj = new CommonUsage();
            return _commonUsageObj;
    }


   /**
 * This method will print toast at the center of the screen * **/public void showToast(String msg)
{
    Toast tstObj = Toast.makeText(_mContext, msg, Toast.LENGTH_SHORT);
    tstObj.setGravity(Gravity.CENTER, tstObj.getXOffset()/ 2, tstObj.getYOffset()/ 2);
    tstObj.show();
}


/** * Checking for all possible Internet providers * Returns true if connected else fails * * **/
public boolean isDeviceHasNetwork()
{
    ConnectivityManager connectivity = (ConnectivityManager)_mContext.
            getSystemService(Context.CONNECTIVITY_SERVICE);

    if(connectivity != null){
        NetworkInfo[] info = connectivity.getAllNetworkInfo();
        if(info != null)
            for (int i = 0; i < info.length; i++) {
                if(info[i].getState() == NetworkInfo.State.CONNECTED){
                    return true;
                }
            }
    }
    return false;
}


/*** This method will show the processing dialog with given msg** **/
public void showProgressDialog(String msg)
{
    mProgressDialog = new ProgressDialog(_mContext);
    mProgressDialog.setMessage(msg);
    mProgressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
    mProgressDialog.setCancelable(false);
    mProgressDialog.setCanceledOnTouchOutside(false);
    if(!((Activity)_mContext).isFinishing()){
        mProgressDialog.show();
    }
}


/** * This method will close the processing dialog which is running now. * * **/public void dismissmPdialog()
{
    try{

        if(mProgressDialog!=null)
        {
            mProgressDialog.dismiss();
            Log.i("GeneralNeedLibM", "progressDialog dismissed successfully");
        }else{
            Log.i("GeneralNeedLibM", "progressDialog dismiss error You might be trying to dismiss the progress dialog" +
                    "which is created with different context Or the progressDialog which not at all created");
        }

    }catch(Exception e)
    {
        e.printStackTrace();
        Log.i("GeneralNeedLibM", ""+e);
        Log.i("GeneralNeedLibM", "progressDialog dismiss exception You might be trying to dismiss the progress dialog" +
                "which is created with different context");
    }


}
}


/*Just Validate empty EditText*/public static boolean Is_Empty_EditText(EditText et){

    String text = et.getText().toString().trim();
    if(text.isEmpty() || text.length()== 0){
        et.requestFocus();
        et.setError("Required!");
    }else{
        et.setError(null);
        return true;
    }

    return false;
}

Stripe Integration in android

Stripe is the simple and best way to accept mobile payments inside any android app.

Steps are as below.

1) First you need to import Stripe library and add it to your project.

   

    On stripe.com you will get the stripe library but it will be a gr-addle support library, you need to convert it to Android project structure. 

2) Add android SDK with API level-17 and android-support-v4 to you SDK if it's not added.

3) Create the Dialog to retrieve Card information from user with the Cancel and Done buttons.        

 

    Required information for card constructor is 

    Card No :- 16 digit, Expiry Date:- MM/YY and Card CVC No :- 3 digit.

    For testing you can use 

    Card No;- 4242 4242 4242 4242

    Expiry Date:- 12/25 (any date grater from current date)

    CVC No :- 123 (any three digits)

    

    if user clicks on the done button of Dialog then get the card info and assign it to the Following fields,

        /*It's better if you create all these fields globally in class*/

        private int cardExpMonth,cardExpYear;

private String cardNumber = "",cardCVC = "";

private static String publishKey = "";

private static Card card;

        In my class I have created this method top retrieve card info from Payment-dialog 

private void getCardInfo()

{

cardNumber = firstFourDigit.getText().toString() + secondFourDigit.getText().toString() 

+ thirdFourDigit.getText().toString() + fourthFourDigit.getText().toString();

cardCVC = ccvCode.getText().toString();

String [] dateMonth =  expiryDate.getText().toString().split("/");

if(!dateMonth[0].isEmpty())

{

cardExpMonth = Integer.parseInt(dateMonth[0]);

if(dateMonth.length == 2 && !dateMonth[1].isEmpty())

{

cardExpYear = Integer.parseInt(dateMonth[1]);

}

}

}

After Successfully retrieving the Card info you need to Validate the Card info creating the card constructor like this

private boolean ValidateCard()

{

//boolean status = false;

card = new Card(

   cardNumber,    // It's String type

   cardExpMonth, //It's int type 2digit

   cardExpYear,  //It's int type 2 digit

   cardCVC    // It's String type

);

                  /*card.validateNumber() will simply validate the 16 digit no provided by the user returns true if the card no is correct false if card no is wrong.*/

if(!card.validateNumber())

{

/*showToast is the method which will Toast the passed String, you can simply call the                            Toast.makeToast.... as well */ 

                        showToast(R.string.invaliCardNo);

return false;

}else if(!card.validateExpiryDate())

{

showToast(R.string.invalideCardDate);

return false;

}else if(!card.validateCVC())

{

showToast(R.string.invalideCardCvc);

return false;

}

return true;

}

4) Get the Publish_key from you server, the publish key is the Stripe account info key. Normally client will provide this key.

create the Stripe instance and call create Token methods like this.

                 try {

Stripe stripe = new Stripe(publishKey);

stripe.createToken(card, 

new TokenCallback() {

@Override

public void onSuccess(Token token) {

Log.i("This is the stripe token here", ""+token);

/*If you enter into onSuccess then Stripe token is created                                                                            successfully, Next pass this token to your Server with                                                                              server required information and if you got success result                                                                          from you server then payment is done successfully.*/

}

@Override

public void onError(Exception error) {

 // Show localized error message

Toast.makeText(getContext(), R.string.transactionError,                                                                         Toast.LENGTH_SHORT).show();

}

});

} catch (AuthenticationException e) {

e.printStackTrace();

}