c# - Android wear Xamarin 消息

Question

我想从 Android Wear 设备向连接的手机发送消息。Android 智能手机应用程序是用 native 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);
    }
}

问题是手机没有收到消息。

Answer 1

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

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

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

沟通者

Communicator类派生自 Java.Lang.Object并实现两个监听器接口(interface)。

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

它包含一个 IGoogleApiClient

    readonly IGoogleApiClient client;

并存储一个公共(public)路径:

    const string path = "/communicator";

(这两个 API，消息 API 和数据 API，都需要一个“路径”作为一种通信 channel 标识符。对所有消息使用相同的路径是第一次尝试，但在增加流量时可能会产生噪音更复杂的应用程序。)

Communicator使用 Android Context 构建并构建 IGoogleApiClient .

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

以下方法将在恢复或暂停 Activity 时调用。他们连接或断开 client并注册或取消注册 Communicator作为消息/数据监听器:

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

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

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

当然，我们需要接收数据的方法。它们实际上是由上面的两个接口(interface)定义的，需要得到实现。 (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”生成包含秒数的“长时间”字符串。这样，在大多数情况下，字符串会从一次点击变为另一次点击。这很重要，因为发送相同的数据映射 两次不会触发 OnDataChanged 事件处理程序!)

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

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

        communicator.Resume();
    }

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

        base.OnPause();
    }

list

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

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

结果

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

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

请注意，某些数据映射的发送者也会收到它。所以时间上dataButton在两个设备上都是一样的。相反，消息只发送给所有其他节点，因此不会返回给发送者。