Android 如何通过多个连接的设备识别移动设备中的磨损节点？

在我的手机中，此代码将返回所有连接的节点：

Wearable.NodeApi.getConnectedNodes(mGoogleApiClient).setResultCallback(new ResultCallback<NodeApi.GetConnectedNodesResult>() {
    @Override
    public void onResult(NodeApi.GetConnectedNodesResult getConnectedNodesResult) {
        Log.d(TAG, "Nodes: " + getConnectedNodesResult.getNodes());
    }
});

@Override
public void onPeerDisconnected(Node peer) {    
   // Which peer is this?
}

Notification that a peer has been disconnected from this node or is no 
longer reachable by this node.
Since multiple nodes can be connected to a network at the same time, 
peer connected and disconnected events can come in any order.

onPeerDisconnected的手册：

Wearable.NodeApi.getConnectedNodes(mGoogleApiClient).setResultCallback(new ResultCallback<NodeApi.GetConnectedNodesResult>() {
    @Override
    public void onResult(NodeApi.GetConnectedNodesResult getConnectedNodesResult) {
        Log.d(TAG, "Nodes: " + getConnectedNodesResult.getNodes());
    }
});

@Override
public void onPeerDisconnected(Node peer) {    
   // Which peer is this?
}

Notification that a peer has been disconnected from this node or is no 
longer reachable by this node.
Since multiple nodes can be connected to a network at the same time, 
peer connected and disconnected events can come in any order.

---

我怎么知道我的衣服在手机上断开了？而不是任何其他连接的设备？

一般来说，我们不喜欢用节点的形状因子“mobile/watch/…”来标记节点，而是提供一种方式，使每个节点都可以广播其“功能”，而其他节点可以查询连接设备的网络，以查看哪些节点提供了他们所需的“功能”。这是通过使用。我们在一些官方示例中使用了这些API，因此您可以看到它们的实际应用。例如，您的手机应用程序可以广播它支持“转录功能”，而您的wear应用程序可以找到提供该功能的节点，以决定将语音流发送到何处进行转录。这提供了一个灵活且可扩展的框架，当生态系统增长时，该框架将继续发挥作用。

一般来说，我们不希望将节点的形状因素标记为“mobile/watch/…”，而是提供一种方式，使每个节点都可以广播其“功能”其他节点可以查询连接设备的网络，以查看哪些节点提供了它们所需的“能力”。这是通过使用。我们在一些官方示例中使用了这些API，因此您可以看到它们的实际应用。例如，您的手机应用程序可以广播它支持“转录功能”，而您的wear应用程序可以找到提供该功能的节点，以决定将语音流发送到何处进行转录。这提供了一个灵活且可扩展的框架，当生态系统增长时，该框架将继续工作。

阿里所说的非常正确，但如果你真的需要设备的节点，也有一个API。

阿里所说的非常正确，但如果你真的需要设备的节点，这方面也有一个API。

以下各节将向您展示如何公布可以处理活动请求的设备节点，发现能够满足请求的节点，并向这些节点发送消息

广告功能

要从可穿戴设备在手持设备上启动活动，请使用MessageApi类发送请求。由于多个可穿戴设备可以连接到手持设备，可穿戴应用程序需要确定连接的节点能够启动活动。在您的手持应用程序中，宣传其运行的节点提供特定功能

要宣传您的手持应用程序的功能，请执行以下操作：

在项目的res/values/目录中创建一个XML配置文件，并将其命名为wear.XML。 将名为android_wear_capabilities的资源添加到wear.xml。 定义设备提供的功能

<resources>
    <string-array name="android_wear_capabilities">
        <item>android_wear</item>
    </string-array> 
</resources>

安卓鞋

检索具有所需功能的节点

最初，您可以通过调用CapabilityApi.getCapability（）方法来检测有能力的节点。下面的示例显示了如何使用android_wear功能手动检索可访问节点的结果。在磨损模块中使用以下代码：

public abstract class BaseActivity extends Activity implements MessageApi.MessageListener, NodeApi.NodeListener,
    DataApi.DataListener, GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener {

private static final String
        SMART_WEAR_CAPABILITY_NAME = "android_wear";

protected GoogleApiClient mGoogleApiClient;
protected ArrayList<String> results;
private String TAG = "BaseActivity::Wear";

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mGoogleApiClient = new GoogleApiClient.Builder(this)
            .addApi(Wearable.API)
            .addConnectionCallbacks(this)
            .addOnConnectionFailedListener(this)
            .build();
}

private Collection<String> getNodes() {
    results = new ArrayList<>();
    NodeApi.GetConnectedNodesResult nodes =
            Wearable.NodeApi.getConnectedNodes(mGoogleApiClient).await();

    for (Node node : nodes.getNodes()) {
        Log.d(TAG, node.getId());
        results.add(node.getId());
    }

    return results;
}

@Override
protected void onResume() {
    super.onResume();
    mGoogleApiClient.connect();
}

@Override
protected void onPause() {
    super.onPause();
    Wearable.MessageApi.removeListener(mGoogleApiClient, this);
    Wearable.NodeApi.removeListener(mGoogleApiClient, this);
    Wearable.DataApi.removeListener(mGoogleApiClient, this);
    mGoogleApiClient.disconnect();
}

@Override
public void onConnected(Bundle bundle) {
    Log.d(TAG, "onConnected(): Successfully connected to Google API client");
    Wearable.MessageApi.addListener(mGoogleApiClient, this);
    Wearable.DataApi.addListener(mGoogleApiClient, this);
    Wearable.NodeApi.addListener(mGoogleApiClient, this);
    results = new ArrayList<>();

    getNodeIdOfHandheldDevice();
}

@Override
public void onConnectionSuspended(int i) {
    Log.d(TAG, "onConnectionSuspended(): Connection to Google API client was suspended");
}

@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
    Log.e(TAG, "onConnectionFailed(): Failed to connect, with result: " + connectionResult);
}

@Override
public void onPeerConnected(Node node) {
    Log.e(TAG, "onPeerConnected():");
}

@Override
public void onPeerDisconnected(Node node) {
    Log.e(TAG, "onPeerDisconnected():");
}

private void getNodeIdOfHandheldDevice() {
    Wearable.CapabilityApi.getCapability(
            mGoogleApiClient, SMART_WEAR_CAPABILITY_NAME,
            CapabilityApi.FILTER_REACHABLE).setResultCallback(
            new ResultCallback<CapabilityApi.GetCapabilityResult>() {
                @Override
                public void onResult(CapabilityApi.GetCapabilityResult result) {
                    if (result.getStatus().isSuccess()) {
                        updateFindMeCapability(result.getCapability());
                    } else {
                        Log.e(TAG,
                                "setOrUpdateNotification() Failed to get capabilities, "
                                        + "status: "
                                        + result.getStatus().getStatusMessage());
                    }
                }
            });
}

private void updateFindMeCapability(CapabilityInfo capabilityInfo) {
    Set<Node> connectedNodes = capabilityInfo.getNodes();
    if (connectedNodes.isEmpty()) {
        results.clear();
    } else {
        for (Node node : connectedNodes) {
            // we are only considering those nodes that are directly connected
            if (node.isNearby()) {
                results.add(node.getId());
            }
        }
    }
}

}

公共抽象类BaseActivity扩展活动实现MessageApi.MessageListener、NodeApi.NodeListener、，
DataApi.DataListener、GoogleAppClient.ConnectionCallbacks、GoogleAppClient.OnConnectionFailedListener{
私有静态最终字符串
智能穿戴功能\u NAME=“安卓穿戴”；
受保护的GoogleapClient MGoogleapClient；
受保护的ArrayList结果；
私有字符串TAG=“BaseActivity:：Wear”；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
mgoogleapclient=新的Googleapclient.Builder（此）
.addApi（可穿戴的.API）
.addConnectionCallbacks（此）
.addOnConnectionFailedListener（此）
.build（）；
}
私有集合getNodes（）{
结果=新的ArrayList（）；
NodeApi.GetConnectedNodeResult节点=
Wearable.NodeApi.getConnectedNodes（mgoogleapClient.wait（）；
对于（节点：nodes.getNodes（））{
Log.d（标记，node.getId（））；
add（node.getId（））；
}
返回结果；
}
@凌驾
受保护的void onResume（）{
super.onResume（）；
mGoogleApiClient.connect（）；
}
@凌驾
受保护的void onPause（）{
super.onPause（）；
Wearable.MessageApi.removeListener（mGoogleApiClient，this）；
可穿戴.NodeApi.removeListener（mGoogleApiClient，this）；
可穿戴.DataApi.removeListener（mGoogleApiClient，this）；
mGoogleApiClient.disconnect（）；
}
@凌驾
未连接的公共空间（捆绑包）{
d（标记“onConnected（）：成功连接到GoogleAPI客户端”）；
Wearable.MessageApi.addListener（mgoogleapClient，this）；
Wearable.DataApi.addListener（mGoogleApiClient，this）；
可穿戴.NodeApi.addListener（mGoogleApiClient，this）；
结果=新的ArrayList（）；
getNodeIdOfHandheldDevice（）；
}
@凌驾
公共空间连接暂停（int i）{
d（标记“onConnectionSuspended（）：与Google API客户端的连接已暂停”）；
}
@凌驾
公共无效onConnectionFailed（ConnectionResult ConnectionResult）{
Log.e（标记“onConnectionFailed（）：连接失败，结果为：“+connectionResult”）；
}
@凌驾
公共void onPeerConnected（节点）{
Log.e（标记“onPeerConnected（）：”）；
}
@凌驾
已连接对等节点上的公共无效（节点）{
Log.e（标记“onPeerDisconnected（）：”）；
}
私有void getNodeIdOfHandheldDevice（）{
Wearable.CapabilityApi.getCapability(
mGoogleApiClient，智能穿戴功能名称，
CapabilityApi.FILTER_可达）。setResultCallback(
新的ResultCallback（）{
@凌驾
public void onResult（CapabilityApi.GetCapabilityResult结果）{
if（result.getStatus（）.issucess（））{
updateFindMeCapability（result.getCapability（））；