alljoynframework-Java-Signals。总线\无\此类\接口

这是一个非常具体的问题，但是在同一个地方呆了几天，在Alljoyn论坛上没有得到任何回应之后，我决定把它贴在这里。也许有人使用过这个框架

我正在做一个项目，我需要使用Alljoyn框架提供的信号机制。但是，我确实需要会话中的信号，api核心中提供的示例是无会话的

在我的例子中，我需要服务（服务器）发出信号，客户端接收信号，但我得到了这个错误。根据api示例，我创建了一个简单的应用程序，通过接口中定义的方法交换消息，因此我知道通信正在工作。在这种情况下，服务将等待客户端连接并发送信号。客户端加入会话，并在注册信号后立即收到总线\u NO \u这样的\u接口错误。我也试着在发送信号前后注册，同样的问题。我认为由于某种原因，客户没有找到总线信号处理器，但我不知道为什么。我还把它放在一个外部类中，但它不起作用

我遵循《核心api指南》中的示例：

这是服务注册并发出信号的部分：

SignalEmitter emitter = new SignalEmitter(mySignalInterface, joinerName, 
   sessionId,
SignalEmitter.GlobalBroadcast.Off);
myInterface = emitter.getInterface(SampleInterface.class);
// Emitting signals myInterface.buttonClicked(1); 
myInterface.playerPosition(12, 1, -24);

然而，在那个例子中，我看不到

myInterface

的定义。我知道这不是一个错误，他们的意思是

mySignalInterface

，因为方法

getInterface

要求一个接口对象，而

mySignalInterface

是一个实现该接口的类

我把我创建的示例放在这里，我将上传这些文件，以防有人想尝试

@BusInterface(name = "org.alljoyn.bus.samples.simple.SimpleInterface")
public interface SimpleInterface {

    @BusMethod
    String Ping(String inStr) throws BusException;

    @BusSignal
    public void playerPosition(int x, int y, int z) throws BusException;
}

服务：

类来实现信号和方法

class SimpleService implements SimpleInterface, BusObject {

    public String Ping(String inStr) {
    mHandler.sendMessage(mHandler.obtainMessage(MESSAGE_PING, inStr));
        return inStr;
    }

    public void playerPosition(int x, int y, int z) { /* no implementation needed here*/}

}

以下是在服务中建立连接的部分代码：

case CONNECT: {
    org.alljoyn.bus.alljoyn.DaemonInit.PrepareDaemon(getApplicationContext());

    mBus = new BusAttachment(getPackageName(), BusAttachment.RemoteMessage.Receive);

    mBus.registerBusListener(new BusListener());

    Status status = mBus.registerBusObject(mSimpleService, "/SimpleService");
    if (status != Status.OK) {...}

    status = mBus.connect();
    logStatus("BusAttachment.connect()", status);
    if (status != Status.OK) {...}

    int flag = 0;

    status = mBus.requestName(SERVICE_NAME, flag);
    logStatus(String.format("BusAttachment.requestName(%s, 0x%08x)", SERVICE_NAME, flag), status);
    if (status == Status.OK) {
        status = mBus.advertiseName(SERVICE_NAME, SessionOpts.TRANSPORT_ANY);
        logStatus(String.format("BusAttachement.advertiseName(%s)", SERVICE_NAME), status);
        if (status != Status.OK) {...}
    }

    Mutable.ShortValue contactPort = new Mutable.ShortValue(CONTACT_PORT);

    SessionOpts sessionOpts = new SessionOpts();
    sessionOpts.traffic = SessionOpts.TRAFFIC_MESSAGES;
    sessionOpts.isMultipoint = false;
    sessionOpts.proximity = SessionOpts.PROXIMITY_ANY;

    sessionOpts.transports = SessionOpts.TRANSPORT_ANY + SessionOpts.TRANSPORT_WFD;

    status = mBus.bindSessionPort(contactPort, sessionOpts, new SessionPortListener() {
        @Override
        public boolean acceptSessionJoiner(short sessionPort, String joiner, SessionOpts sessionOpts) {
        return sessionPort == CONTACT_PORT;
        }

        @Override
        public void sessionJoined(short port, int id, String s) {
        sessionId = id; joinerName = s; sessionEstablished = true;
        }
    });
    logStatus(String.format("BusAttachment.bindSessionPort(%d, %s)",
                        contactPort.value, sessionOpts.toString()), status);
    if (status != Status.OK) {...}

    try {
        while (!sessionEstablished) {
        Thread.sleep(10);
        }

        SignalEmitter emitter = new SignalEmitter(mSimpleService, joinerName, sessionId, SignalEmitter.GlobalBroadcast.Off);
        SimpleInterface myInterface = emitter.getInterface(SimpleInterface.class);
        myInterface.playerPosition(12,1,1);
    }
    catch (BusException ex) {...  }
}

客户：

/*On create of the activity which has a button and a text view to send text to the server */
mEditText.setOnEditorActionListener(new TextView.OnEditorActionListener() {
public boolean onEditorAction(TextView view, int actionId, KeyEvent event) {
    if (actionId == EditorInfo.IME_NULL
            && event.getAction() == KeyEvent.ACTION_UP) {
        /* Call the remote object's Ping method. */
        Message msg = mBusHandler.obtainMessage(BusHandler.PING,
                                                view.getText().toString());
        mBusHandler.sendMessage(msg);
    }
    return true;
}
});

private static final String SERVICE_NAME = "org.alljoyn.bus.samples.simple";
private static final short CONTACT_PORT=42;

private BusAttachment mBus;
private ProxyBusObject mProxyObj;
private SimpleInterface mSimpleInterface;


case CONNECT: {
    org.alljoyn.bus.alljoyn.DaemonInit.PrepareDaemon(getApplicationContext());

    mBus = new BusAttachment(getPackageName(), BusAttachment.RemoteMessage.Receive);


    mBus.registerBusListener(new BusListener() {
    @Override
    public void foundAdvertisedName(String name, short transport, String namePrefix) {

        if(!mIsConnected) {
        Message msg = obtainMessage(JOIN_SESSION);
        msg.arg1 = transport;
        msg.obj = name;
        sendMessage(msg);
        }
    }
    });


    Status status = mBus.connect();
    logStatus("BusAttachment.connect()", status);
    if (Status.OK != status) {...}


    status = mBus.findAdvertisedName(SERVICE_NAME);
    logStatus(String.format("BusAttachement.findAdvertisedName(%s)", SERVICE_NAME), status);
    if (Status.OK != status) {...}

    break;
}
case (JOIN_SESSION): {

    if (mIsStoppingDiscovery) {
        break;
    }

    short contactPort = CONTACT_PORT;
    SessionOpts sessionOpts = new SessionOpts();
    sessionOpts.transports = (short)msg.arg1;
    Mutable.IntegerValue sessionId = new Mutable.IntegerValue();

    Status status = mBus.joinSession((String) msg.obj, contactPort, sessionId, sessionOpts, new SessionListener() {
    @Override
    public void sessionLost(int sessionId, int reason) {
        mIsConnected = false;
        logInfo(String.format("MyBusListener.sessionLost(sessionId = %d, reason = %d)", sessionId,reason));
        mHandler.sendEmptyMessage(MESSAGE_START_PROGRESS_DIALOG);
    }
    });


    if (status == Status.OK) {

        mProxyObj =  mBus.getProxyBusObject(SERVICE_NAME,
               "/SimpleService",
               sessionId.value,
               new Class<?>[] { SimpleInterface.class });


        mSimpleInterface =  mProxyObj.getInterface(SimpleInterface.class);

        mSessionId = sessionId.value;
        mIsConnected = true;
        mHandler.sendEmptyMessage(MESSAGE_STOP_PROGRESS_DIALOG);
    }
    break;
    status = mBus.registerSignalHandlers(this);
    if (status != Status.OK) {...}
}
case PING: {
    try {
    if (mSimpleInterface != null) {

        sendUiMessage(MESSAGE_PING, msg.obj);
        String reply = mSimpleInterface.Ping((String) msg.obj);
        sendUiMessage(MESSAGE_PING_REPLY, reply);
    } catch {...}
}
...here some more code...
@BusSignalHandler(iface="org.alljoyn.bus.samples.simple.SimpleInterface", signal="playerPosition")
public void playerPosition(int x, int y, int z) {
sendUiMessage(MESSAGE_POST_TOAST, "Signal captured");
}

/*创建具有按钮和文本视图以向服务器发送文本的活动时*/
mEditText.setOnEditorActionListener（新的TextView.OnEditorActionListener（）{
公共布尔onEditorAction（TextView视图、int actionId、KeyEvent事件）{
如果（actionId==EditorInfo.IME\u NULL
&&event.getAction（）==KeyEvent.ACTION\u UP）{
/*调用远程对象的Ping方法*/
Message msg=mBusHandler.actainmessage（BusHandler.PING，
view.getText（）.toString（））；
mBusHandler.sendMessage（msg）；
}
返回true；
}
});
私有静态最终字符串服务\u NAME=“org.alljoyn.bus.samples.simple”；
专用静态最终短触点_端口=42；
私人巴士公司；
私有ProxyBusObject mProxyObj；
私有SimpleInterface mSimpleInterface；
案例连接：{
org.alljoyn.bus.alljoyn.daemonit.preparedeamon（getApplicationContext（））；
mBus=新的总线附件（getPackageName（），BusAttachment.RemoteMessage.Receive）；
mBus.registerBusListener（新的BusListener（）{
@凌驾
public void foundAdvertisedName（字符串名称、短传输、字符串名称前缀）{
如果（！连接错误）{
Message msg=获取消息（加入会话）；
msg.arg1=运输；
msg.obj=名称；
发送消息（msg）；
}
}
});
Status Status=mBus.connect（）；
logStatus（“总线连接.连接（）”，状态）；
如果（Status.OK！=Status）{…}
状态=mBus.FindAvertisedName（服务名称）；
日志状态（String.format（“BusAttachement.findAdvertisedName（%s）”，服务名称），状态）；
如果（Status.OK！=Status）{…}
打破
}
案例（参加会议）：{
if（mIsStoppingDiscovery）{
打破
}
短触点端口=触点端口；
SessionOpts SessionOpts=新SessionOpts（）；
sessionOpts.transports=（短）msg.arg1；
Mutable.IntegerValue sessionId=新的Mutable.IntegerValue（）；
Status Status=mBus.joinSession（（字符串）msg.obj，contactPort，sessionId，sessionOpts，new SessionListener（）{
@凌驾
public void sessionLost（int sessionId，int reason）{
错误连接=错误；
logInfo（String.format（“MyBusListener.sessionLost（sessionId=%d，reason=%d）”，sessionId，reason））；
mHandler.sendEmptyMessage（消息启动进度对话框）；
}
});
if（status==status.OK）{
mProxyObj=mBus.getProxyBusObject（服务名称，
“/SimpleService”，
sessionId.value，
新类[]{SimpleInterface.Class}）；
mSimpleInterface=mProxyObj.getInterface（SimpleInterface.class）；
mSessionId=sessionId.value；
错误连接=正确；
mHandler.sendEmptyMessage（消息\u停止\u进度\u对话框）；
}
打破
状态=mBus.RegisterSignalHandler（此）；
如果（status！=status.OK）{…}
}
案例平：{
试一试{
if（mSimpleInterface！=null）{
sendUiMessage（MESSAGE_PING，msg.obj）；
字符串reply=mSimpleInterface.Ping（（字符串）msg.obj）；
sendUiMessage（MESSAGE\u PING\u REPLY，REPLY）；
}捕获{…}
}
…这里有更多的代码。。。
@BusSignalHandler（iface=“org.alljoyn.bus.samples.simple.SimpleInterface”，signal=“playerPosition”）
公共无效播放位置（整数x、整数y、整数z）{
sendUiMessage（MESSAGE_POST_TOAST，“信号捕获”）；
}

在本例中，我有一个客户端，它有一个textview，我可以在其中添加文本并向服务器发送ping。如果我去掉注册信号部分，这是可行的。我尝试使用Thread.sleep按照api核心所说的那样做，但也不起作用

在这里，我根据AlljoynAPI中的示例添加了两个应用程序（客户端和服务器）的代码。

请让我知道，如果你有一些疑问，这是很难把所有的信息在一个帖子。

---

提前谢谢。

当您调用

RegisterSignalHandler

时，必须传递一个实现接口

SimpleInterface

的对象，并且当您收到信号时，将在该对象中调用方法

playerPosition

private static final String SERVICE_NAME = "org.alljoyn.bus.samples.simple";

 @BusSignalHandler(iface = "org.sample.MyInterface", signal = "MySignal")
 public void handleSignal(String str)
 {
 }

 @BusSignalHandler(iface = "org.myapp.IMyInterface", signal = "EmitMySignal")
 public void handleSignal(String str)
 {
 }

@BusSignalHandler(iface="org.alljoyn.bus.samples.simple.SimpleInterface", signal="playerPosition")

@BusSignalHandler(iface="org.alljoyn.bus.samples.simpleclient.SimpleInterface", signal="playerPosition")