import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
@Override
protected void onStop() {
    super.onStop();

    if (mGoogleApiClient != null && mGoogleApiClient.isConnected()) {
        Nearby.Connections.stopAdvertising(mGoogleApiClient);

        if (!mRemotePeerEndpoints.isEmpty()) {
            Nearby.Connections.sendPayload(mGoogleApiClient, mRemotePeerEndpoints, Payload.fromBytes("Shutting down host".getBytes(Charset.forName("UTF-8"))));
            Nearby.Connections.stopAllEndpoints(mGoogleApiClient);
            mRemotePeerEndpoints.clear();
        }

        mGoogleApiClient.disconnect();
    }
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
public void disconnect() {
    Timber.d("disconnect");
    if (mGoogleApiClient.isConnected()) {
        Nearby.Connections.stopAdvertising(mGoogleApiClient);

        if (!mRemotePeerEndpoints.isEmpty()) {
            Nearby.Connections.sendPayload(mGoogleApiClient,
                    mRemotePeerEndpoints,
                    Payload.fromBytes("Shutting down host".getBytes(Charset.forName("UTF-8"))));
            Nearby.Connections.stopAllEndpoints(mGoogleApiClient);
            mRemotePeerEndpoints.clear();
        }

        mGoogleApiClient.disconnect();
    }
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
private void sendStop() {
    if (!googleApiClient.isConnected()) {
        view.showApiNotConnected();
        return;
    }
    Nearby.Connections.sendReliableMessage(googleApiClient, otherEndpointId, toByteArray(-1));

}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
@Override
public void onConnectionRequest(final String endpointId, String deviceId, String endpointName, byte[] payload) {
    Log.d(TAG, "onConnectionRequest");

    Nearby.Connections.acceptConnectionRequest(googleApiClient, endpointId, payload, this)
            .setResultCallback(new ResultCallback<Status>() {
                @Override
                public void onResult(@NonNull Status status) {
                    if (status.isSuccess()) {
                        Log.d(TAG, "acceptConnectionRequest: SUCCESS");

                    } else {
                        Log.d(TAG, "acceptConnectionRequest: FAILURE");
                    }
                }
            });
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
protected void startDiscovering() {
    Nearby.Connections.startDiscovery(connection, serviceId, Connections.DURATION_INDEFINITE, this)
            .setResultCallback(new ResultCallback<Status>() {
                @Override
                public void onResult(@NonNull Status status) {
                    switch (status.getStatusCode()) {
                        case ConnectionsStatusCodes.STATUS_OK:
                            onNearbyConnectionDiscoveringSuccess();
                            break;
                        case ConnectionsStatusCodes.STATUS_NETWORK_NOT_CONNECTED:
                            onNearbyConnectionNetworkNotConnected();
                            break;
                        case ConnectionsStatusCodes.STATUS_ALREADY_DISCOVERING:
                            break;
                    }
                }
            });
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
protected void startAdvertising(String name) {
    List<AppIdentifier> appIdentifierList = new ArrayList<>();
    appIdentifierList.add(new AppIdentifier(connection.getContext().getPackageName()));
    AppMetadata appMetadata = new AppMetadata(appIdentifierList);

    Nearby.Connections.startAdvertising(connection, name, appMetadata, Connections.DURATION_INDEFINITE, this)
            .setResultCallback(new ResultCallback<Connections.StartAdvertisingResult>() {
                @Override
                public void onResult(@NonNull Connections.StartAdvertisingResult result) {
                    switch (result.getStatus().getStatusCode()) {
                        case ConnectionsStatusCodes.STATUS_OK:
                            onNearbyConnectionAdvertisingSuccess();
                            break;
                        case ConnectionsStatusCodes.STATUS_NETWORK_NOT_CONNECTED:
                            onNearbyConnectionNetworkNotConnected();
                            break;
                        case ConnectionsStatusCodes.STATUS_ALREADY_ADVERTISING:
                            break;
                        case ConnectionsStatusCodes.STATUS_ERROR:
                            onNearbyConnectionError(result.getStatus());
                            break;
                    }
                }
            });
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
protected void sendConnectionRequest(String remoteEndpointId) {
    Nearby.Connections.sendConnectionRequest(connection, null, remoteEndpointId, null, this, this)
            .setResultCallback(new ResultCallback<Status>() {
                @Override
                public void onResult(@NonNull Status status) {
                    switch (status.getStatusCode()) {
                        case ConnectionsStatusCodes.STATUS_OK:
                            break;
                        case ConnectionsStatusCodes.STATUS_NETWORK_NOT_CONNECTED:
                            onNearbyConnectionNetworkNotConnected();
                            break;
                        case ConnectionsStatusCodes.STATUS_ALREADY_CONNECTED_TO_ENDPOINT:
                            break;
                    }
                }
            });
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
protected void acceptConnectionRequest(final String remoteEndpointId) {
    Nearby.Connections.acceptConnectionRequest(connection, remoteEndpointId, null, this)
            .setResultCallback(new ResultCallback<Status>() {
                @Override
                public void onResult(@NonNull Status status) {
                    switch (status.getStatusCode()) {
                        case ConnectionsStatusCodes.STATUS_OK:
                            onNearbyConnectionEndpointConnected(remoteEndpointId);
                            break;
                        case ConnectionsStatusCodes.STATUS_NETWORK_NOT_CONNECTED:
                            onNearbyConnectionNetworkNotConnected();
                            break;
                        case ConnectionsStatusCodes.STATUS_ALREADY_CONNECTED_TO_ENDPOINT:
                            break;
                    }
                }
            });
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
/**
 * Send a reliable message to the connected peer. Takes the contents of the EditText and
 * sends the message as a byte[].
 */
private void sendMessage() {
    // Sends a reliable message, which is guaranteed to be delivered eventually and to respect
    // message ordering from sender to receiver. Nearby.Connections.sendUnreliableMessage
    // should be used for high-frequency messages where guaranteed delivery is not required, such
    // as showing one player's cursor location to another. Unreliable messages are often
    // delivered faster than reliable messages.
    String msg = mMessageText.getText().toString();
    Nearby.Connections.sendReliableMessage(mGoogleApiClient, mOtherEndpointId, msg.getBytes());

    mMessageText.setText(null);

    View view = getActivity().getCurrentFocus();
    if (view != null) {
        InputMethodManager imm = (InputMethodManager) getActivity()
                .getSystemService(Context.INPUT_METHOD_SERVICE);

        imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
    }
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
/**
 * Begin advertising for Nearby Connections.
 */
public void startAdvertising() {
    long NO_TIMEOUT = 0L;

    Nearby.Connections.startAdvertising(mGoogleApiClient, null, null,
            NO_TIMEOUT, myConnectionRequestListener)
            .setResultCallback(new ResultCallback<Connections.StartAdvertisingResult>() {
                @Override
                public void onResult(Connections.StartAdvertisingResult result) {
                    if (result.getStatus().isSuccess()) {
                        Log.d(TAG, "Advertising as " +
                                result.getLocalEndpointName());
                        mState = STATE_ADVERTISING;
                    } else {
                        Log.w(TAG, "Failed to start advertising: " +
                                result.getStatus());
                        mState = STATE_IDLE;
                    }
                }
            });
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
/**
 * Begin discovering Nearby Connections.
 *
 * @param serviceId the ID of advertising services to discover.
 */
public void startDiscovery(String serviceId) {
    Nearby.Connections.startDiscovery(mGoogleApiClient, serviceId, 0L,
            myEndpointDiscoveryListener)
            .setResultCallback(new ResultCallback<Status>() {
                @Override
                public void onResult(@NonNull Status status) {
                    if (status.isSuccess()) {
                        Log.d(TAG, "Started discovery.");
                        mState = STATE_DISCOVERING;
                    } else {
                        Log.w(TAG, "Failed to start discovery: " + status);
                        mState = STATE_IDLE;
                    }
                }
            });
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
private void disconnect() {
    if( !isConnectedToNetwork() )
        return;

    if( mIsHost ) {
        sendMessage( "Shutting down host" );
        Nearby.Connections.stopAdvertising( mGoogleApiClient );
        Nearby.Connections.stopAllEndpoints( mGoogleApiClient );
        mIsHost = false;
        mStatusText.setText( "Not connected" );
        mRemotePeerEndpoints.clear();
    } else {
        if( !mIsConnected || TextUtils.isEmpty( mRemoteHostEndpoint ) ) {
            Nearby.Connections.stopDiscovery( mGoogleApiClient, getString( R.string.service_id ) );
            return;
        }

        sendMessage( "Disconnecting" );
        Nearby.Connections.disconnectFromEndpoint( mGoogleApiClient, mRemoteHostEndpoint );
        mRemoteHostEndpoint = null;
        mStatusText.setText( "Disconnected" );
    }

    mIsConnected = false;
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
@Override
public void onConnectionRequest(final String remoteEndpointId, final String remoteDeviceId, final String remoteEndpointName, byte[] payload) {
    if( mIsHost ) {
        Nearby.Connections.acceptConnectionRequest( mGoogleApiClient, remoteEndpointId, payload, this ).setResultCallback(new ResultCallback<Status>() {
            @Override
            public void onResult(Status status) {
                if( status.isSuccess() ) {
                    if( !mRemotePeerEndpoints.contains( remoteEndpointId ) ) {
                        mRemotePeerEndpoints.add( remoteEndpointId );
                    }

                    getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

                    mMessageAdapter.notifyDataSetChanged();
                    sendMessage(remoteDeviceId + " connected!");

                    mSendTextContainer.setVisibility( View.VISIBLE );
                }
            }
        });
    } else {
        Nearby.Connections.rejectConnectionRequest(mGoogleApiClient, remoteEndpointId );
    }
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
private void startDiscovery() {
    Log.d(TAG, "startDiscovery");
    if (!isConnectedToNetwork()) {
        Log.d(TAG, "startDiscovery: not connected to WiFi network.");
        return;
    }

    Nearby.Connections.startDiscovery(googleApiClient, serviceId, TIMEOUT_DISCOVER, this)
            .setResultCallback(new ResultCallback<Status>() {
                @Override
                public void onResult(@NonNull Status status) {
                    if (!isViewAttached()) {
                        return;
                    }
                    if (status.isSuccess()) {
                        Log.d(TAG, "startDiscovery:onResult: SUCCESS");
                    } else {
                        Log.d(TAG, "startDiscovery:onResult: FAILURE");

                        int statusCode = status.getStatusCode();
                        if (statusCode == ConnectionsStatusCodes.STATUS_ALREADY_DISCOVERING) {
                            Log.d(TAG, "STATUS_ALREADY_DISCOVERING");
                        }
                    }
                }
            });
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
private void sendNote(final double frequency) {
    if (!googleApiClient.isConnected()) {
        view.showApiNotConnected();

        return;
    }
    Nearby.Connections.sendReliableMessage(googleApiClient, otherEndpointId, toByteArray(frequency));
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
private void startAdvertising() {
    Log.d(TAG, "startAdvertising");
    if (!isConnectedToNetwork()) {
        Log.d(TAG, "startAdvertising: not connected to WiFi network.");
        return;
    }

    List<AppIdentifier> appIdentifierList = new ArrayList<>();
    appIdentifierList.add(new AppIdentifier(packageName));
    AppMetadata appMetadata = new AppMetadata(appIdentifierList);
    Nearby.Connections.startAdvertising(googleApiClient, serviceId, appMetadata, 0L, this)
            .setResultCallback(new ResultCallback<Connections.StartAdvertisingResult>() {
                @Override
                public void onResult(@NonNull Connections.StartAdvertisingResult result) {
                    Log.d(TAG, "startAdvertising:onResult:" + result);
                    if (result.getStatus().isSuccess()) {
                        Log.d(TAG, "startAdvertising:onResult: SUCCESS");

                    } else {
                        Log.d(TAG, "startAdvertising:onResult: FAILURE ");
                        int statusCode = result.getStatus().getStatusCode();
                        if (statusCode == ConnectionsStatusCodes.STATUS_ALREADY_ADVERTISING) {
                            Log.d(TAG, "STATUS_ALREADY_ADVERTISING");
                        } else {
                            Log.d(TAG, "STATE_READY");
                        }
                    }
                }
            });
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
/**
 * Begin discovering devices advertising Nearby Connections, if possible.
 */
private void startDiscovery() {
    debugLog("startDiscovery");
    if (!isConnectedToNetwork()) {
        debugLog("startDiscovery: not connected to WiFi network.");
        return;
    }

    // Discover nearby apps that are advertising with the required service ID.
    String serviceId = getString(R.string.service_id);
    Nearby.Connections.startDiscovery(mGoogleApiClient, serviceId, TIMEOUT_DISCOVER, this)
            .setResultCallback(new ResultCallback<Status>() {
                @Override
                public void onResult(Status status) {
                    Log.d(TAG, "startDiscovery:onResult: " + status);
                    if (status.isSuccess()) {
                        debugLog("startDiscovery:onResult: SUCCESS");

                        updateViewVisibility(STATE_DISCOVERING);
                    } else {
                        debugLog("startDiscovery:onResult: FAILURE");

                        // If the user hits 'Discover' multiple times in the timeout window,
                        // the error will be STATUS_ALREADY_DISCOVERING
                        int statusCode = status.getStatusCode();
                        if (statusCode == ConnectionsStatusCodes.STATUS_ALREADY_DISCOVERING) {
                            debugLog("STATUS_ALREADY_DISCOVERING");
                        } else {
                            updateViewVisibility(STATE_READY);
                        }
                    }
                }
            });
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
/**
 * Send a reliable message to the Host from a Client.
 */
public void sendMessageToHost(String message) {
    try {
        byte[] payload = message.getBytes("UTF-8");
        Nearby.Connections.sendReliableMessage(mGoogleApiClient,
                mHostId, payload);
    } catch (UnsupportedEncodingException e) {
        Log.e(TAG, "Cannot encode " + message + " to UTF-8?");
    }
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
/**
 * Send a message to a specific participant.
 *
 * @param endpointId the endpoint ID of the participant that will
 *                   receive the message.
 * @param message    String to send as payload.
 */
public void sendMessageTo(String endpointId, String message) {

    try {
        byte[] payload = message.getBytes("UTF-8");
        Log.d(TAG, "Sending message: " + message);
        Nearby.Connections.sendReliableMessage(mGoogleApiClient,
                endpointId, payload);
    } catch (UnsupportedEncodingException e) {
        Log.e(TAG, "Cannot encode " + message + " to UTF-8?");
    }
}
 

import com.google.android.gms.nearby.connection.Connections; //导入依赖的package包/类
/**
 * Send a connection request to a remote endpoint. If the request is successful, notify the
 * listener and add the connection to the Set.  Otherwise, show an error Toast.
 *
 * @param endpointId   the endpointID to connect to.
 * @param endpointName the name of the endpoint to connect to.
 */
private void connectTo(final String endpointId,
                       final String endpointName) {
    Log.d(TAG, "connectTo:" + endpointId);
    Nearby.Connections.sendConnectionRequest(mGoogleApiClient, null,
            endpointId, null,
            new Connections.ConnectionResponseCallback() {
                @Override
                public void onConnectionResponse(String remoteEndpointId, Status status,
                                                 byte[] payload) {
                    Log.d(TAG, "onConnectionResponse:" +
                            remoteEndpointId + ":" + status);
                    if (status.isSuccess()) {
                        // Connection successful, notify listener
                        Toast.makeText(mContext, "Connected to: " + endpointName,
                                Toast.LENGTH_SHORT).show();

                        mHostId = remoteEndpointId;
                        mConnectedClients.put(remoteEndpointId,
                                new DrawingParticipant(
                                remoteEndpointId, endpointName));
                        mListener.onConnectedToEndpoint(mHostId,
                                endpointName);
                    } else {
                        // Connection not successful, show error
                        Toast.makeText(mContext, "Error: failed to connect.",
                                Toast.LENGTH_SHORT).show();
                    }
                }
            }, this);
}