DBus und Java

[Bastian]

Hallo Forum,

ich versuche mich seit einiger Zeit damit, DBus innerhalb einer Java-Anwendung nutzen zu können. Innerhalb eines gewissen Rahmens funktioniert das auch. Ich habe es geschafft mir eine Instanz von org.freesmartphone.Phone zu holen. Ich hatte es auch schon geschafft, die Protokolle zu initialiseren und mir deren Namen zurückgeben zu lassen (das klappt aber nun jetzt auch nicht mehr.). Mein Problem ist, dass meine DBus-Verbindung ständig getrennt wird. Kann mir jemand sagen, woran das liegen könnte? Als Meldung kommt leider nur:

Code: Alles auswählen

[.()] Closing socket


[BikeAtor]

Poste mal etwas Sourcecode. evtl. finde ich was.

[Bastian]

Das ist nicht ganz einfach aber ich versuchs mal.

Ich habe die Klassen für DBus von https://evolvis.org/plugins/scmsvn/viewcvs.php?rev=524&root=jalimo&sortdir=down&view=rev genommen. Leider scheinen die Klassen nicht ganz zu stimmen, da ich ein paar DBus-Pfade anpassen musste.

Mein eigentlichern Quelltext sieht folgendermaßen aus: Klasse CallTest

Code: Alles auswählen

package test;

import org.freedesktop.dbus.exceptions.DBusException;
import org.freesmartphone.Phone;
import org.freesmartphone.PhoneKit;
import org.freesmartphone.phone.Call;

public class CallTest {

   /**
    * @param args
    * @throws Exception
    */
   public static void main(String[] args) throws Exception {
      try {
         System.out.println("Test 1");
         PhoneKit kit = new PhoneKit();
         System.out.println("Test 2");
         Phone phone = kit.getPhoneInstance();
//         kit.reconnect();
         System.out.println("Test 3");
         System.out.println("protocols: ");
         String[] protocolls = phone.InitProtocols();
         for (String proto : protocolls) {
            System.out.println("   " + proto);
         }
         System.out.println("Test 4");
         kit.close();
//         Call call = phone.CreateCall("eineNummer", "GSM", false); //eineNummer ist natürlich eine richtige Nummer gewesen 
//         System.out.println("call state: " + call.GetStatus());
//         System.out.println("call state: " + call.Initiate());
      } catch (Exception e) {
         System.err.println("Exception: " + e.getMessage());
         e.printStackTrace();
      }
   }
}


Meine Ausgabe ist:

Code: Alles auswählen

Test 1
Test 2
Test Phone1
Test Phone2
Test 3
protocols:
[.()] Closing socket
[.()] Closing socket
Exception: No reply within specified time
org.freedesktop.DBus$Error$NoReply: No reply within specified time
   at org.freedesktop.dbus.RemoteInvocationHandler.executeRemoteMethod(RemoteInvocationHandler.java:134)
   at org.freedesktop.dbus.RemoteInvocationHandler.invoke(RemoteInvocationHandler.java:189)
   at $Proxy1.InitProtocols(Unknown Source)
   at org.freesmartphone.impl.PhoneImpl.InitProtocols(PhoneImpl.java:32)
   at test.CallTest.main(CallTest.java:23)


DIe Klassen aus dem Framework:

PhoneKit:

Code: Alles auswählen

package org.freesmartphone;


import org.freedesktop.dbus.DBusConnection;
import org.freedesktop.dbus.DBusInterfaceName;
import org.freedesktop.dbus.DBusSignal;
import org.freedesktop.dbus.DBusInterface;
import org.freedesktop.dbus.exceptions.DBusException;


public class PhoneKit {

    //private String serviceToConnect = "org.freedesktop.Gypsy";
   private String serviceToConnect = "org.freesmartphone.ophoned";
   
    private DBusConnection connection;

    private org.freesmartphone.Phone phoneInstance;
    private org.freesmartphone.phone.Call callInstance;
    private org.freesmartphone.device.Input inputInstance;

    public PhoneKit() throws DBusException {
        connection = DBusConnection.getConnection(DBusConnection.SYSTEM);
    }
   
    public void reconnect() throws DBusException {
         connection = DBusConnection.getConnection(DBusConnection.SYSTEM);
    }

    public PhoneKit(String serviceToConnect) throws DBusException {
        connection = DBusConnection.getConnection(DBusConnection.SYSTEM);
        this.serviceToConnect = serviceToConnect;
    }

    public void close() {
        connection.disconnect();
    }

    public org.freesmartphone.Phone getPhoneInstance() throws Exception {
        if (phoneInstance == null)
            phoneInstance = new org.freesmartphone.impl.PhoneImpl(connection, serviceToConnect, "/org/freesmartphone/Phone");
        return phoneInstance;
    }

    public org.freesmartphone.phone.Call getCallInstance() throws Exception {
        if (callInstance == null)
//           callInstance = new org.freesmartphone.impl.phone.CallImpl(connection, serviceToConnect, "/org/freesmartphone/Phone/Call");
        callInstance = new org.freesmartphone.impl.phone.CallImpl(connection, serviceToConnect, "/org/freesmartphone/Phone/GSM/0");
       
        return callInstance;
    }

    public org.freesmartphone.device.Input getInputInstance() throws Exception {
        if (inputInstance == null)
            inputInstance = new org.freesmartphone.impl.device.InputImpl(connection, "org.freesmartphone.odeviced", "/org/freesmartphone/Device/Input");
        return inputInstance;
    }

}


PhoneImpl:

Code: Alles auswählen

package org.freesmartphone.impl;

import java.util.LinkedList;
import org.freedesktop.dbus.DBusInterface;
import org.freedesktop.dbus.DBusInterfaceName;
import org.freedesktop.dbus.DBusSignal;
import org.freedesktop.dbus.DBusSignalHelper;
import org.freedesktop.dbus.DBusConnection;
import org.freedesktop.dbus.exceptions.DBusException;
import org.freedesktop.dbus.DBusSigHandler;
@DBusInterfaceName("org.freesmartphone.Phone")
public class PhoneImpl implements org.freesmartphone.Phone, DBusSigHandler {

   private Phone phone;
   private DBusConnection conn;
   private String serviceToConnect;
   private LinkedList<org.freesmartphone.PhoneListener> listener = new LinkedList<org.freesmartphone.PhoneListener>();

   public PhoneImpl(DBusConnection conn, String serviceToConnect,
         String objectPath) throws DBusException {
      this.conn = conn;
      this.serviceToConnect = serviceToConnect;
      phone = conn.getRemoteObject(serviceToConnect, objectPath, Phone.class);
      System.out.println("Test Phone1");
//      DBusSignalHelper.addInterfaceMap("org.freesmartphone.impl.Phone",
//            "org.freesmartphone.Phone");
      System.out.println("Test Phone2");
      //conn.addSigHandler(org.freesmartphone.impl.Phone.Incoming.class, this);
   }

   public String[] InitProtocols() throws Exception {
      return phone.InitProtocols();
   }

   public org.freesmartphone.phone.Call CreateCall(String number,
         String protocol, boolean force) throws Exception {
      org.freedesktop.dbus.Path path = phone.CreateCall(number, protocol,
            force);
      return new org.freesmartphone.impl.phone.CallImpl(conn,
            serviceToConnect, path.getPath());
   }

   public void addPhoneListener(org.freesmartphone.PhoneListener newListener) {
      listener.add(newListener);
   }

   public void removePhoneListener(
         org.freesmartphone.PhoneListener removeListener) {
      listener.remove(removeListener);
   }

   public void handle(DBusSignal s) {
      if (s instanceof Phone.Incoming) {
         firePhoneIncoming((Phone.Incoming) s);
      }
   }

   private void firePhoneIncoming(Phone.Incoming state) {
      for (org.freesmartphone.PhoneListener l : listener)
         l.PhoneIncoming(state.call);

   }

   public boolean isRemote() {
      return false;
   }
}


CallImpl:

Code: Alles auswählen

package org.freesmartphone.impl.phone;


import java.util.LinkedList;
import org.freedesktop.dbus.DBusInterface;
import org.freedesktop.dbus.DBusSignal;
import org.freedesktop.dbus.DBusSignalHelper;
import org.freedesktop.dbus.DBusConnection;
import org.freedesktop.dbus.exceptions.DBusException;
import org.freedesktop.dbus.DBusSigHandler;


public class CallImpl implements org.freesmartphone.phone.Call, DBusSigHandler {

    private Call call;
    private DBusConnection conn;
    private String serviceToConnect;
    private LinkedList<org.freesmartphone.phone.CallListener> listener = new LinkedList<org.freesmartphone.phone.CallListener>();

    public CallImpl(DBusConnection conn, String serviceToConnect, String objectPath) throws DBusException {
        this.conn = conn;
        this.serviceToConnect = serviceToConnect;
        call = conn.getRemoteObject(serviceToConnect, objectPath, Call.class);

        DBusSignalHelper.addInterfaceMap("org.freesmartphone.impl.phone.Call", "org.freesmartphone.Phone.Call");
        conn.addSigHandler(org.freesmartphone.impl.phone.Call.Outgoing.class, this);
        DBusSignalHelper.addInterfaceMap("org.freesmartphone.impl.phone.Call", "org.freesmartphone.Phone.Call");
        conn.addSigHandler(org.freesmartphone.impl.phone.Call.Released.class, this);
        DBusSignalHelper.addInterfaceMap("org.freesmartphone.impl.phone.Call", "org.freesmartphone.Phone.Call");
        conn.addSigHandler(org.freesmartphone.impl.phone.Call.Activated.class, this);
    }

    public String GetPeer() throws Exception {
        return call.GetPeer();
    }

    public String Initiate() throws Exception {
        return call.Initiate();
    }

    public String Activate() throws Exception {
        return call.Activate();
    }

    public String Release() throws Exception {
        return call.Release();
    }

    public String GetStatus() throws Exception {
        return call.GetStatus();
    }

    public void Remove() throws Exception {
        call.Remove();
    }

    public void addCallListener(org.freesmartphone.phone.CallListener newListener) {
        listener.add(newListener);
    }

    public void removeCallListener(org.freesmartphone.phone.CallListener removeListener) {
        listener.remove(removeListener);
    }

    public void handle(DBusSignal s) {
        if (s instanceof Call.Outgoing) {
            fireCallOutgoing((Call.Outgoing) s);
        }
        if (s instanceof Call.Released) {
            fireCallReleased((Call.Released) s);
        }
        if (s instanceof Call.Activated) {
            fireCallActivated((Call.Activated) s);
        }
    }

    private void fireCallOutgoing(Call.Outgoing state) {
        for (org.freesmartphone.phone.CallListener l : listener)
            l.CallOutgoing();

    }

    private void fireCallReleased(Call.Released state) {
        for (org.freesmartphone.phone.CallListener l : listener)
            l.CallReleased();

    }

    private void fireCallActivated(Call.Activated state) {
        for (org.freesmartphone.phone.CallListener l : listener)
            l.CallActivated();

    }

    public boolean isRemote() {
        return false;    }}


InputImpl:

Code: Alles auswählen

package org.freesmartphone.impl.device;


import java.util.LinkedList;
import org.freedesktop.dbus.DBusInterface;
import org.freedesktop.dbus.DBusSignal;
import org.freedesktop.dbus.DBusSignalHelper;
import org.freedesktop.dbus.DBusConnection;
import org.freedesktop.dbus.exceptions.DBusException;
import org.freedesktop.dbus.DBusSigHandler;


public class InputImpl implements org.freesmartphone.device.Input, DBusSigHandler {

    private Input input;
    private DBusConnection conn;
    private String serviceToConnect;
    private LinkedList<org.freesmartphone.device.InputListener> listener = new LinkedList<org.freesmartphone.device.InputListener>();

    public InputImpl(DBusConnection conn, String serviceToConnect, String objectPath) throws DBusException {
        this.conn = conn;
        this.serviceToConnect = serviceToConnect;
        input = conn.getRemoteObject(serviceToConnect, objectPath, Input.class);

        DBusSignalHelper.addInterfaceMap("org.freesmartphone.impl.device.Input", "org.freesmartphone.Device.Input");
        conn.addSigHandler(org.freesmartphone.impl.device.Input.Event.class, this);
    }

    public void addInputListener(org.freesmartphone.device.InputListener newListener) {
        listener.add(newListener);
    }

    public void removeInputListener(org.freesmartphone.device.InputListener removeListener) {
        listener.remove(removeListener);
    }

    public void handle(DBusSignal s) {
        if (s instanceof Input.Event) {
            fireInputEvent((Input.Event) s);
        }
    }

    private void fireInputEvent(Input.Event state) {
        for (org.freesmartphone.device.InputListener l : listener)
            l.InputEvent(state.name, state.action, state.seconds);

    }

    public boolean isRemote() {
        return false;    }}


[JesusMcCloud]

waaaaaah wer hat den das mit den imports verbrochen?
...nicht dein code, der runtergeladene

[Bastian]

waaaaaah wer hat den das mit den imports verbrochen?
...nicht dein code, der runtergeladene

Ist wahrscheinlich automatisch generiert. Schlimmer ist, dass der Code nicht funktioniert. Direkt zu Anfang fand ich einige Strings für DBus, die nicht korrekt waren. Habe ein paar Stellen schonmal verbessert, aber richtig ist sicherlich noch nicht alles.

[JesusMcCloud]

hört sich so an, als hättest du schon eine vermutung wo der hund begraben liegt.
jalimo repo bietet dbus-java libmatthew und alles benötigte an. nur eben keine vorkompilierten fso bindings.
hab beim schnellen durchsehn (hab mir nit alles angesehn) keine binaries in den packages gefunden...selbst sollt ja auch snorre sein, da man das programm dann sowieso erst am moko testet.
ich denke mal man sollte vielleicht diese packages runterladen und über alien installiern. erspart einem vielleicht auch ärger.
und zu den imports: denk auch das das automatisch generiert wurde, aber dan hätte man doch zumindest auf die entsprechenden libs verlinken sollen.
grml... nervt mich das immer wenn man sich kram zusammensuchen und stoppeln muss. da hatte ich ja mit meinem letzten jni werk weniger (start-)probleme und der kram blieb trotzdem zwischen linux und wndows halbwegs portabel.

[Bastian]

Ok, ich weiß nicht, ob ich mich unklar ausgedrückt habe.

Der Teil da oben war meine erste Vermutung, dass es daran liegt. Sicherlich wird da auch etwas drinstecken. Aber die Verbindung zu jni liegt eigentlich in keiner der Klassen sonder in den Klassen libmatthew. Diese habe ich nicht aufgeführt gehabt. Da dort aber sicherlich ein Fehler ist werden ich nun gezwungen sein, selber jni zu benutzen und dbus über c anzusprechen. Da habe ich dann wenigstens Kontrolle drüber, wenn was in die Hose geht und kann mir selber ordentliche Debugnachrichten reinschreiben.

[Bastian]

Ich habe gerade gesehen, dass die libmatthew-Version im Jalimo Repo veraltet ist. Könnte mir die jemand zufällig compilieren? (http://www.matthew.ath.cx/projects/java ... 7.2.tar.gz)
Ich bekomme das irgendwie nicht gebacken. Wäre echt nett.

Gruß Bastian

[BikeAtor]

Hier Die gewünschte lib. Oder brauchst Du die Klassen?

[BikeAtor]

So, ich hab jetzt auch mal DBus und Java ausprobiert. Bei mir funktioniert folgender Code mit libmathew07.2 und dbus-java 2.6
Komischerweise funktiniert es nur, wenn ich auch das "Hello" schicke. Ansonsten kommt ein EOF. Wird wohl das Protokoll so vorschreiben.

Code: Alles auswählen

    BusAddress address = new BusAddress( "unix:path=/var/run/dbus/system_bus_socket" );
    Transport conn = new Transport( address );
    Message m = null;

    System.out.println( "Hello" );
    m = new MethodCall(
        "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "Hello", (byte) 0,
        null );
    ;
    conn.mout.writeMessage( m );
    System.out.println( conn.min.readMessage(  ) );

    System.out.println( "Display enabled" );
    m = new MethodCall(
        "org.freesmartphone.ousaged", "/org/freesmartphone/Usage", "org.freesmartphone.Usage",
        "SetResourcePolicy", (byte) 0, "ss", "Display", "enabled" );

    conn.mout.writeMessage( m );
    System.out.println( conn.min.readMessage(  ) );

    System.out.println( "CPU enabled" );
    m = new MethodCall(
        "org.freesmartphone.ousaged", "/org/freesmartphone/Usage", "org.freesmartphone.Usage",
        "SetResourcePolicy", (byte) 0, "ss", "CPU", "enabled" );

    conn.mout.writeMessage( m );
    System.out.println( conn.min.readMessage(  ) );

    System.out.println( "Display auto" );
    m = new MethodCall(
        "org.freesmartphone.ousaged", "/org/freesmartphone/Usage", "org.freesmartphone.Usage",
        "SetResourcePolicy", (byte) 0, "ss", "Display", "auto" );

    conn.mout.writeMessage( m );
    System.out.println( conn.min.readMessage(  ) );

    System.out.println( "CPU auto" );
    m = new MethodCall(
        "org.freesmartphone.ousaged", "/org/freesmartphone/Usage", "org.freesmartphone.Usage",
        "SetResourcePolicy", (byte) 0, "ss", "CPU", "auto" );

    conn.mout.writeMessage( m );
    System.out.println( conn.min.readMessage(  ) );

   conn.disconnect(  )


[Bastian]

Vielen Dank an euch beiden,
Mit den neuen libs funktioniert es nun auch bei mir. Werde dann mal fleissig interfaces für dbus schreiben und mal schauen dass ich was sinvolles schaffe