object GoSDKCreator {
 
    // App ApiKey and Secret
    private const val API_KEY = YOUR_API_KEY
    private const val API_SECRET = YOUR_API_SECRET      
    private fun buildConfig(context: Context) = GoSdkConfiguration.Builder(
        context = context,
        appId = BuildConfig.APPLICATION_ID,
        appVersion = "1.0.0",
        apiKey = API_KEY,
        apiSecret = API_SECRET,
        oAuthFlowAppSecret = YOUR_OAUTH_FLOW_APP_SECRET,
        oAuthFlowRedirectURI = YOUR_OAUTH_FLOW_REDIRECT_URI,
        oAuthFlowAppID = YOUR_OAUTH_FLOW_APP_ID,
        environment = GoSdkConfiguration.Environment.SANDBOX,//Available environments are PROD, DEV, STAGING and SANDBOX
        reconnectLastConnectedReader = true
    )
    .build()
 
    private lateinit var goSdkInstance: GoSdk
 
    @JvmStatic
    fun get(context: Context): GoSdk {
        if (!GoSDKCreator::goSdkInstance.isInitialized) {
            goSdkInstance = GoSdkCreator.create(buildConfig(context))
        }
        return goSdkInstance
    }
}

public class GoSdkCreatorJava {
    // Companion App ApiKey and Secret
    private static final String API_KEY = YOUR_API_KEY;
    private static final String API_SECRET = YOUR_API_SECRET;
 
    private GoSdk goSdkInstance;
 
    private GoSdkConfiguration buildConfig(Context context) {
        return new GoSdkConfiguration.Builder(
                context,
                BuildConfig.APPLICATION_ID,
                YOUR_REDIRECT_URI,
                YOUR_APP_ID,
                YOUR_APP_SECRET,
                "1.0.0",  //app version
                API_KEY,
                API_SECRET,
                null,  //api access token
                GoSdkConfiguration.Environment.SANDBOX,//Available environments are PROD, DEV, STAGING and SANDBOX
                false, //Deprecated field
                false, //Deprecated field
                true   //reconnectLastConnectedReader
         ).build();
    }
 
    public GoSdk get(Context context) {
        if (goSdkInstance == null) {
            goSdkInstance = GoSdkCreator.Companion.create(buildConfig(context));
        }
        return goSdkInstance;
    }
}

goSdk.observeCardReaderStatus(viewLifecycleOwner, cardReaderStatusCallback)
 
val cardReaderStatusCallback = object : GoSdkCallback<CardReaderStatus> {
    override fun onError(e: Throwable) {
        //handle error scenario
    }
 
    override fun onNext(result: CardReaderStatus) {
        // publish it or save in ViewModel?.. anything you want
        when (result) {
            is CardReaderStatus.BatteryPercentChanged -> {}
            is CardReaderStatus.BleFirmwareUpdateInProgress -> {}
            is CardReaderStatus.CheckingForUpdate -> {}
            is CardReaderStatus.Connected -> {}
            is CardReaderStatus.Connecting -> {}
            is CardReaderStatus.Deleted -> {
                //this is where someone will update UI to disable payment taking UI
            }
            is CardReaderStatus.Disconnected -> {
                //this is where someone will update UI to disable payment taking UI
            }
            is CardReaderStatus.Ready -> {
                //this is where someone will update UI to take a payment
            }
        }
        is CardReaderStatus.ResetInProgress -> {}
        is CardReaderStatus.RkiInProgress -> {}
        is CardReaderStatus.SpFirmwareUpdateInProgress -> {}
        is CardReaderStatus.UpdateComplete -> {}
    }
}

goSdk.observeCardReaderStatus(this, new GoSdkCallback<CardReaderStatus>() {
        @Override
        public void onNext(CardReaderStatus cardReaderStatus) {
            // publish it or save in ViewModel?.. anything you want
            switch (cardReaderStatus.toString()) {
                case "BatteryPercentChanged":
                case "BleFirmwareUpdateInProgress":
                case "CheckingForUpdate":
                case "Connected":
                case "Connecting":
                case "Deleted": //this is where someone will update UI to disable payment taking UI
                case "Disconnected": //this is where someone will update UI to disable payment taking UI
                case "Ready: ${result.readerInfo.serialNo}": //this is where someone will update UI to take a payment
                case "ResetInProgress":
                case "RkiInProgress":
                case "SpFirmwareUpdateInProgress":
                case "UpdateComplete":
            }
        }
 
        @Override
        public void onError(@NonNull Throwable throwable) {
              //handle error scenario
        }
    });

val request = PayRequest(
    final = true, //true for Sales, false for Auth or PreAuth Transactions
    capture = true, //true for Sales, true for Auth, false for PreAuth Transactions
    amount = 100L,
    taxAmount = 0L,
    tipAmount = 0L,
    externalPaymentId = "pay-id", //Can be null
    externalReferenceId = "invoice-num", //can be null
    keyedInCard = null //Card value can be filled in, if you want to take payment w/o cardReader
)
 
// Clover recommends that you wait to initiate a charge request until the CardReaderStatus.READY event is emitted 
 
goSdk.chargeCardReader(
    request
).collectLatest {
 //We suggest logging or updating the UI with the transaction status so you follow the transaction steps
 //and to know if the device is waiting for a user action (i.e. if the device is waiting for a card to be inserted or tapped)
 updateUIWithCardReaderState(it)
}
 
private fun updateUIWithCardReaderState(it: ChargeCardReaderState) {
    updateTransactionLog(
        when (it) {
            is ChargeCardReaderState.OnPaymentComplete -> "OnPaymentComplete: ${it.response}"
            is ChargeCardReaderState.OnPaymentError -> "OnPaymentError: $it"
            is ChargeCardReaderState.OnReaderPaymentProgress -> "OnReaderPaymentProgress: ${it.event}"
        }.toString()
    )
}

PayRequest request = new PayRequest(
                        10000L,
                        true,
                        true,
                        "pay-id",
                        "invoice num",
                        10L,
                        1000L,
                        keyedInCard);
 
// Clover recommends that you wait to initiate a charge request until the CardReaderStatus.READY event is emitted  
 
goSdk.chargeCardReader(
    this, //In this context, "this" means the activity. If in a fragment, the viewLifeCycleOwner is required
    request,
    new GoSdkCallback<ChargeCardReaderState>() {        
        @Override
        public void onNext(ChargeCardReaderState result) {
            Log.i("TAG", result.toString());
         
            if (result instanceof PaymentState.OnPaymentComplete) {
                handlePaymentComplete((PaymentState.OnPaymentComplete) result);
            }
        }
 
        @Override
        public void onError(@NonNull Throwable e) {
            Log.i("TAG", e.getMessage());
        }
     }
);

package com.example.gosdkintro
 
import android.Manifest
import android.content.DialogInterface
import android.content.pm.PackageManager
import android.os.Build
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Toast
import androidx.appcompat.app.AlertDialog
import androidx.core.app.ActivityCompat
import androidx.lifecycle.lifecycleScope
import com.clover.sdk.gosdk.GoSdk
import com.clover.sdk.gosdk.model.PayRequest
import com.clover.sdk.gosdk.payment.domain.model.CardReaderStatus
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.launch
 
class MainActivity : AppCompatActivity() {
    private val goSdk: GoSdk by lazy { GoSDKCreator.get(this) }
 
    private val requiredPermissions = when {
        Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> arrayOf(
            Manifest.permission.BLUETOOTH_CONNECT,
            Manifest.permission.BLUETOOTH_SCAN,
        )
        Build.VERSION.SDK_INT <= Build.VERSION_CODES.P -> arrayOf(
            Manifest.permission.ACCESS_COARSE_LOCATION
        )
        else -> arrayOf(
            Manifest.permission.ACCESS_FINE_LOCATION
        )
    }
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
 
        ActivityCompat.requestPermissions(
            this,
            requiredPermissions,
            REQUEST_PERMISSION_CODE
        )
    }
 
    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        val permissionsList = ArrayList<String>()
        if (requestCode == REQUEST_PERMISSION_CODE && grantResults.isNotEmpty()) {
            for (i in permissions.indices) {
                if (grantResults[i] == PackageManager.PERMISSION_DENIED) {
                    permissionsList.add(permissions[i])
                }
            }
 
            if (permissionsList.isEmpty()) {
                permissionsGranted()
            } else {
                var showRationale = false
 
                for (permission in permissionsList) {
                    if (ActivityCompat.shouldShowRequestPermissionRationale(this, permission)) {
                        showRationale = true
                        break
                    }
                }
 
                if (showRationale) {
                    showAlertDialog(
                        { _, _ ->
                            ActivityCompat.requestPermissions(
                                this,
                                permissionsList.toTypedArray(),
                                REQUEST_PERMISSION_CODE
                            )
                        },
                        { _, _ ->
                            permissionsDenied()
                        }
                    )
                }
            }
        }
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
    }
 
    private fun showAlertDialog(
        okListener: DialogInterface.OnClickListener,
        cancelListener: DialogInterface.OnClickListener
    ) {
        AlertDialog.Builder(this)
            .setMessage("Some permissions are not granted. Application may not work as expected. Do you want to grant them?")
            .setPositiveButton("OK", okListener)
            .setNegativeButton("Cancel", cancelListener)
            .create()
            .show()
    }
 
    private fun permissionsDenied() {
        Toast.makeText(this, "Permissions Denied!", Toast.LENGTH_SHORT).show()
    }
 
 
    private fun permissionsGranted() {
        Toast.makeText(this, "Permissions granted!", Toast.LENGTH_SHORT).show()
 
        lifecycleScope.launch {
            goSdk.scanForReaders().collectLatest { reader ->
                //This callback will hit for every device found
                //Once you found the device you want to connect to, call the line below
                goSdk.connect(reader)
            }
        }
 
        lifecycleScope.launch {
            goSdk.observeCardReaderStatus().collectLatest {
                println(it)
 
                if (it is CardReaderStatus.Ready) {
                    val request = PayRequest(
                        final = true, //true for Sales, false for Auth or PreAuth Transactions
                        capture = true, //true for Sales, true for Auth, false for PreAuth Transactions
                        amount = 100L,
                        taxAmount = 0L,
                        tipAmount = 0L,
                        externalPaymentId = null
                    )
                    goSdk.chargeCardReader(request).collectLatest { chargeState ->
                        println(chargeState)
                    }
                }
            }
        }
    }
 
    companion object {
        const val REQUEST_PERMISSION_CODE = 100
    }
}

package com.example.gosdkintro;
 
import android.Manifest;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.widget.Toast;
 
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
 
import com.clover.sdk.gosdk.GoSdk;
import com.clover.sdk.gosdk.core.domain.model.ReaderInfo;
import com.clover.sdk.gosdk.model.PayRequest;
import com.clover.sdk.gosdk.models.ChargeCardReaderState;
import com.clover.sdk.gosdk.models.GoSdkCallback;
import com.clover.sdk.gosdk.models.PaymentState;
import com.clover.sdk.gosdk.payment.domain.model.CardReaderStatus;
 
import java.util.ArrayList;
import java.util.Arrays;
 
 
public class MainActivity extends AppCompatActivity {
    private GoSdk goSdk;
 
    private final MainActivity activity = this;
 
    private final int REQUEST_PERMISSION_CODE = 100;
 
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
 
        goSdk = GoSdkCreatorJava.get(activity);
 
        String[] requiredPermissions = new String[]{Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION};
 
        // Get Bluetooth permissions to connect to the reader
        ActivityCompat.requestPermissions(
                this,
                requiredPermissions,
                REQUEST_PERMISSION_CODE
        );
    }
 
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        ArrayList<String> permissionsList = new ArrayList<>();
 
        if (requestCode == REQUEST_PERMISSION_CODE && grantResults.length != 0) {
            for (int i = 0; i < permissions.length; i++) {
                if (grantResults[i] == PackageManager.PERMISSION_DENIED) {
                    permissionsList.add(permissions[i]);
                }
            }
 
            if (permissionsList.size() == 0) {
                permissionsGranted();
            } else {
                boolean showRationale = false;
 
                for (int i = 0; i < permissionsList.size(); i++) {
                    String permission = permissionsList.get(i);
 
                    if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
                        showRationale = true;
                        break;
                    }
                }
 
                if (showRationale) {
                    DialogInterface.OnClickListener okListener = (dialogInterface, i) -> {
                        String[] permissionsArray = Arrays.copyOf(permissionsList.toArray(), permissionsList.size(), String[].class);
                        ActivityCompat.requestPermissions(
                                activity,
                                permissionsArray,
                                REQUEST_PERMISSION_CODE
                        );
                    };
 
                    DialogInterface.OnClickListener cancelListener = (dialogInterface, i) -> permissionsDenied();
 
                    showAlertDialog(okListener, cancelListener);
                }
            }
        }
 
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }
 
    private void permissionsGranted() {
        Toast.makeText(this, "Permissions granted!", Toast.LENGTH_SHORT).show();
 
        goSdk.scanForReaders(activity, new GoSdkCallback<ReaderInfo>() {
            @Override
            public void onNext(ReaderInfo readerInfo) {
                //This callback will hit for every device found
                //Once you found the device you want to connect to, call the line below
                goSdk.connect(readerInfo);
            }
 
            @Override
            public void onError(@NonNull Throwable throwable) {
                //handle error scenario
            }
        });
 
        goSdk.observeCardReaderStatus(
                activity,
                new GoSdkCallback<CardReaderStatus>() {
                    @Override
                    public void onNext(CardReaderStatus cardReaderStatus) {
                        // Ready status means the updates are done, if any and we are ready to take the payment
                        if (cardReaderStatus instanceof CardReaderStatus.Ready) {
                            PayRequest request = new PayRequest(10000L, true, true, "pay-id", "invoice num", 10L, 1000L, null);
                            goSdk.chargeCardReader(
                                    activity,
                                    request,
                                    new GoSdkCallback<ChargeCardReaderState>() {
                                        @Override
                                        public void onNext(ChargeCardReaderState result) {
                                            // Let's do some actual work
                                            if (result instanceof PaymentState.OnPaymentComplete) {
                                                handlePaymentComplete((PaymentState.OnPaymentComplete) result);
                                            }
                                        }
 
                                        @Override
                                        public void onError(@NonNull Throwable e) {
                                            //handle error scenario
                                        }
                                    }
                            );
                        }
                    }
 
                    @Override
                    public void onError(@NonNull Throwable throwable) {
                        //handle error scenario
                    }
                }
        );
    }
 
    private void handlePaymentComplete(@NonNull PaymentState.OnPaymentComplete event) {
        //save it to our ViewModel.... Will help with other operations like printing receipts
    }
 
 
    private void permissionsDenied() {
        Toast.makeText(this, "Permissions Denied!", Toast.LENGTH_SHORT).show();
    }
 
    private void showAlertDialog(
            DialogInterface.OnClickListener okListener,
            DialogInterface.OnClickListener cancelListener
    ) {
        new AlertDialog.Builder(this)
                .setMessage("Some permissions are not granted. Application may not work as expected. Do you want to grant them?")
                .setPositiveButton("OK", okListener)
                .setNegativeButton("Cancel", cancelListener)
                .create()
                .show();
    }
}