com.bbva.hancock.sdk.HancockSocket Maven / Gradle / Ivy
package com.bbva.hancock.sdk;
import com.bbva.hancock.sdk.exception.HancockErrorEnum;
import com.bbva.hancock.sdk.exception.HancockException;
import com.bbva.hancock.sdk.exception.HancockTypeErrorEnum;
import com.bbva.hancock.sdk.models.socket.*;
import com.google.gson.Gson;
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import static com.bbva.hancock.sdk.models.socket.HancockSocketMessageResponseKind.*;
public class HancockSocket {
private final WebSocketClient ws;
private final List> errorFunctions;
private final Map> callbackFunctions;
private final Map>> transactionFunctions;
private final Map>> contractsFunctions;
public HancockSocket(final String url) throws HancockException {
final URI wsUri;
try {
wsUri = new URI(url);
} catch (final URISyntaxException e) {
throw new HancockException(HancockTypeErrorEnum.ERROR_INTERNAL, "50003", 500, HancockErrorEnum.ERROR_SOCKET.getMessage(), HancockErrorEnum.ERROR_SOCKET.getMessage(), e);
}
errorFunctions = new ArrayList<>();
transactionFunctions = new HashMap<>();
contractsFunctions = new HashMap<>();
callbackFunctions = new HashMap<>();
ws = new WebSocketClient(wsUri) {
@Override
public void onOpen(final ServerHandshake handshakedata) {
executeFunction("ready", handshakedata);
}
@Override
public void onMessage(final String message) {
final Gson gson = new Gson();
final HancockSocketMessage hsm = gson.fromJson(message, HancockSocketMessage.class);
switch (hsm.getKind()) {
case TRANSFER:
case TRANSACTION:
case SMARTCONTRACTTRANSACTION:
case SMARTCONTRACTDEPLOYMENT:
final HancockSocketTransactionEvent transactionEvent = gson.fromJson(message, HancockSocketTransactionEvent.class);
executeEventFunction(transactionEvent, transactionFunctions);
break;
case SMARTCONTRACTEVENT:
final HancockSocketContractEvent contractEvent = gson.fromJson(message, HancockSocketContractEvent.class);
executeEventFunction(contractEvent, contractsFunctions);
break;
default:
executeFunction(hsm.getKind(), hsm);
}
}
@Override
public void onClose(final int code, final String reason, final boolean remote) {
executeFunction("close", reason);
}
@Override
public void onError(final Exception ex) {
executeErrorFunction(ex);
}
protected void executeErrorFunction(final Exception obj) {
for (final Function function : errorFunctions) {
function.apply(obj);
}
}
protected void executeFunction(final String event, final Object obj) {
final List functionList = callbackFunctions.get(event);
if (functionList != null) {
for (final Function function : functionList) {
function.apply(obj);
}
}
}
protected void executeEventFunction(final T obj, final Map>> mapFunctions) {
final List> functionList = mapFunctions.get(obj.getKind());
if (functionList != null) {
for (final Function function : functionList) {
function.apply(obj);
}
}
}
};
ws.connect();
}
/**
* Add a new function to be called when a message is received from the socket fot a specific event
*
* @param event The event which is listened
* @param function The function to be called
*/
public void on(final String event, final Function function) {
List functionList = callbackFunctions.get(event);
if (functionList == null) {
functionList = new ArrayList<>();
}
functionList.add(function);
callbackFunctions.put(event, functionList);
}
/**
* Add a new function to be called when a exception is received from the socket
*
* @param function The function to be called
*/
public void onError(final Function function) {
errorFunctions.add(function);
}
/**
* Add a new function to be called when a message is received from the socket for a specific event of transaction
*
* @param event The event which is listened (transfer, transaction or contract-transaction)
* @param function The function to be called
*/
public void onTransaction(final String event, final Function function) {
onEvent(event, function, transactionFunctions);
}
/**
* Add a new function to be called when a message is received from the socket for a specific event of contract events
*
* @param event The event which is listened (contract-event)
* @param function The function to be called
*/
public void onContractEvent(final String event, final Function function) {
onEvent(event, function, contractsFunctions);
}
private void onEvent(final String event, final Function function, final Map>> mapFunctions) {
List> functionList = mapFunctions.get(event);
if (functionList == null) {
functionList = new ArrayList<>();
}
functionList.add(function);
mapFunctions.put(event, functionList);
}
/**
* Remove all functions from the handlers list of an specific event
*
* @param event The event which is listened
*/
public void removeAllListeners(final String event) {
callbackFunctions.remove(event);
}
/**
* Remove all handlers for all event types
*/
public void removeAllListeners() {
callbackFunctions.clear();
transactionFunctions.clear();
contractsFunctions.clear();
errorFunctions.clear();
}
/**
* Add new addresses to be listened for event of type "transfers".
*
* @param addresses New Addresses to be listened
*/
public void watchTransfer(final List addresses) {
if (!addresses.isEmpty()) {
sendMessage(HancockSocketMessageRequestKind.WATCHTRANSFER.getKind(), addresses);
}
}
/**
* Add new addresses to be listened for event of type "transactions".
*
* @param addresses New Addresses to be listened
*/
public void watchTransaction(final List addresses) {
if (!addresses.isEmpty()) {
sendMessage(HancockSocketMessageRequestKind.WATCHTRANSACTION.getKind(), addresses);
}
}
/**
* Add new addresses or alias to be listened for event of type "contract-transaction".
*
* @param contracts New address or alias to be listened
*/
public void watchContractTransaction(final List contracts) {
if (!contracts.isEmpty()) {
sendMessage(HancockSocketMessageRequestKind.WATCHSMARTCONTRACTTRANSACTION.getKind(), contracts);
}
}
/**
* Add new addresses or alias to be listened for event of type "contract-transaction".
*
* @param contracts New address or alias to be listened
*/
public void watchContractDeployments(final List contracts) {
if (!contracts.isEmpty()) {
sendMessage(HancockSocketMessageRequestKind.WATCHSMARTCONTRACDEPLOYMENTS.getKind(), contracts);
}
}
/**
* Add new addresses or alias to be listened for event of type "contract-event".
*
* @param contracts New address or alias to be listened
*/
public void watchContractEvent(final List contracts) {
if (!contracts.isEmpty()) {
sendMessage(HancockSocketMessageRequestKind.WATCHSMARTCONTRACTEVENT.getKind(), contracts);
}
}
/**
* Stop listening the addresses for event of type "transfers".
*
* @param addresses Addresses to stop listening
*/
public void unwatchTransfer(final List addresses) {
if (!addresses.isEmpty()) {
sendMessage(HancockSocketMessageRequestKind.UNWATCHTRANSFER.getKind(), addresses);
}
}
/**
* Stop listening the addresses for event of type "transactions".
*
* @param addresses Addresses to stop listening
*/
public void unwatchTransaction(final List addresses) {
if (!addresses.isEmpty()) {
sendMessage(HancockSocketMessageRequestKind.UNWATCHTRANSACTION.getKind(), addresses);
}
}
/**
* Stop listening the contracts for event of type "contracts".
*
* @param contracts Contracts to stop listening
*/
public void unwatchContractTransaction(final List contracts) {
if (!contracts.isEmpty()) {
sendMessage(HancockSocketMessageRequestKind.UNWATCHSMARTCONTRACTTRANSACTION.getKind(), contracts);
}
}
/**
* Stop listening the contracts for event of type "contracts".
*
* @param contracts Contracts to stop listening
*/
public void unwatchContractEvent(final List contracts) {
if (!contracts.isEmpty()) {
sendMessage(HancockSocketMessageRequestKind.UNWATCHSMARTCONTRACTEVENT.getKind(), contracts);
}
}
public WebSocketClient getWs() {
return ws;
}
public Map> getCallbackFunctions() {
return callbackFunctions;
}
public Map>> getTransactionFunctions() {
return transactionFunctions;
}
public Map>> getContractsFunctions() {
return contractsFunctions;
}
public List> getErrorFunctions() {
return errorFunctions;
}
protected void sendMessage(final String kind, final List body) {
final HancockSocketRequest message = new HancockSocketRequest(kind, body);
if (ws.isOpen()) {
final Gson gson = new Gson();
ws.send(gson.toJson(message));
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy