Android 佩戴 Xamarin 消息

Question

我想从 Android Wear 设备向连接的 Phone 发送消息。 Android Smartphone 应用程序是用本机 Java 编写的并且正在运行。 Wear-Application 是使用 Xamarin 用 c# 编写的，无法正常工作。这是我到目前为止得到的：

public class MainActivity : Activity, IMessageApiMessageListener,
     IGoogleApiClientConnectionCallbacks, IResultCallback
{
    private IGoogleApiClient mApiClient;
    private SensorManager _SensorManager;

    private Sensor _Gyroscop;
    private static  String WEAR_MESSAGE_PATH = "//message";
    protected override void OnCreate (Bundle bundle)
    {   
        base.OnCreate (bundle);
        // Set our view from the "main" layout resource
        SetContentView (Resource.Layout.Main);

        var v = FindViewById<WatchViewStub> (Resource.Id.watch_view_stub);
        v.LayoutInflated += delegate {
        };

        if(_SensorManager == null) {
            _SensorManager = (SensorManager)GetSystemService(SensorService);
        }

        SensorListener s = new SensorListener(); 
        _Gyroscop = _SensorManager.GetDefaultSensor (SensorType.Gyroscope);
        _SensorManager.RegisterListener (s, _Gyroscop,SensorDelay.Normal);
        s.SensorChangedEvent +=  delegate(SensorEvent e) {
            if(mApiClient.IsConnected ){
                sendMessage(WEAR_MESSAGE_PATH,"Test");
            }
        };
        initGoogleApiClient ();
    }

    private void initGoogleApiClient() {
    mApiClient = new GoogleApiClientBuilder( this )
                .AddApi( WearableClass.Api )
                .AddConnectionCallbacks( this )
                .Build();

    if (mApiClient != null && !(mApiClient.IsConnected || mApiClient.IsConnecting)) {
        mApiClient.Connect ();
        }
    }



    private void sendMessage(  String path,  String text ) {
        WearableClass.NodeApi
                     .GetConnectedNodes (mApiClient)
                     .SetResultCallback (this);
    }

    public void OnResult (Java.Lang.Object raw)
    {
        Exception nodeException, messageException;
        try {
            //send the message
            var nodeResult = raw.JavaCast<INodeApiGetConnectedNodesResult> ();
            foreach (var node in nodeResult.Nodes)
            WearableClass.MessageApi.SendMessage (mApiClient, node.Id, WEAR_MESSAGE_PATH, StringToByteArray("Test")).SetResultCallback (this); //will go to second try/catch block
            return;
        } catch (Exception e) {
            nodeException = e;
        }
        try {
            //check that it worked correctly
            var messageResult = raw.JavaCast<IMessageApiSendMessageResult> ();
            if (!messageResult.Status.IsSuccess)                    
                Console.WriteLine ("Problem");
            return;
        } catch (Exception e) {
            messageException = e;
        }
    }

    public void OnConnected (Bundle p0)
    {
        WearableClass.MessageApi.AddListener (mApiClient, this);
    }

    public void OnConnectionSuspended (int p0)
    {
        WearableClass.MessageApi.RemoveListener (mApiClient, this);
    }
}

问题是 phone 没有收到消息。

Answer 1

我终于完成了一个演示手持设备和穿戴设备之间通信的最小工作示例。它是纯 Xamarin 解决方案，允许双向发送消息和数据映射。

由于手持设备和可穿戴设备发送和接收信息的方式相同，因此我创建了一个名为 "Communication" 的共享项目。它包含一个 "Communicator" class，两个应用程序都使用它。

此外，在这个简单示例中，两个主要活动的 AXML 和 C# 实现是相同的。我们将在每个设备上看到两个按钮，允许发送新消息或一些数据。

沟通者

Communicator class 派生自 Java.Lang.Object 并实现了两个侦听器接口。

public class Communicator: Java.Lang.Object, IMessageApiMessageListener, IDataApiDataListener
{
    ...

它包含一个IGoogleApiClient

    readonly IGoogleApiClient client;

并存储公共路径：

    const string path = "/communicator";

(APIs，消息API和数据API，都需要一个"path"作为一种通信通道标识符。使用相同的路径所有消息都是第一次尝试，但在更复杂的应用程序中增加流量时可能会变得嘈杂。）

Communicator 是使用 Android Context 构建的，并构建了 IGoogleApiClient.

    public Communicator(Context context)
    {
        client = new GoogleApiClientBuilder(context)
            .AddApi(WearableClass.Api)
            .Build();
    }

恢复或暂停 activity 时将调用以下方法。他们连接或断开 client 并注册或取消注册 Communicator 作为 message/data 侦听器：

    public void Resume()
    {
        if (!client.IsConnected) {
            client.Connect();
            WearableClass.MessageApi.AddListener(client, this);
            WearableClass.DataApi.AddListener(client, this);
        }
    }

    public void Pause()
    {
        if (client != null && client.IsConnected) {
            client.Disconnect();
            WearableClass.MessageApi.RemoveListener(client, this);
            WearableClass.DataApi.RemoveListener(client, this);
        }
    }

发送信息有两种比较相似的方法，一种是消息，一种是数据图。为了避免阻塞 UI，这两个任务都在后台线程上执行。请注意，消息被发送到特定的 "nodes"（= 设备），而数据没有特定的接收者。

    public void SendMessage(string message)
    {
        Task.Run(() => {
            foreach (var node in Nodes()) {
                var bytes = Encoding.Default.GetBytes(message);
                var result = WearableClass.MessageApi.SendMessage(client, node.Id, path, bytes).Await();
                var success = result.JavaCast<IMessageApiSendMessageResult>().Status.IsSuccess ? "Ok." : "Failed!";
                Console.WriteLine(string.Format("Communicator: Sending message {0}... {1}", message, success));
            }
        });
    }

    public void SendData(DataMap dataMap)
    {
        Task.Run(() => {
            var request = PutDataMapRequest.Create(path);
            request.DataMap.PutAll(dataMap);
            var result = WearableClass.DataApi.PutDataItem(client, request.AsPutDataRequest()).Await();
            var success = result.JavaCast<IDataApiDataItemResult>().Status.IsSuccess ? "Ok." : "Failed!";
            Console.WriteLine(string.Format("Communicator: Sending data map {0}... {1}", dataMap, success));
        });
    }

当然，我们需要接收数据的方法。它们实际上是由上面的两个接口定义的，需要得到实现。（OnDataChanged 检查正确的路径，因为数据可能不专用于此应用程序。）

    public void OnMessageReceived(IMessageEvent messageEvent)
    {
        var message = Encoding.Default.GetString(messageEvent.GetData());
        Console.WriteLine(string.Format("Communicator: Message received \"{0}\"", message));
        MessageReceived(message);
    }

    public void OnDataChanged(DataEventBuffer p0)
    {
        Console.WriteLine(string.Format("Communicator: Data changed ({0} data events)", p0.Count));
        for (var i = 0; i < p0.Count; i++) {
            var dataEvent = p0.Get(i).JavaCast<IDataEvent>();
            if (dataEvent.Type == DataEvent.TypeChanged && dataEvent.DataItem.Uri.Path == path)
                DataReceived(DataMapItem.FromDataItem(dataEvent.DataItem).DataMap);
        }
    }

他们每个人都会调用以下事件之一。

    public event Action<string> MessageReceived = delegate {};

    public event Action<DataMap> DataReceived = delegate {};

最后但同样重要的是，我们需要一种方法来检索所有连接的节点：

    IList<INode> Nodes()
    {
        var result = WearableClass.NodeApi.GetConnectedNodes(client).Await();
        return result.JavaCast<INodeApiGetConnectedNodesResult>().Nodes;
    }

布局

为简单起见，两个应用程序使用相同的布局。它包含两个按钮，每个按钮占屏幕总大小的 50%。

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
    <Button
        android:id="@+id/messageButton"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_weight="1"
        android:text="Send message" />
    <Button
        android:id="@+id/dataButton"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_weight="1"
        android:text="Send data" />
</LinearLayout>

主要activity

这两个应用程序都实现了 MainActivity 派生自 Activity:

public class MainActivity : Activity
{
    ...

每个activity都有一个communicator封装了所有通信相关的代码。

    Communicator communicator;

在OnCreate的最后我们实例化了communicator,

        communicator = new Communicator(this);

并连接 messageButton

        var messageButton = FindViewById<Button>(Resource.Id.messageButton);
        messageButton.Click += (sender, e) => communicator.SendMessage("time: " + DateTime.Now.ToString("T"));
        communicator.MessageReceived += message => RunOnUiThread(() => messageButton.Text = message);

以及dataButton

        var dataButton = FindViewById<Button>(Resource.Id.dataButton);
        dataButton.Click += delegate {
            var dataMap = new DataMap();
            dataMap.PutString("time", DateTime.Now.ToString("T"));
            communicator.SendData(dataMap);
        };
        communicator.DataReceived += dataMap => RunOnUiThread(() => dataButton.Text = dataMap.ToString());

（我们使用格式标识符 "T" 生成包含秒数的 "long time" 字符串。这样在大多数情况下，字符串会从一次点击变为另一次点击。这很重要，因为发送相同的数据映射两次不触发OnDataChanged事件处理器！）

最后，我们Resume和Pause communicator在正确的地方：

    protected override void OnResume()
    {
        base.OnResume();

        communicator.Resume();
    }

    protected override void OnPause()
    {
        communicator.Pause();

        base.OnPause();
    }

清单

由于我们使用的是 Google 移动服务，因此我们需要将以下行放入两个 AndroidManifest.xml 文件的 <application> 标记中：

    <meta-data android:name="com.google.android.gms.version" android:value="@integer/google_play_services_version" />

结果

打开应用程序时，我们会看到以下屏幕。

点击几下后，两个应用程序都会通过消息 API 或数据 API 相互发送当前时间。现在屏幕如下所示。

请注意，某些数据地图的发送者也会收到它。因此，dataButton 上的时间在两个设备上是相同的。相反，一条消息只发送给所有 other 个节点，因此不会 return 发送给发送者。

Answer 2

我终于找到了我的bug，以及他们不沟通的原因。问题是两个应用程序有不同的包名称（您可以在 AndroidManifest.xml 中设置它们）。将它们设置为相同的名称后，通信就可以进行了。谢谢 Falko 的大力帮助 :) .

Android 佩戴 Xamarin 消息

Android wear Xamarin Messages

c#

android

xamarin

沟通者

布局

主要activity

清单

结果