com.google.android.gms.nearby.connection.ConnectionInfo Java Examples

/**
 * 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);
}
 

@Override
protected void onNearbyConnectionInitiated(String endpointId, ConnectionInfo connectionInfo) {
    super.onNearbyConnectionInitiated(endpointId, connectionInfo);
    RobocarConnection connection = mRobocarConnectionLiveData.getValue();
    if (connection != null && connection.endpointMatches(endpointId)) {
        connection.setAuthToken(connectionInfo.getAuthenticationToken());
        if (connection.isAutoConnect()) {
            acceptConnection();
        } else {
            // Wait for something else to call acceptConnection.
            connection.setState(ConnectionState.AUTHENTICATING);
        }
    } else {
        // We didn't request this connection, so reject it.
        rejectConnection(endpointId);
    }
}
 

@Override
public void onConnectionInitiated(String endpointId, ConnectionInfo connectionInfo) {
  logD(
      String.format(
          "onConnectionInitiated(endpointId=%s, endpointName=%s)",
          endpointId, connectionInfo.getEndpointName()));
  Endpoint endpoint = new Endpoint(endpointId, connectionInfo.getEndpointName());
  mPendingConnections.put(endpointId, endpoint);
  ConnectionsActivity.this.onConnectionInitiated(endpoint, connectionInfo);
}
 

@Override
protected void onConnectionInitiated(Endpoint endpoint, ConnectionInfo connectionInfo) {
  // A connection to another device has been initiated! We'll use the auth token, which is the
  // same on both devices, to pick a color to use when we're connected. This way, users can
  // visually see which device they connected with.
  mConnectedColor = COLORS[connectionInfo.getAuthenticationToken().hashCode() % COLORS.length];

  // We accept the connection immediately.
  acceptConnection(endpoint);
}
 

@Override
protected void onNearbyConnectionInitiated(final String endpointId,
        ConnectionInfo connectionInfo) {
    super.onNearbyConnectionInitiated(endpointId, connectionInfo);
    if (mCompanionConnectionLiveData.getValue() != null) {
        // We already have a companion trying to connect. Reject this one.
        Nearby.Connections.rejectConnection(mGoogleApiClient, endpointId);
        return;
    }


    DiscovererInfo info = DiscovererInfo.parse(connectionInfo.getEndpointName());
    if (info == null || isNotTheDroidWeAreLookingFor(info)) {
        // Discoverer looks malformed, or doesn't match our previous paired companion.
        Nearby.Connections.rejectConnection(mGoogleApiClient, endpointId);
        return;
    }

    // Store the endpoint and accept.
    CompanionConnection connection = new CompanionConnection(endpointId, info, this);
    connection.setAuthToken(connectionInfo.getAuthenticationToken());
    connection.setState(ConnectionState.AUTH_ACCEPTED);
    mCompanionConnectionLiveData.setValue(connection);

    Nearby.Connections.acceptConnection(mGoogleApiClient, endpointId, mInternalPayloadListener)
            .setResultCallback(new ResultCallback<Status>() {
                @Override
                public void onResult(@NonNull Status status) {
                    if (status.isSuccess()) {
                        Log.d(TAG, "Accepted connection. " + endpointId);
                        // TODO implement a timeout
                    } else {
                        Log.d(TAG, "Accept connection failed." + endpointId);
                        // revert state
                        clearCompanionEndpoint();
                    }
                }
            });
}
 

@Override
protected void onConnectionInitiated(Endpoint endpoint, ConnectionInfo connectionInfo) {
    // A connection to another device has been initiated! We'll use the auth token, which is the
    // same on both devices, to pick a color to use when we're connected. This way, users can
    // visually see which device they connected with.
    //  mConnectedColor = COLORS[connectionInfo.getAuthenticationToken().hashCode() % COLORS.length];
    acceptConnection(endpoint);
    addContact(endpoint.getName());
}
 

@Override
public void onConnectionInitiated(String endpointId, ConnectionInfo connectionInfo) {
  logD(
      String.format(
          "onConnectionInitiated(endpointId=%s, endpointName=%s)",
          endpointId, connectionInfo.getEndpointName()));
  Endpoint endpoint = new Endpoint(endpointId, connectionInfo.getEndpointName());
  mPendingConnections.put(endpointId, endpoint);
  ConnectionsActivity.this.onConnectionInitiated(endpoint, connectionInfo);
}
 

@Override
protected void onConnectionInitiated(Endpoint endpoint, ConnectionInfo connectionInfo) {
  // A connection to another device has been initiated! We'll accept the connection immediately.
  acceptConnection(endpoint);
}
 

@Override
public void onConnectionInitiated(String endpointId, ConnectionInfo connectionInfo) {
    connectionsClient.acceptConnection(endpointId, payloadCallback);
    opponentName = connectionInfo.getEndpointName();
}
 

/**
 * Called when a pending connection with a remote endpoint is created. Use {@link ConnectionInfo}
 * for metadata about the connection (like incoming vs outgoing, or the authentication token). If
 * we want to continue with the connection, call {@link #acceptConnection(Endpoint)}. Otherwise,
 * call {@link #rejectConnection(Endpoint)}.
 */
protected void onConnectionInitiated(Endpoint endpoint, ConnectionInfo connectionInfo) {}
 

/**
 * Called when a pending connection with a remote endpoint is created. Use {@link ConnectionInfo}
 * for metadata about the connection (like incoming vs outgoing, or the authentication token). If
 * we want to continue with the connection, call {@link #acceptConnection(Endpoint)}. Otherwise,
 * call {@link #rejectConnection(Endpoint)}.
 */
protected void onConnectionInitiated(Endpoint endpoint, ConnectionInfo connectionInfo) {}
 

protected void onNearbyConnectionInitiated(String endpointId, ConnectionInfo connectionInfo) {}