NearbyConnectionModule.java

package com.butchmarshall.reactnative.google.nearby.connection;

import static com.butchmarshall.reactnative.google.nearby.connection.Constants.TAG;

import android.Manifest;
import android.hardware.Camera;

import com.facebook.react.modules.core.PermissionAwareActivity;
import com.facebook.react.modules.core.PermissionListener;
import com.facebook.react.modules.core.DeviceEventManagerModule;

import com.facebook.react.bridge.ActivityEventListener;
import com.facebook.react.bridge.LifecycleEventListener;
import com.facebook.react.bridge.Arguments;
import com.facebook.react.bridge.Callback;
import com.facebook.react.bridge.Promise;
import com.facebook.react.bridge.PromiseImpl;
import com.facebook.react.bridge.ReactContextBaseJavaModule;
import com.facebook.react.bridge.Callback;
import com.facebook.react.bridge.ReadableMap;
import com.facebook.react.bridge.WritableMap;
import com.facebook.react.bridge.WritableArray;
import com.facebook.react.bridge.NativeModule;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactContext;
import com.facebook.react.bridge.ReactMethod;

import android.app.Activity;

import android.net.Uri;

import android.content.Intent;
import android.content.Context;
import android.content.BroadcastReceiver;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.content.pm.ApplicationInfo;

import android.os.Bundle;
import android.os.ParcelFileDescriptor;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;

import android.support.annotation.CallSuper;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.annotation.UiThread;
import android.support.annotation.WorkerThread;
import android.support.v4.content.ContextCompat;
import android.support.v4.app.ActivityCompat;
import android.support.v4.util.SimpleArrayMap;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.widget.Toast;
import com.google.android.gms.common.api.Status;
import com.google.android.gms.common.api.ApiException;
import com.google.android.gms.nearby.Nearby;
import com.google.android.gms.nearby.connection.AdvertisingOptions;
import com.google.android.gms.nearby.connection.ConnectionInfo;
import com.google.android.gms.nearby.connection.ConnectionLifecycleCallback;
import com.google.android.gms.nearby.connection.ConnectionResolution;
import com.google.android.gms.nearby.connection.ConnectionsClient;
import com.google.android.gms.nearby.connection.ConnectionsStatusCodes;
import com.google.android.gms.nearby.connection.DiscoveredEndpointInfo;
import com.google.android.gms.nearby.connection.DiscoveryOptions;
import com.google.android.gms.nearby.connection.EndpointDiscoveryCallback;
import com.google.android.gms.nearby.connection.Payload;
import com.google.android.gms.nearby.connection.PayloadCallback;
import com.google.android.gms.nearby.connection.PayloadTransferUpdate;
import com.google.android.gms.nearby.connection.Strategy;
import com.google.android.gms.tasks.OnFailureListener;
import com.google.android.gms.tasks.OnSuccessListener;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Locale;
import java.util.Map;
import java.util.Set;

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

import java.io.*;
/*import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;*/
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.Callable;

public class NearbyConnectionModule extends ReactContextBaseJavaModule implements ActivityEventListener {
	ReactApplicationContext reactContext;

	/**
	 * These permissions are required before connecting to Nearby Connections. Only {@link
	 * Manifest.permission#ACCESS_COARSE_LOCATION} is considered dangerous, so the others should be
	 * granted just by having them in our AndroidManfiest.xml
	 */
	private static final String[] REQUIRED_PERMISSIONS =
		new String[] {
			Manifest.permission.BLUETOOTH,
			Manifest.permission.BLUETOOTH_ADMIN,
			Manifest.permission.ACCESS_WIFI_STATE,
			Manifest.permission.CHANGE_WIFI_STATE,
			Manifest.permission.ACCESS_COARSE_LOCATION,
		};

	private static final String[] REQUIRED_AUDIO_PERMISSIONS =
		new String[] {
			Manifest.permission.RECORD_AUDIO,
		};

	private static final String[] REQUIRED_STORAGE_PERMISSIONS =
		new String[] {
			Manifest.permission.READ_EXTERNAL_STORAGE,
			Manifest.permission.WRITE_EXTERNAL_STORAGE,
		};

	private static final String E_PERMISSIONS_MISSING = "E_PERMISSION_MISSING";
	private static final String E_CALLBACK_ERROR = "E_CALLBACK_ERROR";
	private static final int REQUEST_CODE_REQUIRED_PERMISSIONS = 1;

	/** For recording audio as the user speaks. */
	@Nullable private AudioRecorder mRecorder;

	/**
	 * True if we are asking a discovered device to connect to us. While we ask, we cannot ask another
	 * device.
	 */
	private boolean mIsConnecting = false;

	/** True if we are discovering. */
	private boolean mIsDiscovering = false;

	/** True if we are advertising. */
	private boolean mIsAdvertising = false;

	private final Map<String, ConnectionsClient> mConnectionsClients = new HashMap<>();

	/** The devices we've discovered near us. */
	private final Map<String, Endpoint> mEndpoints = new HashMap<>();

	/** For recording audio as the user speaks. */
	private final Map<String, AudioRecorder> mRecorders = new HashMap<>();

	private final Map<String, Payload> mReceivedPayloads = new HashMap<>();
	private final SimpleArrayMap<String, String> mPayloadFileData = new SimpleArrayMap<>();

	private final Map<String, AudioPlayer> mAudioPlayers = new HashMap<>();

	/** Callbacks for connections to other devices. */
	private ConnectionLifecycleCallback getConnectionLifecycleCallback(final String serviceId, final String type) {
		final ConnectionLifecycleCallback mConnectionLifecycleCallback = new ConnectionLifecycleCallback() {
			@Override
			public void onConnectionInitiated(String endpointId, ConnectionInfo connectionInfo) {
				logD(
					String.format(
						"onConnectionInitiated(serviceId=%s, endpointId=%s, endpointName=%s)",
						serviceId, endpointId, connectionInfo.getEndpointName()));

				Endpoint endpoint = new Endpoint(serviceId, endpointId, connectionInfo.getEndpointName(), type);
				mEndpoints.put(serviceId+"_"+endpointId, endpoint);

				connectionInitiatedToEndpoint(serviceId, endpointId, connectionInfo);
			}

			@Override
			public void onConnectionResult(String endpointId, ConnectionResolution result) {
				logD(String.format("onConnectionResponse(serviceId=%s, endpointId=%s, result=%s)", serviceId, endpointId, result));

				// We're no longer connecting
				mIsConnecting = false;

				if (!result.getStatus().isSuccess()) {
					logW(
						String.format(
							"Connection failed. Received status %s.",
							NearbyConnectionModule.statusToString(result.getStatus())));

					endpointConnectionFailed(serviceId, endpointId, result.getStatus().getStatusCode());
					return;
				}
				connectedToEndpoint(serviceId, endpointId);
			}

			@Override
			public void onDisconnected(String endpointId) {
				logD(String.format("onDisconnected(serviceId=%s, endpointId=%s)", serviceId, endpointId));

				// TODO FIX THIS
				if (!mEndpoints.containsKey(serviceId+"_"+endpointId) || !mEndpoints.get(serviceId+"_"+endpointId).isConnected()) {
					logW("Unexpected disconnection from serviceId "+serviceId+" and endpoint " + endpointId);

					return;
				}
				closeMicrophone(serviceId, endpointId);

				disconnectedFromEndpoint(serviceId, endpointId);
			}
		};

		return mConnectionLifecycleCallback;
	}

	/** Callbacks for payloads (bytes of data) sent from another device to us. */
	private PayloadCallback getPayloadCallback(final String serviceId) {
		final PayloadCallback mPayloadCallback = new PayloadCallback() {
			@Override
			public void onPayloadReceived(String endpointId, Payload payload) {
				String payloadId = Long.toString(payload.getId());
				int payloadType = payload.getType();

				logD(String.format("onPayloadReceived(endpointId=%s, payload=%s, id=%s, type=%s)", endpointId, payload, payloadId, payloadType));

				mReceivedPayloads.put(serviceId+"_"+endpointId+"_"+payloadId, payload);

				// Track out-of-band filename transfers
				if (payloadType == Payload.Type.BYTES) {
					String bytes = "";

					try {
						bytes = new String(payload.asBytes(), "UTF-8");
					}
					catch (UnsupportedEncodingException e) {
						logW("onPayloadReceived failed converting payload asBytes.", e);
					}

					int colonIndex = bytes.indexOf(':');
					int filePayloadType = Integer.parseInt(bytes.substring(0, colonIndex));
					if (filePayloadType == Payload.Type.FILE) {
						bytes = bytes.substring(colonIndex + 1);

						colonIndex = bytes.indexOf(':');
						String filePayloadId = bytes.substring(0, colonIndex);
						String filename = bytes.substring(colonIndex + 1);

						logD(String.format("got filename for (payloadId=%s, filename=%s)", filePayloadId, filename));

						mPayloadFileData.put(filePayloadId, filename);
					}
				}

				onReceivePayload(serviceId, endpointId, payload);
			}

			@Override
			public void onPayloadTransferUpdate(String endpointId, PayloadTransferUpdate update) {
				logD(String.format("onPayloadTransferUpdate(endpointId=%s, update=%s)", endpointId, update));

				onPayloadUpdate(serviceId, endpointId, update);
			}
		};

		return mPayloadCallback;
	};

	private EndpointDiscoveryCallback getEndpointDiscoveryCallback(final String serviceId) {
		final EndpointDiscoveryCallback mEndpointDiscoveryCallback = new EndpointDiscoveryCallback() {
			@Override
			public void onEndpointFound(String endpointId, DiscoveredEndpointInfo info) {
                logD(
                    String.format(
                        "onEndpointFound(endpointId=%s, serviceId=%s, endpointName=%s)",
                        endpointId, info.getServiceId(), info.getEndpointName()));

				Endpoint existingEndpoint = mEndpoints.get(serviceId+"_"+endpointId);

				if (serviceId.equals(info.getServiceId()) && existingEndpoint == null || !existingEndpoint.isConnected()) {
					Endpoint endpoint = new Endpoint(serviceId, endpointId, info.getEndpointName(), "discovering");
					mEndpoints.put(serviceId+"_"+endpointId, endpoint);

					onEndpointDiscovered(serviceId, endpointId);
				}
			}

			@Override
			public void onEndpointLost(String endpointId) {
				logD(String.format("onEndpointLost(endpointId=%s)", endpointId));

				endpointLost(serviceId, endpointId);
			}
		};

		return mEndpointDiscoveryCallback;
	}

    public NearbyConnectionModule(ReactApplicationContext reactContext) {
        super(reactContext);
		this.reactContext = reactContext;

		onResume();

		setLifecycleListeners();
    }

	private void onResume() {
		registerAdvertisingStartingHandler();
		registerAdvertisingStartedHandler();
		registerAdvertisingStartFailedHandler();

		registerDiscoveryStartingHandler();
		registerDiscoveryStartedHandler();
		registerDiscoveryStartFailedHandler();

		registerEndpointDiscoveredHandler();
		registerEndpointLostHandler();
		registerConnectionInitiatedToEndpointHandler();
		registerConnectedToEndpointHandler();
		registerDisconnectedFromEndpointHandler();
		registerEndpointConnectionFailedHandler();
		registerOnReceivePayloadHandler();
		registerOnPayloadUpdateHandler();
		registerSendPayloadFailedHandler();
	}
	
	private void onPause() {
		unregisterAdvertisingStartingHandler();
		unregisterAdvertisingStartedHandler();
		unregisterAdvertisingStartFailedHandler();

		unregisterDiscoveryStartingHandler();
		unregisterDiscoveryStartedHandler();
		unregisterDiscoveryStartFailedHandler();

		unregisterEndpointDiscoveredHandler();
		unregisterEndpointLostHandler();
		unregisterConnectionInitiatedToEndpointHandler();
		unregisterConnectedToEndpointHandler();
		unregisterDisconnectedFromEndpointHandler();
		unregisterEndpointConnectionFailedHandler();
		unregisterOnReceivePayloadHandler();
		unregisterOnPayloadUpdateHandler();
		unregisterSendPayloadFailedHandler();
	}
	
	private void onDestroy() {
		
	}

	@Override
	public void onCatalystInstanceDestroy() {
		logW("onCatalystInstanceDestroy");
		for (ConnectionsClient mConnectionsClient : mConnectionsClients.values()) {
			mConnectionsClient.stopDiscovery();
			mConnectionsClient.stopAdvertising();
			mConnectionsClient.stopAllEndpoints();
		}
	}

    private void setLifecycleListeners() {

        this.reactContext.addLifecycleEventListener(new LifecycleEventListener() {
            @Override
            public void onHostResume() {
                logW("onHostResume");
                onResume();
            }

            @Override
            public void onHostPause() {
                logW("onHostPause");
                onPause();
            }

            @Override
            public void onHostDestroy() {
				logW("onHostDestroy");
                onDestroy();
            }
        });
    }

	/** Called when our Activity is first created. */
	protected ConnectionsClient getConnectionsClientSingleton(final String serviceId) {
		ConnectionsClient mConnectionsClient = mConnectionsClients.get(serviceId);
		if (mConnectionsClient == null) {
			logV("No ConnectionsClient exists for " + serviceId + ", initializing");

			final Activity currentActivity = getCurrentActivity();

			mConnectionsClient = Nearby.getConnectionsClient(currentActivity);
			mConnectionsClients.put(serviceId, mConnectionsClient);
		}

		return mConnectionsClient;
	}

    @Override
    public String getName() {
        return "NearbyConnection";
    }

    @Override
    public void onNewIntent(Intent intent) {
    }

    @Override
    public void onActivityResult(Activity activity, final int requestCode, final int resultCode, final Intent data) {

    }

	/**
	 * Get all the payloads received by this device
	 */
	@ReactMethod
	public void payloads(final Promise promise) {
		WritableArray result = Arguments.createArray();

		for (String key : mReceivedPayloads.keySet()) {
			// Explode key to get serviceId, endpointId, payloadId
			//result.pushMap(endpoint.toWritableMap());
		}

		promise.resolve(result);
	}

	/**
	 * Get all the services discovered by this device
	 */
	@ReactMethod
	public void endpoints(final Promise promise) {
		WritableArray result = Arguments.createArray();

		for (Endpoint endpoint : mEndpoints.values()) {
			result.pushMap(endpoint.toWritableMap());
		}

		promise.resolve(result);
	}

	@ReactMethod
	public void rejectConnection(final String serviceId, final String endpointId) {
		final Endpoint endpoint = mEndpoints.get(serviceId+"_"+endpointId);

		logV("rejecting connection from " + endpointId);
		final ConnectionsClient clientSingleton = getConnectionsClientSingleton(serviceId);

		clientSingleton
			.rejectConnection(endpointId)
			.addOnFailureListener(
				new OnFailureListener() {
					@Override
					public void onFailure(@NonNull Exception e) {
						ApiException apiException = (ApiException) e;

						logW("rejectConnection() failed.", e);
					}
				});
	}

	@ReactMethod
	public void acceptConnection(final String serviceId, final String endpointId) {
		final Endpoint endpoint = mEndpoints.get(serviceId+"_"+endpointId);

		logV("acceptConnection(serviceId: "+serviceId+", endpointId:" + endpointId+")");
		final ConnectionsClient clientSingleton = getConnectionsClientSingleton(serviceId);

		clientSingleton
			.acceptConnection(endpointId, getPayloadCallback(serviceId))
			.addOnFailureListener(
				new OnFailureListener() {
					@Override
					public void onFailure(@NonNull Exception e) {
						ApiException apiException = (ApiException) e;

						logW("acceptConnection(serviceId: "+serviceId+", endpointId:" + endpointId+") failed.", e);
					}
				});
	}

	@ReactMethod
	protected void startAdvertising(final String endpointName, final String serviceId, final int strategy) {
		mIsAdvertising = true;
		onAdvertisingStarting(endpointName, serviceId);

		Strategy finalStrategy = Strategy.P2P_CLUSTER;
		switch(strategy) {
			case 0: finalStrategy = Strategy.P2P_CLUSTER;
				break;
			case 1: finalStrategy = Strategy.P2P_STAR;
				break;
		}

		final Activity activity = getCurrentActivity();
		final ConnectionsClient clientSingleton = getConnectionsClientSingleton(serviceId);
		final AdvertisingOptions advertisingOptions =  new AdvertisingOptions(finalStrategy);

        permissionsCheck(activity, Arrays.asList(getRequiredPermissions()), new Callable<Void>() {
            @Override
            public Void call() throws Exception {
				clientSingleton
					.startAdvertising(
						endpointName,
						serviceId,
						getConnectionLifecycleCallback(serviceId, "advertised"),
						advertisingOptions
					)
					.addOnSuccessListener(
						new OnSuccessListener<Void>() {
							@Override
							public void onSuccess(Void unusedResult) {
								logV("Now advertising endpoint " + endpointName + " with serviceId " + serviceId);
								onAdvertisingStarted(endpointName, serviceId);
							}
						}
					)
					.addOnFailureListener(
						new OnFailureListener() {
							@Override
							public void onFailure(@NonNull Exception e) {
								ApiException apiException = (ApiException) e;

								mIsAdvertising = false;
								logW("startAdvertising for endpointName "+ endpointName +" serviceId "+ serviceId +" failed.", e);
								onAdvertisingStartFailed(endpointName, serviceId, apiException.getStatusCode());
							}
						}
					);

                return null;
            }
        });
	}

	/** Stops discovery. */
	@ReactMethod
	public void stopAdvertising(final String serviceId) {
		final ConnectionsClient clientSingleton = getConnectionsClientSingleton(serviceId);

		logV("Stopping advertising endpoint " + serviceId);

		mIsAdvertising = false;
		clientSingleton.stopAdvertising();
	}

	/** Returns {@code true} if currently advertising. */
	@ReactMethod
	public boolean isAdvertising() {
		return mIsAdvertising;
	}

	@ReactMethod
	public void startDiscovering(final String serviceId, final int strategy) {
		mIsDiscovering = true;
		onDiscoveryStarting(serviceId);

		Strategy finalStrategy = Strategy.P2P_CLUSTER;
		switch(strategy) {
			case 0: finalStrategy = Strategy.P2P_CLUSTER;
				break;
			case 1: finalStrategy = Strategy.P2P_STAR;
				break;
		}

		final Activity activity = getCurrentActivity();
		final ConnectionsClient clientSingleton = getConnectionsClientSingleton(serviceId);
		final DiscoveryOptions discoveryOptions = new DiscoveryOptions(finalStrategy);

        permissionsCheck(activity, Arrays.asList(getRequiredPermissions()), new Callable<Void>() {
            @Override
            public Void call() throws Exception {
				clientSingleton.startDiscovery(
					serviceId,
					getEndpointDiscoveryCallback(serviceId),
					discoveryOptions
				).addOnSuccessListener(
					new OnSuccessListener<Void>() {
						@Override
						public void onSuccess(Void unusedResult) {
							logV("Now discovering for serviceId "+ serviceId);
							onDiscoveryStarted(serviceId);
						}
					}
				).addOnFailureListener(
					new OnFailureListener() {
						@Override
						public void onFailure(@NonNull Exception e) {
							ApiException apiException = (ApiException) e;

							mIsDiscovering = false;
							logW("startDiscovering for serviceId "+serviceId+" failed.", e);
							onDiscoveryStartFailed(serviceId, apiException.getStatusCode());
						}
					}
				);

                return null;
            }
        });
	}

	/** Stops discovery. */
	@ReactMethod
	public void stopDiscovering(String serviceId) {
		final ConnectionsClient clientSingleton = getConnectionsClientSingleton(serviceId);

		logV("Stopping discovering endpoints " + serviceId);

		mIsDiscovering = false;
		clientSingleton.stopDiscovery();
	}

	/** Returns {@code true} if currently discovering. */
	@ReactMethod
	public boolean isDiscovering() {
		return mIsDiscovering;
	}

	/** Returns {@code true} if currently connecting. */
	@ReactMethod
	public boolean isConnecting() {
		return mIsConnecting;
	}

	/**
	 * Called when advertising starting
	 */
	private void onAdvertisingStarting(final String endpointName, final String serviceId) {
		// Broadcast endpoint discovered
		Intent i = new Intent("com.butchmarshall.reactnative.google.nearby.connection.AdvertisingStarting");
		Bundle bundle = new Bundle();
		bundle.putString("endpointName", endpointName);
		bundle.putString("serviceId", serviceId);
		i.putExtras(bundle);

		final Activity activity = getCurrentActivity();
		activity.sendBroadcast(i);
	}

	private BroadcastReceiver mAdvertisingStartingReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			if (getReactApplicationContext().hasActiveCatalystInstance()) {
				String endpointName = intent.getStringExtra("endpointName");
				String serviceId = intent.getStringExtra("serviceId");

				WritableMap out = Arguments.createMap();
				out.putString("endpointName", endpointName);
				out.putString("serviceId", serviceId);

				sendEvent(getReactApplicationContext(), "advertising_starting", out);
			}
		}
	};
	private void unregisterAdvertisingStartingHandler() {
		getReactApplicationContext().unregisterReceiver(mAdvertisingStartingReceiver);
	}
	private void registerAdvertisingStartingHandler() {
		IntentFilter intentFilter = new IntentFilter("com.butchmarshall.reactnative.google.nearby.connection.AdvertisingStarting");
		getReactApplicationContext().registerReceiver(mAdvertisingStartingReceiver, intentFilter);
	}

	/**
	 * Called when advertising started
	 */
	private void onAdvertisingStarted(final String endpointName, final String serviceId) {
		// Broadcast endpoint discovered
		Intent i = new Intent("com.butchmarshall.reactnative.google.nearby.connection.AdvertisingStarted");
		Bundle bundle = new Bundle();
		bundle.putString("endpointName", endpointName);
		bundle.putString("serviceId", serviceId);
		i.putExtras(bundle);

		final Activity activity = getCurrentActivity();
		activity.sendBroadcast(i);
	}

	private BroadcastReceiver mAdvertisingStartedReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			if (getReactApplicationContext().hasActiveCatalystInstance()) {
				String endpointName = intent.getStringExtra("endpointName");
				String serviceId = intent.getStringExtra("serviceId");

				WritableMap out = Arguments.createMap();
				out.putString("endpointName", endpointName);
				out.putString("serviceId", serviceId);

				sendEvent(getReactApplicationContext(), "advertising_started", out);
			}
		}
	};
	private void unregisterAdvertisingStartedHandler() {
		getReactApplicationContext().unregisterReceiver(mAdvertisingStartedReceiver);
	}
	private void registerAdvertisingStartedHandler() {
		IntentFilter intentFilter = new IntentFilter("com.butchmarshall.reactnative.google.nearby.connection.AdvertisingStarted");
		getReactApplicationContext().registerReceiver(mAdvertisingStartedReceiver, intentFilter);
	}

	/**
	 * Called when advertising failed to start
	 */
	private void onAdvertisingStartFailed(final String endpointName, final String serviceId, final int statusCode) {
		// Broadcast endpoint discovered
		Intent i = new Intent("com.butchmarshall.reactnative.google.nearby.connection.AdvertisingStartFailed");
		Bundle bundle = new Bundle();
		bundle.putInt("statusCode", statusCode);
		bundle.putString("endpointName", endpointName);
		bundle.putString("serviceId", serviceId);
		i.putExtras(bundle);

		final Activity activity = getCurrentActivity();
		activity.sendBroadcast(i);
	}

	private BroadcastReceiver mAdvertisingStartFailedReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			if (getReactApplicationContext().hasActiveCatalystInstance()) {
				int statusCode = intent.getIntExtra("statusCode", -1);
				String endpointName = intent.getStringExtra("endpointName");
				String serviceId = intent.getStringExtra("serviceId");

				WritableMap out = Arguments.createMap();
				out.putInt("statusCode", statusCode);
				out.putString("endpointName", endpointName);
				out.putString("serviceId", serviceId);

				sendEvent(getReactApplicationContext(), "advertising_start_failed", out);
			}
		}
	};
	private void unregisterAdvertisingStartFailedHandler() {
		getReactApplicationContext().unregisterReceiver(mAdvertisingStartFailedReceiver);
	}
	private void registerAdvertisingStartFailedHandler() {
		IntentFilter intentFilter = new IntentFilter("com.butchmarshall.reactnative.google.nearby.connection.AdvertisingStartFailed");
		getReactApplicationContext().registerReceiver(mAdvertisingStartFailedReceiver, intentFilter);
	}

	/**
	 * Called when discovery starting
	 */
	private void onDiscoveryStarting(final String serviceId) {
		// Broadcast endpoint discovered
		Intent i = new Intent("com.butchmarshall.reactnative.google.nearby.connection.DiscoveryStarting");
		Bundle bundle = new Bundle();
		bundle.putString("serviceId", serviceId);
		i.putExtras(bundle);

		final Activity activity = getCurrentActivity();
		activity.sendBroadcast(i);
	}

	private BroadcastReceiver mDiscoveryStartingReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			if (getReactApplicationContext().hasActiveCatalystInstance()) {
				String serviceId = intent.getStringExtra("serviceId");

				WritableMap out = Arguments.createMap();
				out.putString("serviceId", serviceId);

				sendEvent(getReactApplicationContext(), "discovery_starting", out);
			}
		}
	};
	private void unregisterDiscoveryStartingHandler() {
		getReactApplicationContext().unregisterReceiver(mDiscoveryStartingReceiver);
	}
	private void registerDiscoveryStartingHandler() {
		IntentFilter intentFilter = new IntentFilter("com.butchmarshall.reactnative.google.nearby.connection.DiscoveryStarting");
		getReactApplicationContext().registerReceiver(mDiscoveryStartingReceiver, intentFilter);
	}

	/**
	 * Called when discovery started
	 */
	private void onDiscoveryStarted(final String serviceId) {
		// Broadcast endpoint discovered
		Intent i = new Intent("com.butchmarshall.reactnative.google.nearby.connection.DiscoveryStarted");
		Bundle bundle = new Bundle();
		bundle.putString("serviceId", serviceId);
		i.putExtras(bundle);

		final Activity activity = getCurrentActivity();
		activity.sendBroadcast(i);
	}

	private BroadcastReceiver mDiscoveryStartedReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			if (getReactApplicationContext().hasActiveCatalystInstance()) {
				String serviceId = intent.getStringExtra("serviceId");

				WritableMap out = Arguments.createMap();
				out.putString("serviceId", serviceId);

				sendEvent(getReactApplicationContext(), "discovery_started", out);
			}
		}
	};
	private void unregisterDiscoveryStartedHandler() {
		getReactApplicationContext().unregisterReceiver(mDiscoveryStartedReceiver);
	}
	private void registerDiscoveryStartedHandler() {
		IntentFilter intentFilter = new IntentFilter("com.butchmarshall.reactnative.google.nearby.connection.DiscoveryStarted");
		getReactApplicationContext().registerReceiver(mDiscoveryStartedReceiver, intentFilter);
	}

	/**
	 * Called when discovery started
	 */
	private void onDiscoveryStartFailed(final String serviceId, int statusCode) {
		Intent i = new Intent("com.butchmarshall.reactnative.google.nearby.connection.DiscoveryStartFailed");
		Bundle bundle = new Bundle();
		bundle.putInt("statusCode", statusCode);
		bundle.putString("serviceId", serviceId);
		i.putExtras(bundle);

		final Activity activity = getCurrentActivity();
		activity.sendBroadcast(i);
	}

	private BroadcastReceiver mDiscoveryStartFailedReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			if (getReactApplicationContext().hasActiveCatalystInstance()) {
				int statusCode = intent.getIntExtra("statusCode", -1);
				String serviceId = intent.getStringExtra("serviceId");

				WritableMap out = Arguments.createMap();
				out.putInt("statusCode", statusCode);
				out.putString("serviceId", serviceId);

				sendEvent(getReactApplicationContext(), "discovery_start_failed", out);
			}
		}
	};
	private void unregisterDiscoveryStartFailedHandler() {
		getReactApplicationContext().unregisterReceiver(mDiscoveryStartFailedReceiver);
	}
	private void registerDiscoveryStartFailedHandler() {
		IntentFilter intentFilter = new IntentFilter("com.butchmarshall.reactnative.google.nearby.connection.DiscoveryStartFailed");
		getReactApplicationContext().registerReceiver(mDiscoveryStartFailedReceiver, intentFilter);
	}

	/**
	 * Called when a payload was received
	 */
	private void onReceivePayload(final String serviceId, final String endpointId, Payload payload) {
		int payloadType = payload.getType();
		long payloadId = payload.getId();

		// Broadcast endpoint discovered
		Intent i = new Intent("com.butchmarshall.reactnative.google.nearby.connection.ReceivePayload");
		Bundle bundle = new Bundle();
		bundle.putString("serviceId", serviceId);
		bundle.putString("endpointId", endpointId);
		bundle.putInt("payloadType", payloadType);
		bundle.putString("payloadId", Long.toString(payloadId));
/*
		if (payloadType == Payload.Type.FILE) {
			long payloadSize = payload.getSize();
			bundle.putLong("payloadSize", payloadSize);
		}
*/
		i.putExtras(bundle);

		final Activity activity = getCurrentActivity();
		activity.sendBroadcast(i);
	}

	private BroadcastReceiver mOnReceivePayloadReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			if (getReactApplicationContext().hasActiveCatalystInstance()) {
				String serviceId = intent.getStringExtra("serviceId");
				String endpointId = intent.getStringExtra("endpointId");
				int payloadType = intent.getIntExtra("payloadType", -1);
				String payloadId = intent.getStringExtra("payloadId");

				WritableMap out = Arguments.createMap();
				out.putString("serviceId", serviceId);
				out.putString("endpointId", endpointId);
				out.putInt("payloadType", payloadType);
				out.putString("payloadId", payloadId);

				if (payloadType == Payload.Type.FILE) {
					long payloadSize = intent.getLongExtra("payloadSize", -1);
					out.putDouble("payloadSize", payloadSize);
				}

				sendEvent(getReactApplicationContext(), "receive_payload", out);
			}
		}
	};
	private void unregisterOnReceivePayloadHandler() {
		getReactApplicationContext().unregisterReceiver(mOnReceivePayloadReceiver);
	}
	private void registerOnReceivePayloadHandler() {
		IntentFilter intentFilter = new IntentFilter("com.butchmarshall.reactnative.google.nearby.connection.ReceivePayload");
		getReactApplicationContext().registerReceiver(mOnReceivePayloadReceiver, intentFilter);
	}

	/**
	 * Called when there is an update to a payload
	 */
	private void onPayloadUpdate(final String serviceId, final String endpointId, PayloadTransferUpdate update) {
		long bytesTransferred = update.getBytesTransferred();
		long totalBytes = update.getTotalBytes();
		long payloadId = update.getPayloadId();
		int payloadStatus = update.getStatus();
		int payloadHashCode = update.hashCode();

		// Broadcast endpoint discovered
		Intent i = new Intent("com.butchmarshall.reactnative.google.nearby.connection.PayloadUpdate");
		Bundle bundle = new Bundle();
		bundle.putString("serviceId", serviceId);
		bundle.putString("endpointId", endpointId);
		bundle.putLong("bytesTransferred", bytesTransferred);
		bundle.putLong("totalBytes", totalBytes);
		bundle.putString("payloadId", Long.toString(payloadId));
		bundle.putInt("payloadStatus", payloadStatus);
		bundle.putInt("payloadHashCode", payloadHashCode);
		i.putExtras(bundle);

		final Activity activity = getCurrentActivity();
		activity.sendBroadcast(i);
	}

	private BroadcastReceiver mRegisterOnPayloadUpdateReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			if (getReactApplicationContext().hasActiveCatalystInstance()) {
				String serviceId = intent.getStringExtra("serviceId");
				String endpointId = intent.getStringExtra("endpointId");
				long bytesTransferred = intent.getLongExtra("bytesTransferred", -1);
				long totalBytes = intent.getLongExtra("totalBytes", -1);
				String payloadId = intent.getStringExtra("payloadId");
				int payloadStatus = intent.getIntExtra("payloadStatus", -1);
				int payloadHashCode = intent.getIntExtra("payloadHashCode", -1);

				WritableMap out = Arguments.createMap();
				out.putString("serviceId", serviceId);
				out.putString("endpointId", endpointId);
				out.putDouble("bytesTransferred", bytesTransferred);
				out.putDouble("totalBytes", totalBytes);
				out.putString("payloadId", payloadId);
				out.putInt("payloadStatus", payloadStatus);
				out.putInt("payloadHashCode", payloadHashCode);

				sendEvent(getReactApplicationContext(), "payload_transfer_update", out);
			}
		}
	};
	private void unregisterOnPayloadUpdateHandler() {
		getReactApplicationContext().unregisterReceiver(mRegisterOnPayloadUpdateReceiver);
	}
	private void registerOnPayloadUpdateHandler() {
		IntentFilter intentFilter = new IntentFilter("com.butchmarshall.reactnative.google.nearby.connection.PayloadUpdate");
		getReactApplicationContext().registerReceiver(mRegisterOnPayloadUpdateReceiver, intentFilter);
	}

	/**
	 * Called when sending payload fails
	 */
	private void onSendPayloadFailed(final String serviceId, final String endpointId, Payload payload, int statusCode) {
		int payloadType = payload.getType();
		long payloadId = payload.getId();

		// Broadcast endpoint discovered
		Intent i = new Intent("com.butchmarshall.reactnative.google.nearby.connection.SendPayloadFailed");
		Bundle bundle = new Bundle();
		bundle.putString("serviceId", serviceId);
		bundle.putString("endpointId", endpointId);
		bundle.putInt("statusCode", statusCode);
		bundle.putInt("payloadType", payloadType);
		bundle.putString("payloadId", Long.toString(payloadId));

		i.putExtras(bundle);

		final Activity activity = getCurrentActivity();
		activity.sendBroadcast(i);
	}

	private BroadcastReceiver mSendPayloadFailedReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			if (getReactApplicationContext().hasActiveCatalystInstance()) {
				String serviceId = intent.getStringExtra("serviceId");
				String endpointId = intent.getStringExtra("endpointId");
				int statusCode = intent.getIntExtra("statusCode", -1);
				int payloadType = intent.getIntExtra("payloadType", -1);
				String payloadId = intent.getStringExtra("payloadId");

				WritableMap out = Arguments.createMap();
				out.putString("serviceId", serviceId);
				out.putString("endpointId", endpointId);
				out.putInt("statusCode", statusCode);
				out.putInt("payloadType", payloadType);
				out.putString("payloadId", payloadId);

				sendEvent(getReactApplicationContext(), "send_payload_failed", out);
			}
		}
	};
	private void unregisterSendPayloadFailedHandler() {
		getReactApplicationContext().unregisterReceiver(mSendPayloadFailedReceiver);
	}
	private void registerSendPayloadFailedHandler() {
		IntentFilter intentFilter = new IntentFilter("com.butchmarshall.reactnative.google.nearby.connection.SendPayloadFailed");
		getReactApplicationContext().registerReceiver(mSendPayloadFailedReceiver, intentFilter);
	}
	
	/**
	 * Called when connecting to an endpoint failed
	 */
	private void endpointConnectionFailed(final String serviceId, final String endpointId, final int statusCode) {
		Endpoint endpoint = mEndpoints.get(serviceId+"_"+endpointId);

		String endpointName = endpoint.getName();

		// Broadcast endpoint discovered
		Intent i = new Intent("com.butchmarshall.reactnative.google.nearby.connection.EndpointConnectionFailed");
		Bundle bundle = new Bundle();
		bundle.putString("endpointId", endpointId);
		bundle.putString("endpointName", endpointName);
		bundle.putString("serviceId", serviceId);
		bundle.putInt("statusCode", statusCode);
		i.putExtras(bundle);

		final Activity activity = getCurrentActivity();
		activity.sendBroadcast(i);
	}

	private BroadcastReceiver mEndpointConnectionFailedReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			if (getReactApplicationContext().hasActiveCatalystInstance()) {
				String endpointId = intent.getStringExtra("endpointId");
				String endpointName = intent.getStringExtra("endpointName");
				String serviceId = intent.getStringExtra("serviceId");
				int statusCode = intent.getIntExtra("statusCode", -1);

				WritableMap out = Arguments.createMap();
				out.putString("endpointId", endpointId);
				out.putString("endpointName", endpointName);
				out.putString("serviceId", serviceId);
				out.putInt("statusCode", statusCode);

				sendEvent(getReactApplicationContext(), "endpoint_connection_failed", out);
			}
		}
	};
	private void unregisterEndpointConnectionFailedHandler() {
		getReactApplicationContext().unregisterReceiver(mEndpointConnectionFailedReceiver);
	}
	private void registerEndpointConnectionFailedHandler() {
		IntentFilter intentFilter = new IntentFilter("com.butchmarshall.reactnative.google.nearby.connection.EndpointConnectionFailed");
		getReactApplicationContext().registerReceiver(mEndpointConnectionFailedReceiver, intentFilter);
	}

	/**
	 * Called when disconnected from an endpoint 
	 */
	private void disconnectedFromEndpoint(final String serviceId, final String endpointId) {
		final Endpoint endpoint = mEndpoints.get(serviceId+"_"+endpointId);
		
		if (endpoint == null) {
			logD("disconnectedFromEndpoint unknown endpoint");
			return;
		}
		logD(String.format("disconnectedFromEndpoint(endpoint=%s)", endpoint));

		String endpointName = endpoint.getName();

		endpoint.setConnected(false);

		// Broadcast endpoint discovered
		Intent i = new Intent("com.butchmarshall.reactnative.google.nearby.connection.DisconnectedFromEndpoint");
		Bundle bundle = new Bundle();
		bundle.putString("endpointId", endpointId);
		bundle.putString("endpointName", endpointName);
		bundle.putString("serviceId", serviceId);
		i.putExtras(bundle);

		final Activity activity = getCurrentActivity();
		activity.sendBroadcast(i);
	}

	private BroadcastReceiver mDisconnectedFromEndpointReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			if (getReactApplicationContext().hasActiveCatalystInstance()) {
				String endpointId = intent.getStringExtra("endpointId");
				String endpointName = intent.getStringExtra("endpointName");
				String serviceId = intent.getStringExtra("serviceId");

				WritableMap out = Arguments.createMap();
				out.putString("endpointId", endpointId);
				out.putString("endpointName", endpointName);
				out.putString("serviceId", serviceId);
				sendEvent(getReactApplicationContext(), "disconnected_from_endpoint", out);
			}
		}
	};
	private void unregisterDisconnectedFromEndpointHandler() {
		getReactApplicationContext().unregisterReceiver(mDisconnectedFromEndpointReceiver);
	}
	private void registerDisconnectedFromEndpointHandler() {
		IntentFilter intentFilter = new IntentFilter("com.butchmarshall.reactnative.google.nearby.connection.DisconnectedFromEndpoint");
		getReactApplicationContext().registerReceiver(mDisconnectedFromEndpointReceiver, intentFilter);
	}

	/**
	 * Called when connected to a nearby advertiser 
	 */
	private void connectedToEndpoint(final String serviceId, final String endpointId) {
		final Endpoint endpoint = mEndpoints.get(serviceId+"_"+endpointId);

		logD(String.format("connectedToEndpoint(endpoint=%s)", endpoint));

		String endpointName = endpoint.getName();

		endpoint.setConnected(true);

		// Broadcast endpoint discovered
		Intent i = new Intent("com.butchmarshall.reactnative.google.nearby.connection.ConnectedToEndpoint");
		Bundle bundle = new Bundle();
		bundle.putString("endpointId", endpointId);
		bundle.putString("endpointName", endpointName);
		bundle.putString("serviceId", serviceId);
		i.putExtras(bundle);

		final Activity activity = getCurrentActivity();
		activity.sendBroadcast(i);
	}

	private BroadcastReceiver mConnectedToEndpointReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			if (getReactApplicationContext().hasActiveCatalystInstance()) {
				String endpointId = intent.getStringExtra("endpointId");
				String endpointName = intent.getStringExtra("endpointName");
				String serviceId = intent.getStringExtra("serviceId");

				WritableMap out = Arguments.createMap();
				out.putString("endpointId", endpointId);
				out.putString("endpointName", endpointName);
				out.putString("serviceId", serviceId);
				
				sendEvent(getReactApplicationContext(), "connected_to_endpoint", out);
			}
		}
	};
	private void unregisterConnectedToEndpointHandler() {
		getReactApplicationContext().unregisterReceiver(mConnectedToEndpointReceiver);
	}
	private void registerConnectedToEndpointHandler() {
		IntentFilter intentFilter = new IntentFilter("com.butchmarshall.reactnative.google.nearby.connection.ConnectedToEndpoint");
		getReactApplicationContext().registerReceiver(mConnectedToEndpointReceiver, intentFilter);
	}

	/**
	 * Called when a connection to a nearby advertiser is initiated
	 */
	private void connectionInitiatedToEndpoint(final String serviceId, final String endpointId, final ConnectionInfo connectionInfo) {
		final Endpoint endpoint = mEndpoints.get(serviceId+"_"+endpointId);

		String authenticationToken = connectionInfo.getAuthenticationToken();
		String endpointName = connectionInfo.getEndpointName();
		Boolean incomingConnection = connectionInfo.isIncomingConnection();

		// Broadcast endpoint discovered
		Intent i = new Intent("com.butchmarshall.reactnative.google.nearby.connection.ConnectionInitiatedToEndpoint");
		Bundle bundle = new Bundle();
		bundle.putString("endpointId", endpointId);
		bundle.putString("endpointName", endpointName);
		bundle.putString("serviceId", serviceId);
		bundle.putString("authenticationToken", authenticationToken);
		bundle.putBoolean("incomingConnection", incomingConnection);
		i.putExtras(bundle);

		final Activity activity = getCurrentActivity();
		activity.sendBroadcast(i);
	}

	private BroadcastReceiver mConnectionInitiatedToEndpointReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			if (getReactApplicationContext().hasActiveCatalystInstance()) {
				String endpointId = intent.getStringExtra("endpointId");
				String endpointName = intent.getStringExtra("endpointName");
				String serviceId = intent.getStringExtra("serviceId");
				String authenticationToken = intent.getStringExtra("authenticationToken");
				Boolean incomingConnection = intent.getBooleanExtra("incomingConnection", false);

				WritableMap out = Arguments.createMap();
				out.putString("endpointId", endpointId);
				out.putString("endpointName", endpointName);
				out.putString("serviceId", serviceId);
				out.putString("authenticationToken", authenticationToken);
				out.putBoolean("incomingConnection", incomingConnection);

				sendEvent(getReactApplicationContext(), "connection_initiated_to_endpoint", out);
			}
		}
	};
	private void unregisterConnectionInitiatedToEndpointHandler() {
		getReactApplicationContext().unregisterReceiver(mConnectionInitiatedToEndpointReceiver);
	}
	private void registerConnectionInitiatedToEndpointHandler() {
		IntentFilter intentFilter = new IntentFilter("com.butchmarshall.reactnative.google.nearby.connection.ConnectionInitiatedToEndpoint");
		getReactApplicationContext().registerReceiver(mConnectionInitiatedToEndpointReceiver, intentFilter);
	}

	/**
	 * Called when a nearby endpoint is lost
	 */
	private void endpointLost(final String serviceId, final String endpointId) {
		final Endpoint endpoint = mEndpoints.get(serviceId+"_"+endpointId);

		String endpointName = endpoint.getName();
		
		// Broadcast endpoint discovered
		Intent i = new Intent("com.butchmarshall.reactnative.google.nearby.connection.EndPointLost");
		Bundle bundle = new Bundle();
		bundle.putString("endpointId", endpointId);
		bundle.putString("serviceId", serviceId);
		bundle.putString("endpointName", endpointName);
		i.putExtras(bundle);

		final Activity activity = getCurrentActivity();
		activity.sendBroadcast(i);
	}

	private BroadcastReceiver mEndpointLostReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			if (getReactApplicationContext().hasActiveCatalystInstance()) {
				String endpointId = intent.getStringExtra("endpointId");
				String endpointName = intent.getStringExtra("endpointName");
				String serviceId = intent.getStringExtra("serviceId");

				WritableMap out = Arguments.createMap();
				out.putString("endpointId", endpointId);
				out.putString("endpointName", endpointName);
				out.putString("serviceId", serviceId);

				sendEvent(getReactApplicationContext(), "endpoint_lost", out);
			}
		}
	};
	private void unregisterEndpointLostHandler() {
		getReactApplicationContext().unregisterReceiver(mEndpointLostReceiver);
	}
	private void registerEndpointLostHandler() {
		IntentFilter intentFilter = new IntentFilter("com.butchmarshall.reactnative.google.nearby.connection.EndPointLost");
		getReactApplicationContext().registerReceiver(mEndpointLostReceiver, intentFilter);
	}

	/**
	 * Called when a remote endpoint is discovered.
     */
	private void onEndpointDiscovered(final String serviceId, final String endpointId) {
		final Endpoint endpoint = mEndpoints.get(serviceId+"_"+endpointId);

		String endpointName = endpoint.getName();

		// We found an advertiser!
		// stopDiscovering(serviceId); - should we actually stop discovering?  Maybe more peeps!

		// Broadcast endpoint discovered
		Intent i = new Intent("com.butchmarshall.reactnative.google.nearby.connection.EndPointDiscovered");
		Bundle bundle = new Bundle();
		bundle.putString("endpointName", endpointName);
		bundle.putString("serviceId", serviceId);
		bundle.putString("endpointId", endpointId);
		i.putExtras(bundle);

		final Activity activity = getCurrentActivity();
		activity.sendBroadcast(i);
	}

	private BroadcastReceiver mEndpointDiscoveredReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			if (getReactApplicationContext().hasActiveCatalystInstance()) {
				String endpointId = intent.getStringExtra("endpointId");
				String endpointName = intent.getStringExtra("endpointName");
				String serviceId = intent.getStringExtra("serviceId");

				WritableMap out = Arguments.createMap();
				out.putString("endpointId", endpointId);
				out.putString("endpointName", endpointName);
				out.putString("serviceId", serviceId);

				sendEvent(getReactApplicationContext(), "endpoint_discovered", out);
			}
		}
	};
	private void unregisterEndpointDiscoveredHandler() {
		getReactApplicationContext().unregisterReceiver(mEndpointDiscoveredReceiver);
	}
	private void registerEndpointDiscoveredHandler() {
		IntentFilter intentFilter = new IntentFilter("com.butchmarshall.reactnative.google.nearby.connection.EndPointDiscovered");
		getReactApplicationContext().registerReceiver(mEndpointDiscoveredReceiver, intentFilter);
	}

	/**
	 * Sends a connection request to the endpoint. Either {@link #onConnectionInitiated(Endpoint,
	 * ConnectionInfo)} or {@link #onConnectionFailed(Endpoint)} will be called once we've found out
	 * if we successfully reached the device.
	 */
	@ReactMethod
	public void connectToEndpoint(final String serviceId, final String endpointId) {
		final Endpoint endpoint = mEndpoints.get(serviceId+"_"+endpointId);
		if (endpoint == null) {
			logW("connectToEndpoint failed to service "+serviceId+" and endpoint "+endpointId+", could not find endpoint");
			return;
		}

		final String endpointName = endpoint.getName();

		logV("connectToEndpoint request to service "+serviceId+" and endpoint " + endpointId);

		final ConnectionsClient clientSingleton = getConnectionsClientSingleton(serviceId);

		// Mark ourselves as connecting so we don't connect multiple times
		mIsConnecting = true;

		// Ask to connect
		clientSingleton
			.requestConnection(endpointName, endpointId, getConnectionLifecycleCallback(serviceId, "discovering"))
			.addOnFailureListener(
				new OnFailureListener() {
					@Override
					public void onFailure(@NonNull Exception e) {
						ApiException apiException = (ApiException) e;

						logW("connectToEndpoint to service "+serviceId+" and endpoint " + endpointId+" failed.", e);
						mIsConnecting = false;
						endpointConnectionFailed(serviceId, endpointId, apiException.getStatusCode());
					}
				}
			);
	}

	/** Disconnects from the given endpoint. */
	@ReactMethod
	public void disconnectFromEndpoint(final String serviceId, final String endpointId) {
		final Endpoint endpoint = mEndpoints.get(serviceId+"_"+endpointId);
		if (endpoint == null) {
			logW("disconnectFromEndpoint failed from service "+serviceId+" and endpoint "+endpointId);
			return;
		}

		final ConnectionsClient clientSingleton = getConnectionsClientSingleton(serviceId);

		clientSingleton.disconnectFromEndpoint(endpointId);

		disconnectedFromEndpoint(serviceId, endpointId);
	}

	/** Removes a payload */
	@ReactMethod
	public void removePayload(final String serviceId, final String endpointId, final String payloadId) {
		mReceivedPayloads.remove(serviceId+"_"+endpointId+"_"+payloadId);
	}

	/** Send a file to a connected device. */
	@ReactMethod
	public void sendFile(final String serviceId, final String endpointId, final String path, final String metadata) {
		Uri uri = Uri.parse(path);

		logV("sendFile to service "+serviceId+" and endpoint " + endpointId + ", "+ uri);

		try {
			// Open the ParcelFileDescriptor for this URI with read access.
			ParcelFileDescriptor pfd = getReactApplicationContext().getContentResolver().openFileDescriptor(uri, "r");
			Payload filePayload = Payload.fromFile(pfd);

			String payloadMessage = Payload.Type.FILE+":"+filePayload.getId() + ":" + uri.getLastPathSegment() + ":" + metadata;
			sendPayload(serviceId, endpointId, Payload.fromBytes(payloadMessage.getBytes("UTF-8")));

			sendPayload(serviceId, endpointId, filePayload);
		}
		catch (FileNotFoundException e)   {
			logW("sendFile() failed.", e);
		}
		catch(IOException e) {
			logW("sendFile() failed.", e);
		}
	}

	/** Send bytes to an endpoint */
	@ReactMethod
	public void sendBytes(final String serviceId, final String endpointId, final String bytes) {
		logV("sendBytes to service "+serviceId+" and endpoint " + endpointId +" byte payload "+bytes);

		try {
			String payloadMessage = Payload.Type.BYTES+":"+ bytes;

			sendPayload(serviceId, endpointId, Payload.fromBytes(payloadMessage.getBytes("UTF-8")));
		}
		catch(IOException e) {
			logW("sendBytes() failed.", e);
		}
	}

	/** Read bytes. */
	@ReactMethod
	public void readBytes(final String serviceId, final String endpointId, final String payloadId, final Promise promise) {
		logV("readBytes from service "+serviceId+" and endpoint " + endpointId + " and payload "+Long.parseLong(payloadId, 10)+" ");

		Payload payload = mReceivedPayloads.get(serviceId+"_"+endpointId+"_"+Long.parseLong(payloadId, 10));
		if (payload == null) {
			logV("Cannot find payload.");
			return;
		}
		if (payload.getType() != Payload.Type.BYTES) {
			logV("Cannot get, not bytes.");
			return;
		}

		try {
			String bytes = new String(payload.asBytes(), "UTF-8");

			int colonIndex = bytes.indexOf(':');
			int payloadType = Integer.parseInt(bytes.substring(0, colonIndex));
			bytes = bytes.substring(colonIndex + 1);

			WritableMap out = Arguments.createMap();
			out.putInt("type", payloadType);

			// Simple bytes payload
			if (payloadType == Payload.Type.BYTES) {
				out.putString("bytes", bytes);
			}
			// Represents a file or stream payload
			else if (payloadType == Payload.Type.FILE || payloadType == Payload.Type.STREAM) {
				// Get payloadId of payload represented
				colonIndex = bytes.indexOf(':');
				out.putString("payloadId", bytes.substring(0, colonIndex));

				bytes = bytes.substring(colonIndex + 1);
				colonIndex = bytes.indexOf(':');

				if (payloadType == Payload.Type.STREAM) {
					out.putString("streamType", bytes.substring(0, colonIndex));
				}
				else {
					out.putString("filename", bytes.substring(0, colonIndex));
				}
				out.putString("metadata", bytes.substring(colonIndex + 1));
			}

			promise.resolve(out);
		}
		catch (UnsupportedEncodingException ex) {
			promise.reject("");
		}
	}

	/** File a file to a uri. */
	@ReactMethod
	public void saveFile(final String serviceId, final String endpointId, final String payloadId, final Promise promise) {
		logV("saveFile from service "+serviceId+" and endpoint " + endpointId + " and payload "+payloadId);

		final Payload payload = mReceivedPayloads.get(serviceId+"_"+endpointId+"_"+payloadId);
		if (payload == null) {
			logV("Cannot find payload.");
			promise.reject("");
			return;
		}
		if (payload.getType() != Payload.Type.FILE) {
			logV("Cannot save, not a file.");
			promise.reject("");
			return;
		}

		final String payloadFileData = mPayloadFileData.get(payloadId);
		int colonIndex = payloadFileData.indexOf(':');
		final String payloadFilename = payloadFileData.substring(0, colonIndex);
		final String payloadMetadata = payloadFileData.substring(colonIndex+1);

		if (payloadFilename == null) {
			logV("Cannot find filename for "+payloadId);
			promise.reject("");
			return;
		}

		final Activity activity = getCurrentActivity();

		permissionsCheck(activity, Arrays.asList(getRequiredStoragePermissions()), new Callable<Void>() {
            @Override
            public Void call() throws Exception {
				File payloadFile = payload.asFile().asJavaFile();
				if (payloadFile == null) {
					logV("Cannot convert to file.");
					promise.reject("");
				}
				else {
					File destPath = payloadFile.getParentFile();
					String extension = NearbyConnectionModule.getFileExtension(payloadFilename);

					File destFile = NearbyConnectionModule.getUniqueFile(destPath, extension);

					payloadFile.renameTo(destFile);

					String destFilePath = destFile.getPath();
					logV("file saved to "+destFilePath);

					WritableMap out = Arguments.createMap();
					out.putString("path", destFilePath);
					out.putString("originalFilename", payloadFilename);
					out.putString("metadata", payloadMetadata);

					promise.resolve(out);
				}

				return null;
			}
		});
	}

	/** Send sound from the microphone and stream to a connected device. */
	@ReactMethod
	public void openMicrophone(final String serviceId, final String endpointId, final String metadata) {
		logV("openMicrophone to service "+serviceId+" and endpoint " + endpointId);

		final Activity activity = getCurrentActivity();

		permissionsCheck(activity, Arrays.asList(getRequiredAudioPermissions()), new Callable<Void>() {
            @Override
            public Void call() throws Exception {
				try {
					ParcelFileDescriptor[] payloadPipe = ParcelFileDescriptor.createPipe();

					Payload streamPayload = Payload.fromStream(payloadPipe[0]);

					// Send payload indicating this is an audio stream
					String payloadMessage = Payload.Type.STREAM+":"+streamPayload.getId() + ":audio:" + metadata;
					sendPayload(serviceId, endpointId, Payload.fromBytes(payloadMessage.getBytes("UTF-8")));

					// Send the first half of the payload (the read side) to Nearby Connections.
					sendPayload(serviceId, endpointId, streamPayload);

					// Use the second half of the payload (the write side) in AudioRecorder.
					AudioRecorder recorder = new AudioRecorder(payloadPipe[1]);

					mRecorders.put(serviceId+"_"+endpointId, recorder);

					recorder.start();
				}
				catch (IOException e) {
					logW("openMicrophone error", e);
				}

				return null;
			}
		});
	}

	/** Stops streaming sound from the microphone. */
	@ReactMethod
	private void closeMicrophone(final String serviceId, String endpointId) {
		logV("closeMicrophone to service "+serviceId+" and endpoint " + endpointId);

		AudioRecorder recorder = mRecorders.remove(serviceId+"_"+endpointId);

		if (recorder != null) {
			recorder.stop();
			recorder = null;
		}
	}

	/** Starts streaming sound from an endpoint. */
	@ReactMethod
	private void startPlayingAudioStream(final String serviceId, final String endpointId, final String payloadId) {
		logV("startPlayingAudioStream from service "+serviceId+" and endpoint " + endpointId + " and payload "+payloadId);

		Payload payload = mReceivedPayloads.get(serviceId+"_"+endpointId+"_"+payloadId);

		if (payload.getType() != Payload.Type.STREAM) {
			logV("startPlayingAudioStream from service "+serviceId+" and endpoint " + endpointId +" and payload "+payloadId+" failure.  Not a stream.");
			return;
		}
		final Activity activity = getCurrentActivity();

		AudioPlayer player = new AudioPlayer(payload.asStream().asInputStream()) {
			@WorkerThread
			@Override
			protected void onFinish() {
				activity.runOnUiThread(
					new Runnable() {
						@UiThread
						@Override
						public void run() {
							logV("audioPlayer onFinish "+serviceId+" and endpoint " + endpointId + " and payload "+payloadId);
							mAudioPlayers.remove(serviceId+"_"+endpointId+"_"+payloadId);
						}
					}
				);
			}
		};
		mAudioPlayers.put(serviceId+"_"+endpointId+"_"+payloadId, player);

		player.start();
	}

	@ReactMethod
	private void stopPlayingAudioStream(final String serviceId, String endpointId, final String payloadId) {
		logV("stopPlayingAudioStream from service "+serviceId+" and endpoint " + endpointId + " and payload "+payloadId);

		AudioPlayer player = mAudioPlayers.remove(serviceId+"_"+endpointId+"_"+payloadId);
		if (player == null) {
			return;
		}

		player.stop();
	}

	/** @return True if currently streaming from the microphone. */
	@ReactMethod
	private boolean isMicrophoneOpen() {
		for (AudioRecorder recorder : mRecorders.values()) {
			if (recorder != null && recorder.isRecording()) {
				return true;
			}
		}

		return false;
	}

	/**
	 * @return All permissions required for the app connectivity to properly function.
	 */
	protected String[] getRequiredPermissions() {
		return REQUIRED_PERMISSIONS;
	}

	/**
	 * @return All permissions required audio transfer to properly function
	 */
	protected String[] getRequiredAudioPermissions() {
		return REQUIRED_AUDIO_PERMISSIONS;
	}

	/**
	 * @return All permissions required for file transfer to properly function
	 */
	protected String[] getRequiredStoragePermissions() {
		return REQUIRED_STORAGE_PERMISSIONS;
	}
	
	/**
	* Returns {@code true} if the app was granted all the permissions. Otherwise, returns {@code
	* false}.
	*/
	public static boolean hasPermissions(Context context, String... permissions) {
		for (String permission : permissions) {
			if (ContextCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) {
				return false;
			}
		}
		return true;
	}

    private void permissionsCheck(final Activity activity, final List<String> requiredPermissions, final Callable<Void> callback) {

        List<String> missingPermissions = new ArrayList<>();

        for (String permission : requiredPermissions) {
            int status = ActivityCompat.checkSelfPermission(activity, permission);
            if (status != PackageManager.PERMISSION_GRANTED) {
                missingPermissions.add(permission);
            }
        }

        if (!missingPermissions.isEmpty()) {
            ((PermissionAwareActivity) activity).requestPermissions(missingPermissions.toArray(new String[missingPermissions.size()]), 1, new PermissionListener() {

                @Override
                public boolean onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
                    if (requestCode == 1) {

                        for (int grantResult : grantResults) {
                            if (grantResult == PackageManager.PERMISSION_DENIED) {
                                return true;
                            }
                        }

                        try {
                            callback.call();
                        } catch (Exception e) {
							logV("permissionsCheck error.");
                        }
                    }

                    return true;
                }
            });

            return;
        }

        // all permissions granted
        try {
            callback.call();
        } catch (Exception e) {
			logV("permissionsCheck error.");
        }
    }

	/**
	 * Sends a {@link Payload} to all currently connected endpoints.
	 *
	 * @param payload The data you want to send.
	 */
	protected void sendPayload(final String serviceId, final String endpointId, final Payload payload) {
		final ConnectionsClient clientSingleton = getConnectionsClientSingleton(serviceId);

		clientSingleton
			.sendPayload(endpointId, payload)
			.addOnFailureListener(
				new OnFailureListener() {
					@Override
					public void onFailure(@NonNull Exception e) {
						ApiException apiException = (ApiException) e;

						logW("sendPayload() failed.", e);

						onSendPayloadFailed(serviceId, endpointId, payload, apiException.getStatusCode());
					}
				});
	}

	/**
	 * send a JS event
	 **/
	protected static void sendEvent(final ReactContext context, final String eventName, Object body) {
		if (context != null) {
			context
				.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
				.emit(eventName, body);
		} else {
			Log.v(TAG, "Missing context - cannot send event!");
		}
	}

	/** A safe way to get an instance of the Camera object. */
	private static Camera getCameraInstance(){
		Camera c = null;
		try {
			c = Camera.open(); // attempt to get a Camera instance
		}
		catch (Exception e){
			// Camera is not available (in use or does not exist)
		}
		return c; // returns null if camera is unavailable
	}

	/** Check if this device has a camera */
	private static boolean hasCameraHardware(Context context) {
		if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA)){
			// this device has a camera
			return true;
		} else {
			// no camera on this device
			return false;
		}
	}

	/**
	 * Transforms a {@link Status} into a English-readable message for logging.
	 *
	 * @param status The current status
	 * @return A readable String. eg. [404]File not found.
	 */
	private static String statusToString(Status status) {
	  return String.format(
		  Locale.US,
		  "[%d]%s",
		  status.getStatusCode(),
		  status.getStatusMessage() != null
			  ? status.getStatusMessage()
			  : ConnectionsStatusCodes.getStatusCodeString(status.getStatusCode()));
	}
	
	@CallSuper
	protected void logV(String msg) {
		Log.v(TAG, msg);
	}

	@CallSuper
	protected void logD(String msg) {
		Log.d(TAG, msg);
	}

	@CallSuper
	protected void logW(String msg) {
		Log.w(TAG, msg);
	}

	@CallSuper
	protected void logW(String msg, Throwable e) {
		Log.w(TAG, msg, e);
	}

	@CallSuper
	protected void logE(String msg, Throwable e) {
		Log.e(TAG, msg, e);
	}

	private static File getUniqueFile(File directory, String extension) {
		return new File(directory, new StringBuilder()
			.append(UUID.randomUUID())
			.append(".")
			.append(extension).toString()
		);
	}

	private static String getFileExtension(String name) {
		try {
			return name.substring(name.lastIndexOf(".") + 1);
		} catch (Exception e) {
			return "";
		}
	}

	/** Represents a device we can talk to. */
	protected static class Endpoint {
		@NonNull private final String serviceId;
		@NonNull private final String id;
		@NonNull private final String name;
		@NonNull private final String type;
		@NonNull private Boolean connected;

		private Endpoint(@NonNull String serviceId, @NonNull String id, @NonNull String name, @NonNull String type) {
			this.serviceId = serviceId;
			this.id = id;
			this.name = name;
			this.type = type;
			this.connected = false;
		}

		public WritableMap toWritableMap() {
			WritableMap out = Arguments.createMap();

			out.putString("serviceId", serviceId);
			out.putString("endpointId", id);
			out.putString("endpointName", name);
			out.putBoolean("connected", connected);
			out.putString("type", type);

			return out;
		}
		
		public void setConnected(final Boolean newValue) {
			this.connected = newValue;
		}

		@NonNull
		public Boolean isConnected() {
			return connected;
		}

		/**
		 * Discovered or advertised
		 */
		@NonNull
		public String getType() {
			return type;
		}

		@NonNull
		public String getServiceId() {
			return serviceId;
		}
		
		@NonNull
		public String getId() {
			return id;
		}

		@NonNull
		public String getName() {
		  return name;
		}

		@Override
		public boolean equals(Object obj) {
			if (obj != null && obj instanceof Endpoint) {
				Endpoint other = (Endpoint) obj;
				return id.equals(other.id);
			}
			return false;
		}

		@Override
		public int hashCode() {
			return id.hashCode();
		}

		@Override
		public String toString() {
			return String.format("Endpoint{id=%s, name=%s}", id, name);
		}
	}
}