org.freedesktop.dbus.AbstractConnection クラス

org.freedesktop.dbus.AbstractConnection の継承関係図

org.freedesktop.dbus.AbstractConnection 連携図

クラス
class	_globalhandler
class	_sender
class	_thread
class	_workerthread
class	FallbackContainer

公開メンバ関数
void	changeThreadCount (byte newcount)
void	setWeakReferences (boolean weakreferences)
void	exportObject (String objectpath, DBusInterface object) throws DBusException
void	addFallback (String objectprefix, DBusInterface object) throws DBusException
void	removeFallback (String objectprefix)
void	unExportObject (String objectpath)
void	sendSignal (DBusSignal signal)
void	disconnect ()
void	finalize ()
DBusExecutionException	getError ()
DBusAsyncReply	callMethodAsync (DBusInterface object, String m, Object... parameters)
BusAddress	getAddress () throws ParseException

静的公開メンバ関数
static DBusCallInfo	getCallInfo ()

静的公開変数類
static final boolean	EXCEPTION_DEBUG

限定公開メンバ関数
	AbstractConnection (String address) throws DBusException
void	listen ()
abstract< T extends DBusSignal > void	removeSigHandler (DBusMatchRule rule, DBusSigHandler< T > handler) throws DBusException
abstract< T extends DBusSignal > void	addSigHandler (DBusMatchRule rule, DBusSigHandler< T > handler) throws DBusException
void	sendMessage (Message m)

限定公開変数類
Map< String, ExportedObject >	exportedObjects
Map< DBusInterface, RemoteObject >	importedObjects
Map< SignalTuple, Vector< DBusSigHandler<? extends DBusSignal > > >	handledSignals
EfficientMap	pendingCalls
Map< MethodCall, CallbackHandler<? extends Object > >	pendingCallbacks
Map< MethodCall, DBusAsyncReply<? extends Object > >	pendingCallbackReplys
LinkedList< Runnable >	runnables
LinkedList< _workerthread >	workers
FallbackContainer	fallbackcontainer
boolean	_run
_thread	thread
_sender	sender
Transport	transport
String	addr
boolean	weakreferences = false
boolean	connected = false

静的限定公開変数類
static final int	TIMEOUT = 100000

関数
String	getExportedObject (DBusInterface i) throws DBusException
abstract DBusInterface	getExportedObject (String source, String path) throws DBusException
void	queueOutgoing (Message m)
public< T extends DBusSignal > void	removeSigHandler (Class< T > type, DBusSigHandler< T > handler) throws DBusException
public< T extends DBusSignal > void	removeSigHandler (Class< T > type, DBusInterface object, DBusSigHandler< T > handler) throws DBusException
public< T extends DBusSignal > void	addSigHandler (Class< T > type, DBusSigHandler< T > handler) throws DBusException
public< T extends DBusSignal > void	addSigHandler (Class< T > type, DBusInterface object, DBusSigHandler< T > handler) throws DBusException
protected< T extends DBusSignal > void	addSigHandlerWithoutMatch (Class<? extends DBusSignal > signal, DBusSigHandler< T > handler) throws DBusException
public< A > void	callWithCallback (DBusInterface object, String m, CallbackHandler< A > callback, Object... parameters)

静的関数
	[static initializer]

変数
EfficientQueue	outgoing
LinkedList< Error >	pendingErrors

静的変数
static final String	BUSNAME_REGEX = "^[-_a-zA-Z][-_a-zA-Z0-9]*(\\.[-_a-zA-Z][-_a-zA-Z0-9]*)*$"
static final String	CONNID_REGEX = "^:[0-9]*\\.[0-9]*$"
static final String	OBJECT_REGEX = "^/([-_a-zA-Z0-9]+(/[-_a-zA-Z0-9]+)*)?$"
static final byte	THREADCOUNT = 4
static final int	MAX_ARRAY_LENGTH = 67108864
static final int	MAX_NAME_LENGTH = 255
static final Pattern	dollar_pattern = Pattern.compile("[$]")
static final boolean	FLOAT_SUPPORT

非公開メンバ関数
void	addRunnable (Runnable r)
void	handleMessage (final MethodCall m) throws DBusException
void	handleMessage (final DBusSignal s)
void	handleMessage (final Error err)
void	handleMessage (final MethodReturn mr)
Message	readIncoming () throws DBusException

非公開変数類
ObjectTree	objectTree
_globalhandler	_globalhandlerreference

静的非公開変数類
static final int	PENDING_MAP_INITIAL_SIZE = 10
static final Map< Thread, DBusCallInfo >	infomap = new HashMap<Thread, DBusCallInfo>()

詳解

Handles a connection to DBus.

構築子と解体子

AbstractConnection()

org.freedesktop.dbus.AbstractConnection.AbstractConnection ( String  address ) throws DBusException

inlineprotected

                                                                      {
        exportedObjects = new HashMap<String, ExportedObject>();
        importedObjects = new HashMap<DBusInterface, RemoteObject>();
        _globalhandlerreference = new _globalhandler();
        synchronized (exportedObjects) {
            exportedObjects.put(null, new ExportedObject(_globalhandlerreference, weakreferences));
        }
        handledSignals = new HashMap<SignalTuple, Vector<DBusSigHandler<? extends DBusSignal>>>();
        pendingCalls = new EfficientMap(PENDING_MAP_INITIAL_SIZE);
        outgoing = new EfficientQueue(PENDING_MAP_INITIAL_SIZE);
        pendingCallbacks = new HashMap<MethodCall, CallbackHandler<? extends Object>>();
        pendingCallbackReplys = new HashMap<MethodCall, DBusAsyncReply<? extends Object>>();
        pendingErrors = new LinkedList<Error>();
        runnables = new LinkedList<Runnable>();
        workers = new LinkedList<_workerthread>();
        objectTree = new ObjectTree();
        fallbackcontainer = new FallbackContainer();
        synchronized (workers) {
            for (int i = 0; i < THREADCOUNT; i++) {
                _workerthread t = new _workerthread();
                t.start();
                workers.add(t);
            }
        }
        _run = true;
        addr = address;
    }

関数詳解

[static initializer]()

org.freedesktop.dbus.AbstractConnection.[static initializer] ( )

inlinestaticpackage

addFallback()

void org.freedesktop.dbus.AbstractConnection.addFallback ( String  objectprefix, DBusInterface  object  ) throws DBusException

inline

Export an object as a fallback object. This object will have it's methods invoked for all paths starting with this object path.

引数

objectprefix	The path below which the fallback handles calls. MUST be in slash-notation, like "/org/freedesktop/Local",
object	The object to export.

例外

DBusException

If the objectpath is incorrectly formatted,

                                                                                            {
        if (null == objectprefix || "".equals(objectprefix))
            throw new DBusException(getString("missingObjectPath"));
        if (!objectprefix.matches(OBJECT_REGEX) || objectprefix.length() > MAX_NAME_LENGTH)
            throw new DBusException(getString("invalidObjectPath") + objectprefix);
        ExportedObject eo = new ExportedObject(object, weakreferences);
        fallbackcontainer.add(objectprefix, eo);
    }

addRunnable()

void org.freedesktop.dbus.AbstractConnection.addRunnable ( Runnable  r )

inlineprivate

                                         {
        synchronized (runnables) {
            runnables.add(r);
            runnables.notifyAll();
        }
    }

addSigHandler() [1/3]

public<T extends DBusSignal> void org.freedesktop.dbus.AbstractConnection.addSigHandler ( Class< T >  type, DBusSigHandler< T >  handler  ) throws DBusException

inlinepackage

Add a Signal Handler. Adds a signal handler to call when a signal is received which matches the specified type and name.

引数

type	The signal to watch for.
handler	The handler to call when a signal is received.

例外

DBusException	If listening for the signal on the bus failed.
ClassCastException	If type is not a sub-type of DBusSignal.

                                                                                                                    {
        if (!DBusSignal.class.isAssignableFrom(type)) throw new ClassCastException(getString("notDBusSignal"));
        addSigHandler(new DBusMatchRule(type), (DBusSigHandler<? extends DBusSignal>) handler);
    }

addSigHandler() [2/3]

public<T extends DBusSignal> void org.freedesktop.dbus.AbstractConnection.addSigHandler ( Class< T >  type, DBusInterface  object, DBusSigHandler< T >  handler  ) throws DBusException

inlinepackage

Add a Signal Handler. Adds a signal handler to call when a signal is received which matches the specified type, name and object.

引数

type	The signal to watch for.
object	The object from which the signal will be emitted
handler	The handler to call when a signal is received.

例外

DBusException	If listening for the signal on the bus failed.
ClassCastException	If type is not a sub-type of DBusSignal.

                                                                                                                                          {
        if (!DBusSignal.class.isAssignableFrom(type)) throw new ClassCastException(getString("notDBusSignal"));
        String objectpath = importedObjects.get(object).objectpath;
        if (!objectpath.matches(OBJECT_REGEX) || objectpath.length() > MAX_NAME_LENGTH)
            throw new DBusException(getString("invalidObjectPath") + objectpath);
        addSigHandler(new DBusMatchRule(type, null, objectpath), (DBusSigHandler<? extends DBusSignal>) handler);
    }

addSigHandler() [3/3]

abstract <T extends DBusSignal> void org.freedesktop.dbus.AbstractConnection.addSigHandler ( DBusMatchRule  rule, DBusSigHandler< T >  handler  ) throws DBusException

abstractprotected

addSigHandlerWithoutMatch()

protected<T extends DBusSignal> void org.freedesktop.dbus.AbstractConnection.addSigHandlerWithoutMatch ( Class<? extends DBusSignal >  signal, DBusSigHandler< T >  handler  ) throws DBusException

inlinepackage

                                                                                                                                                        {
        DBusMatchRule rule = new DBusMatchRule(signal);
        SignalTuple key = new SignalTuple(rule.getInterface(), rule.getMember(), rule.getObject(), rule.getSource());
        synchronized (handledSignals) {
            Vector<DBusSigHandler<? extends DBusSignal>> v = handledSignals.get(key);
            if (null == v) {
                v = new Vector<DBusSigHandler<? extends DBusSignal>>();
                v.add(handler);
                handledSignals.put(key, v);
            } else
                v.add(handler);
        }
    }

callMethodAsync()

DBusAsyncReply org.freedesktop.dbus.AbstractConnection.callMethodAsync ( DBusInterface  object, String  m, Object...  parameters  )

inline

Call a method asynchronously and get a handle with which to get the reply.

引数

object	The remote object on which to call the method.
m	The name of the method on the interface to call.
parameters	The parameters to call the method with.

戻り値

A handle to the call.

                                                                                                {
        Class<?>[] types = new Class[parameters.length];
        for (int i = 0; i < parameters.length; i++)
            types[i] = parameters[i].getClass();
        RemoteObject ro = importedObjects.get(object);

        try {
            Method me;
            if (null == ro.iface)
                me = object.getClass().getMethod(m, types);
            else
                me = ro.iface.getMethod(m, types);
            return (DBusAsyncReply) RemoteInvocationHandler.executeRemoteMethod(ro, me, this, RemoteInvocationHandler.CALL_TYPE_ASYNC, null, parameters);
        } catch (DBusExecutionException DBEe) {
            if (EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, DBEe);
            throw DBEe;
        } catch (Exception e) {
            if (EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, e);
            throw new DBusExecutionException(e.getMessage());
        }
    }

callWithCallback()

public<A> void org.freedesktop.dbus.AbstractConnection.callWithCallback ( DBusInterface  object, String  m, CallbackHandler< A >  callback, Object...  parameters  )

inlinepackage

Call a method asynchronously and set a callback. This handler will be called in a separate thread.

引数

object	The remote object on which to call the method.
m	The name of the method on the interface to call.
callback	The callback handler.
parameters	The parameters to call the method with.

                                                                                                                        {
        if (Debug.debug) Debug.print(Debug.VERBOSE, "callWithCallback(" + object + "," + m + ", " + callback);
        Class[] types = new Class[parameters.length];
        for (int i = 0; i < parameters.length; i++)
            types[i] = parameters[i].getClass();
        RemoteObject ro = importedObjects.get(object);

        try {
            Method me;
            if (null == ro.iface)
                me = object.getClass().getMethod(m, types);
            else
                me = ro.iface.getMethod(m, types);
            RemoteInvocationHandler.executeRemoteMethod(ro, me, this, RemoteInvocationHandler.CALL_TYPE_CALLBACK, callback, parameters);
        } catch (DBusExecutionException DBEe) {
            if (EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, DBEe);
            throw DBEe;
        } catch (Exception e) {
            if (EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, e);
            throw new DBusExecutionException(e.getMessage());
        }
    }

changeThreadCount()

void org.freedesktop.dbus.AbstractConnection.changeThreadCount ( byte  newcount )

inline

Change the number of worker threads to receive method calls and handle signals. Default is 4 threads

引数

newcount

The new number of worker Threads to use.

                                                 {
        synchronized (workers) {
            if (workers.size() > newcount) {
                int n = workers.size() - newcount;
                for (int i = 0; i < n; i++) {
                    _workerthread t = workers.removeFirst();
                    t.halt();
                }
            } else if (workers.size() < newcount) {
                int n = newcount - workers.size();
                for (int i = 0; i < n; i++) {
                    _workerthread t = new _workerthread();
                    t.start();
                    workers.add(t);
                }
            }
        }
    }

disconnect()

void org.freedesktop.dbus.AbstractConnection.disconnect ( )

inline

Disconnect from the Bus.

                             {
        connected = false;
        if (Debug.debug) Debug.print(Debug.INFO, "Sending disconnected signal");
        try {
            handleMessage(new org.freedesktop.DBus.Local.Disconnected("/"));
        } catch (Exception ee) {
            if (EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, ee);
        }

        if (Debug.debug) Debug.print(Debug.INFO, "Disconnecting Abstract Connection");
        // run all pending tasks.
        while (runnables.size() > 0)
            synchronized (runnables) {
                runnables.notifyAll();
            }

        // stop the main thread
        _run = false;

        // unblock the sending thread.
        synchronized (outgoing) {
            outgoing.notifyAll();
        }

        // disconnect from the trasport layer
        try {
            if (null != transport) {
                transport.disconnect();
                transport = null;
            }
        } catch (IOException IOe) {
            if (EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, IOe);
        }

        // stop all the workers
        synchronized (workers) {
            for (_workerthread t : workers)
                t.halt();
        }

        // make sure none are blocking on the runnables queue still
        synchronized (runnables) {
            runnables.notifyAll();
        }
    }

exportObject()

void org.freedesktop.dbus.AbstractConnection.exportObject ( String  objectpath, DBusInterface  object  ) throws DBusException

inline

Export an object so that its methods can be called on DBus.

引数

objectpath	The path to the object we are exposing. MUST be in slash-notation, like "/org/freedesktop/Local", and SHOULD end with a capitalised term. Only one object may be exposed on each path at any one time, but an object may be exposed on several paths at once.
object	The object to export.

例外

DBusException

If the objectpath is already exporting an object. or if objectpath is incorrectly formatted,

                                                                                           {
        if (null == objectpath || "".equals(objectpath))
            throw new DBusException(getString("missingObjectPath"));
        if (!objectpath.matches(OBJECT_REGEX) || objectpath.length() > MAX_NAME_LENGTH)
            throw new DBusException(getString("invalidObjectPath") + objectpath);
        synchronized (exportedObjects) {
            if (null != exportedObjects.get(objectpath))
                throw new DBusException(getString("objectAlreadyExported"));
            ExportedObject eo = new ExportedObject(object, weakreferences);
            exportedObjects.put(objectpath, eo);
            objectTree.add(objectpath, eo, eo.introspectiondata);
        }
    }

finalize()

void org.freedesktop.dbus.AbstractConnection.finalize ( )

inline

                           {
        disconnect();
    }

getAddress()

BusAddress org.freedesktop.dbus.AbstractConnection.getAddress ( ) throws ParseException

inline

Returns the address this connection is connected to.

                                                         {
        return new BusAddress(addr);
    }

getCallInfo()

static DBusCallInfo org.freedesktop.dbus.AbstractConnection.getCallInfo ( )

inlinestatic

Returns a structure with information on the current method call.

戻り値

the DBusCallInfo for this method call, or null if we are not in a method call.

                                             {
        DBusCallInfo info;
        synchronized (infomap) {
            info = infomap.get(Thread.currentThread());
        }
        return info;
    }

getError()

DBusExecutionException org.freedesktop.dbus.AbstractConnection.getError ( )

inline

Return any DBus error which has been received.

戻り値

A DBusExecutionException, or null if no error is pending.

                                             {
        synchronized (pendingErrors) {
            if (pendingErrors.size() == 0) return null;
            else
                return pendingErrors.removeFirst().getException();
        }
    }

getExportedObject() [1/2]

String org.freedesktop.dbus.AbstractConnection.getExportedObject ( DBusInterface  i ) throws DBusException

inlinepackage

                                                                   {
        synchronized (exportedObjects) {
            for (String s : exportedObjects.keySet())
                if (i.equals(exportedObjects.get(s).object.get()))
                    return s;
        }

        String s = importedObjects.get(i).objectpath;
        if (null != s) return s;

        throw new DBusException("Not an object exported or imported by this connection");
    }

getExportedObject() [2/2]

abstract DBusInterface org.freedesktop.dbus.AbstractConnection.getExportedObject ( String  source, String  path  ) throws DBusException

abstractpackage

handleMessage() [1/4]

void org.freedesktop.dbus.AbstractConnection.handleMessage ( final MethodCall  m ) throws DBusException

inlineprivate

                                                                        {
        if (Debug.debug) Debug.print(Debug.DEBUG, "Handling incoming method call: " + m);

        ExportedObject eo = null;
        Method meth = null;
        Object o = null;

        if (null == m.getInterface() ||
                m.getInterface().equals("org.freedesktop.DBus.Peer") ||
                m.getInterface().equals("org.freedesktop.DBus.Introspectable")) {
            synchronized (exportedObjects) {
                eo = exportedObjects.get(null);
            }
            if (null != eo && null == eo.object.get()) {
                unExportObject(null);
                eo = null;
            }
            if (null != eo) {
                meth = eo.methods.get(new MethodTuple(m.getName(), m.getSig()));
            }
            if (null != meth)
                o = new _globalhandler(m.getPath());
            else
                eo = null;
        }
        if (null == o) {
            // now check for specific exported functions

            synchronized (exportedObjects) {
                eo = exportedObjects.get(m.getPath());
            }
            if (null != eo && null == eo.object.get()) {
                if (Debug.debug) Debug.print(Debug.INFO, "Unexporting " + m.getPath() + " implicitly");
                unExportObject(m.getPath());
                eo = null;
            }

            if (null == eo) {
                eo = fallbackcontainer.get(m.getPath());
            }

            if (null == eo) {
                try {
                    queueOutgoing(new Error(m, new DBus.Error.UnknownObject(m.getPath() + getString("notObjectProvidedByProcess"))));
                } catch (DBusException DBe) {
                }
                return;
            }
            if (Debug.debug) {
                Debug.print(Debug.VERBOSE, "Searching for method " + m.getName() + " with signature " + m.getSig());
                Debug.print(Debug.VERBOSE, "List of methods on " + eo + ":");
                for (MethodTuple mt : eo.methods.keySet())
                    Debug.print(Debug.VERBOSE, "   " + mt + " => " + eo.methods.get(mt));
            }
            meth = eo.methods.get(new MethodTuple(m.getName(), m.getSig()));
            if (null == meth) {
                try {
                    queueOutgoing(new Error(m, new DBus.Error.UnknownMethod(MessageFormat.format(getString("methodDoesNotExist"), new Object[]{m.getInterface(), m.getName()}))));
                } catch (DBusException DBe) {
                }
                return;
            }
            o = eo.object.get();
        }

        // now execute it
        final Method me = meth;
        final Object ob = o;
        final boolean noreply = (1 == (m.getFlags() & Message.Flags.NO_REPLY_EXPECTED));
        final DBusCallInfo info = new DBusCallInfo(m);
        final AbstractConnection conn = this;
        if (Debug.debug) Debug.print(Debug.VERBOSE, "Adding Runnable for method " + meth);
        addRunnable(new Runnable() {
            private boolean run = false;

            public synchronized void run() {
                if (run) return;
                run = true;
                if (Debug.debug) Debug.print(Debug.DEBUG, "Running method " + me + " for remote call");
                try {
                    Type[] ts = me.getGenericParameterTypes();
                    m.setArgs(Marshalling.deSerializeParameters(m.getParameters(), ts, conn));
                    if (Debug.debug)
                        Debug.print(Debug.VERBOSE, "Deserialised " + Arrays.deepToString(m.getParameters()) + " to types " + Arrays.deepToString(ts));
                } catch (Exception e) {
                    if (EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, e);
                    try {
                        conn.queueOutgoing(new Error(m, new DBus.Error.UnknownMethod(getString("deSerializationFailure") + e)));
                    } catch (DBusException DBe) {
                    }
                    return;
                }

                try {
                    synchronized (infomap) {
                        infomap.put(Thread.currentThread(), info);
                    }
                    Object result;
                    try {
                        if (Debug.debug)
                            Debug.print(Debug.VERBOSE, "Invoking Method: " + me + " on " + ob + " with parameters " + Arrays.deepToString(m.getParameters()));
                        result = me.invoke(ob, m.getParameters());
                    } catch (InvocationTargetException ITe) {
                        if (EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, ITe.getCause());
                        throw ITe.getCause();
                    }
                    synchronized (infomap) {
                        infomap.remove(Thread.currentThread());
                    }
                    if (!noreply) {
                        MethodReturn reply;
                        if (Void.TYPE.equals(me.getReturnType()))
                            reply = new MethodReturn(m, null);
                        else {
                            StringBuffer sb = new StringBuffer();
                            for (String s : Marshalling.getDBusType(me.getGenericReturnType()))
                                sb.append(s);
                            Object[] nr = Marshalling.convertParameters(new Object[]{result}, new Type[]{me.getGenericReturnType()}, conn);

                            reply = new MethodReturn(m, sb.toString(), nr);
                        }
                        conn.queueOutgoing(reply);
                    }
                } catch (DBusExecutionException DBEe) {
                    if (EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, DBEe);
                    try {
                        conn.queueOutgoing(new Error(m, DBEe));
                    } catch (DBusException DBe) {
                    }
                } catch (Throwable e) {
                    if (EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, e);
                    try {
                        conn.queueOutgoing(new Error(m, new DBusExecutionException(MessageFormat.format(getString("errorExecutingMethod"), new Object[]{m.getInterface(), m.getName(), e.getMessage()}))));
                    } catch (DBusException DBe) {
                    }
                }
            }
        });
    }

handleMessage() [2/4]

void org.freedesktop.dbus.AbstractConnection.handleMessage ( final DBusSignal  s )

inlineprivate

                                                   {
        if (Debug.debug) Debug.print(Debug.DEBUG, "Handling incoming signal: " + s);
        Vector<DBusSigHandler<? extends DBusSignal>> v = new Vector<DBusSigHandler<? extends DBusSignal>>();
        synchronized (handledSignals) {
            Vector<DBusSigHandler<? extends DBusSignal>> t;
            t = handledSignals.get(new SignalTuple(s.getInterface(), s.getName(), null, null));
            if (null != t) v.addAll(t);
            t = handledSignals.get(new SignalTuple(s.getInterface(), s.getName(), s.getPath(), null));
            if (null != t) v.addAll(t);
            t = handledSignals.get(new SignalTuple(s.getInterface(), s.getName(), null, s.getSource()));
            if (null != t) v.addAll(t);
            t = handledSignals.get(new SignalTuple(s.getInterface(), s.getName(), s.getPath(), s.getSource()));
            if (null != t) v.addAll(t);
        }
        if (0 == v.size()) return;
        final AbstractConnection conn = this;
        for (final DBusSigHandler<? extends DBusSignal> h : v) {
            if (Debug.debug) Debug.print(Debug.VERBOSE, "Adding Runnable for signal " + s + " with handler " + h);
            addRunnable(new Runnable() {
                private boolean run = false;

                public synchronized void run() {
                    if (run) return;
                    run = true;
                    try {
                        DBusSignal rs;
                        if (s instanceof DBusSignal.internalsig || s.getClass().equals(DBusSignal.class))
                            rs = s.createReal(conn);
                        else
                            rs = s;
                        ((DBusSigHandler<DBusSignal>) h).handle(rs);
                    } catch (DBusException DBe) {
                        if (EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, DBe);
                        try {
                            conn.queueOutgoing(new Error(s, new DBusExecutionException("Error handling signal " + s.getInterface() + "." + s.getName() + ": " + DBe.getMessage())));
                        } catch (DBusException DBe2) {
                        }
                    }
                }
            });
        }
    }

handleMessage() [3/4]

void org.freedesktop.dbus.AbstractConnection.handleMessage ( final Error  err )

inlineprivate

                                                {
        if (Debug.debug) Debug.print(Debug.DEBUG, "Handling incoming error: " + err);
        MethodCall m = null;
        if (null == pendingCalls) return;
        synchronized (pendingCalls) {
            if (pendingCalls.contains(err.getReplySerial()))
                m = pendingCalls.remove(err.getReplySerial());
        }
        if (null != m) {
            m.setReply(err);
            CallbackHandler cbh = null;
            DBusAsyncReply asr = null;
            synchronized (pendingCallbacks) {
                cbh = pendingCallbacks.remove(m);
                if (Debug.debug) Debug.print(Debug.VERBOSE, cbh + " = pendingCallbacks.remove(" + m + ")");
                asr = pendingCallbackReplys.remove(m);
            }
            // queue callback for execution
            if (null != cbh) {
                final CallbackHandler fcbh = cbh;
                if (Debug.debug) Debug.print(Debug.VERBOSE, "Adding Error Runnable with callback handler " + fcbh);
                addRunnable(new Runnable() {
                    private boolean run = false;

                    public synchronized void run() {
                        if (run) return;
                        run = true;
                        try {
                            if (Debug.debug) Debug.print(Debug.VERBOSE, "Running Error Callback for " + err);
                            DBusCallInfo info = new DBusCallInfo(err);
                            synchronized (infomap) {
                                infomap.put(Thread.currentThread(), info);
                            }

                            fcbh.handleError(err.getException());
                            synchronized (infomap) {
                                infomap.remove(Thread.currentThread());
                            }

                        } catch (Exception e) {
                            if (EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, e);
                        }
                    }
                });
            }

        } else
            synchronized (pendingErrors) {
                pendingErrors.addLast(err);
            }
    }

handleMessage() [4/4]

void org.freedesktop.dbus.AbstractConnection.handleMessage ( final MethodReturn  mr )

inlineprivate

                                                      {
        if (Debug.debug) Debug.print(Debug.DEBUG, "Handling incoming method return: " + mr);
        MethodCall m = null;
        if (null == pendingCalls) return;
        synchronized (pendingCalls) {
            if (pendingCalls.contains(mr.getReplySerial()))
                m = pendingCalls.remove(mr.getReplySerial());
        }
        if (null != m) {
            m.setReply(mr);
            mr.setCall(m);
            CallbackHandler cbh = null;
            DBusAsyncReply asr = null;
            synchronized (pendingCallbacks) {
                cbh = pendingCallbacks.remove(m);
                if (Debug.debug) Debug.print(Debug.VERBOSE, cbh + " = pendingCallbacks.remove(" + m + ")");
                asr = pendingCallbackReplys.remove(m);
            }
            // queue callback for execution
            if (null != cbh) {
                final CallbackHandler fcbh = cbh;
                final DBusAsyncReply fasr = asr;
                if (Debug.debug)
                    Debug.print(Debug.VERBOSE, "Adding Runnable for method " + fasr.getMethod() + " with callback handler " + fcbh);
                addRunnable(new Runnable() {
                    private boolean run = false;

                    public synchronized void run() {
                        if (run) return;
                        run = true;
                        try {
                            if (Debug.debug) Debug.print(Debug.VERBOSE, "Running Callback for " + mr);
                            DBusCallInfo info = new DBusCallInfo(mr);
                            synchronized (infomap) {
                                infomap.put(Thread.currentThread(), info);
                            }

                            fcbh.handle(RemoteInvocationHandler.convertRV(mr.getSig(), mr.getParameters(), fasr.getMethod(), fasr.getConnection()));
                            synchronized (infomap) {
                                infomap.remove(Thread.currentThread());
                            }

                        } catch (Exception e) {
                            if (EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, e);
                        }
                    }
                });
            }

        } else
            try {
                queueOutgoing(new Error(mr, new DBusExecutionException(getString("spuriousReply"))));
            } catch (DBusException DBe) {
            }
    }

listen()

void org.freedesktop.dbus.AbstractConnection.listen ( )

inlineprotected

                            {
        // start listening
        thread = new _thread();
        thread.start();
        sender = new _sender();
        sender.start();
    }

queueOutgoing()

void org.freedesktop.dbus.AbstractConnection.queueOutgoing ( Message  m )

inlinepackage

                                  {
        synchronized (outgoing) {
            if (null == outgoing) return;
            outgoing.add(m);
            if (Debug.debug) Debug.print(Debug.DEBUG, "Notifying outgoing thread");
            outgoing.notifyAll();
        }
    }

readIncoming()

Message org.freedesktop.dbus.AbstractConnection.readIncoming ( ) throws DBusException

inlineprivate

                                                        {
        if (!connected) throw new NotConnected(getString("missingTransport"));
        Message m = null;
        try {
            m = transport.min.readMessage();
        } catch (IOException IOe) {
            throw new FatalDBusException(IOe.getMessage());
        }
        return m;
    }

removeFallback()

void org.freedesktop.dbus.AbstractConnection.removeFallback ( String  objectprefix )

inline

Remove a fallback

引数

objectprefix

The prefix to remove the fallback for.

                                                    {
        fallbackcontainer.remove(objectprefix);
    }

removeSigHandler() [1/3]

public<T extends DBusSignal> void org.freedesktop.dbus.AbstractConnection.removeSigHandler ( Class< T >  type, DBusSigHandler< T >  handler  ) throws DBusException

inlinepackage

Remove a Signal Handler. Stops listening for this signal.

引数

type	The signal to watch for.

例外

DBusException	If listening for the signal on the bus failed.
ClassCastException	If type is not a sub-type of DBusSignal.

                                                                                                                       {
        if (!DBusSignal.class.isAssignableFrom(type)) throw new ClassCastException(getString("notDBusSignal"));
        removeSigHandler(new DBusMatchRule(type), handler);
    }

removeSigHandler() [2/3]

public<T extends DBusSignal> void org.freedesktop.dbus.AbstractConnection.removeSigHandler ( Class< T >  type, DBusInterface  object, DBusSigHandler< T >  handler  ) throws DBusException

inlinepackage

Remove a Signal Handler. Stops listening for this signal.

引数

type	The signal to watch for.
object	The object emitting the signal.

例外

DBusException	If listening for the signal on the bus failed.
ClassCastException	If type is not a sub-type of DBusSignal.

                                                                                                                                             {
        if (!DBusSignal.class.isAssignableFrom(type)) throw new ClassCastException(getString("notDBusSignal"));
        String objectpath = importedObjects.get(object).objectpath;
        if (!objectpath.matches(OBJECT_REGEX) || objectpath.length() > MAX_NAME_LENGTH)
            throw new DBusException(getString("invalidObjectPath") + objectpath);
        removeSigHandler(new DBusMatchRule(type, null, objectpath), handler);
    }

removeSigHandler() [3/3]

abstract <T extends DBusSignal> void org.freedesktop.dbus.AbstractConnection.removeSigHandler ( DBusMatchRule  rule, DBusSigHandler< T >  handler  ) throws DBusException

abstractprotected

sendMessage()

void org.freedesktop.dbus.AbstractConnection.sendMessage ( Message  m )

inlineprotected

                                          {
        try {
            if (!connected) throw new NotConnected(getString("disconnected"));
            if (m instanceof DBusSignal)
                ((DBusSignal) m).appendbody(this);

            if (m instanceof MethodCall) {
                if (0 == (m.getFlags() & Message.Flags.NO_REPLY_EXPECTED))
                    if (null == pendingCalls)
                        ((MethodCall) m).setReply(new Error("org.freedesktop.DBus.Local", "org.freedesktop.DBus.Local.disconnected", 0, "s", new Object[]{getString("disconnected")}));
                    else synchronized (pendingCalls) {
                        pendingCalls.put(m.getSerial(), (MethodCall) m);
                    }
            }

            transport.mout.writeMessage(m);

        } catch (Exception e) {
            if (EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, e);
            if (m instanceof MethodCall && e instanceof NotConnected)
                try {
                    ((MethodCall) m).setReply(new Error("org.freedesktop.DBus.Local", "org.freedesktop.DBus.Local.disconnected", 0, "s", new Object[]{getString("disconnected")}));
                } catch (DBusException DBe) {
                }
            if (m instanceof MethodCall && e instanceof DBusExecutionException)
                try {
                    ((MethodCall) m).setReply(new Error(m, e));
                } catch (DBusException DBe) {
                }
            else if (m instanceof MethodCall)
                try {
                    if (Debug.debug) Debug.print(Debug.INFO, "Setting reply to " + m + " as an error");
                    ((MethodCall) m).setReply(new Error(m, new DBusExecutionException(getString("messageFailedSend") + e.getMessage())));
                } catch (DBusException DBe) {
                }
            else if (m instanceof MethodReturn)
                try {
                    transport.mout.writeMessage(new Error(m, e));
                } catch (IOException IOe) {
                    if (EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, IOe);
                } catch (DBusException IOe) {
                    if (EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, e);
                }
            if (e instanceof IOException) disconnect();
        }
    }

sendSignal()

void org.freedesktop.dbus.AbstractConnection.sendSignal ( DBusSignal  signal )

inline

Return a reference to a remote object. This method will resolve the well known name (if given) to a unique bus name when you call it. This means that if a well known name is released by one process and acquired by another calls to objects gained from this method will continue to operate on the original process.

引数

busname	The bus name to connect to. Usually a well known bus name in dot-notation (such as "org.freedesktop.local") or may be a DBus address such as ":1-16".
objectpath	The path on which the process is exporting the object.$
type	The interface they are exporting it on. This type must have the same full class name and exposed method signatures as the interface the remote object is exporting.

戻り値

A reference to a remote object.

例外

ClassCastException	If type is not a sub-type of DBusInterface
DBusException	If busname or objectpath are incorrectly formatted or type is not in a package. Send a signal.

引数

signal

The signal to send.

                                              {
        queueOutgoing(signal);
    }

setWeakReferences()

void org.freedesktop.dbus.AbstractConnection.setWeakReferences ( boolean  weakreferences )

inline

If set to true the bus will not hold a strong reference to exported objects. If they go out of scope they will automatically be unexported from the bus. The default is to hold a strong reference, which means objects must be explicitly unexported before they will be garbage collected.

                                                          {
        this.weakreferences = weakreferences;
    }

unExportObject()

void org.freedesktop.dbus.AbstractConnection.unExportObject ( String  objectpath )

inline

Stop Exporting an object

引数

objectpath

The objectpath to stop exporting.

                                                  {
        synchronized (exportedObjects) {
            exportedObjects.remove(objectpath);
            objectTree.remove(objectpath);
        }
    }

メンバ詳解

_globalhandlerreference

_globalhandler org.freedesktop.dbus.AbstractConnection._globalhandlerreference

private

_run

boolean org.freedesktop.dbus.AbstractConnection._run

protected

addr

String org.freedesktop.dbus.AbstractConnection.addr

protected

BUSNAME_REGEX

final String org.freedesktop.dbus.AbstractConnection.BUSNAME_REGEX = "^[-_a-zA-Z][-_a-zA-Z0-9]*(\\.[-_a-zA-Z][-_a-zA-Z0-9]*)*$"

staticpackage

connected

boolean org.freedesktop.dbus.AbstractConnection.connected = false

protected

CONNID_REGEX

final String org.freedesktop.dbus.AbstractConnection.CONNID_REGEX = "^:[0-9]*\\.[0-9]*$"

staticpackage

dollar_pattern

final Pattern org.freedesktop.dbus.AbstractConnection.dollar_pattern = Pattern.compile("[$]")

staticpackage

EXCEPTION_DEBUG

final boolean org.freedesktop.dbus.AbstractConnection.EXCEPTION_DEBUG

static

exportedObjects

Map<String, ExportedObject> org.freedesktop.dbus.AbstractConnection.exportedObjects

protected

fallbackcontainer

FallbackContainer org.freedesktop.dbus.AbstractConnection.fallbackcontainer

protected

FLOAT_SUPPORT

final boolean org.freedesktop.dbus.AbstractConnection.FLOAT_SUPPORT

staticpackage

handledSignals

Map<SignalTuple, Vector<DBusSigHandler<? extends DBusSignal> > > org.freedesktop.dbus.AbstractConnection.handledSignals

protected

importedObjects

Map<DBusInterface, RemoteObject> org.freedesktop.dbus.AbstractConnection.importedObjects

protected

infomap

final Map<Thread, DBusCallInfo> org.freedesktop.dbus.AbstractConnection.infomap = new HashMap<Thread, DBusCallInfo>()

staticprivate

MAX_ARRAY_LENGTH

final int org.freedesktop.dbus.AbstractConnection.MAX_ARRAY_LENGTH = 67108864

staticpackage

MAX_NAME_LENGTH

final int org.freedesktop.dbus.AbstractConnection.MAX_NAME_LENGTH = 255

staticpackage

OBJECT_REGEX

final String org.freedesktop.dbus.AbstractConnection.OBJECT_REGEX = "^/([-_a-zA-Z0-9]+(/[-_a-zA-Z0-9]+)*)?$"

staticpackage

objectTree

ObjectTree org.freedesktop.dbus.AbstractConnection.objectTree

private

outgoing

EfficientQueue org.freedesktop.dbus.AbstractConnection.outgoing

package

PENDING_MAP_INITIAL_SIZE

final int org.freedesktop.dbus.AbstractConnection.PENDING_MAP_INITIAL_SIZE = 10

staticprivate

Initial size of the pending calls map

pendingCallbackReplys

Map<MethodCall, DBusAsyncReply<? extends Object> > org.freedesktop.dbus.AbstractConnection.pendingCallbackReplys

protected

pendingCallbacks

Map<MethodCall, CallbackHandler<? extends Object> > org.freedesktop.dbus.AbstractConnection.pendingCallbacks

protected

pendingCalls

EfficientMap org.freedesktop.dbus.AbstractConnection.pendingCalls

protected

pendingErrors

LinkedList<Error> org.freedesktop.dbus.AbstractConnection.pendingErrors

package

runnables

LinkedList<Runnable> org.freedesktop.dbus.AbstractConnection.runnables

protected

sender

_sender org.freedesktop.dbus.AbstractConnection.sender

protected

thread

_thread org.freedesktop.dbus.AbstractConnection.thread

protected

THREADCOUNT

final byte org.freedesktop.dbus.AbstractConnection.THREADCOUNT = 4

staticpackage

TIMEOUT

final int org.freedesktop.dbus.AbstractConnection.TIMEOUT = 100000

staticprotected

Timeout in us on checking the BUS for incoming messages and sending outgoing messages

transport

Transport org.freedesktop.dbus.AbstractConnection.transport

protected

weakreferences

boolean org.freedesktop.dbus.AbstractConnection.weakreferences = false

protected

workers

LinkedList<_workerthread> org.freedesktop.dbus.AbstractConnection.workers

protected

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/doxygen/keycloak/federation/src/federation/sssd/src/main/java/org/freedesktop/dbus/AbstractConnection.java