ofmeet plugin version 0.1.6

Added support for media relaying using the JingleNodes plugin

jinglenodes plugin 0.1.3
Replaced jingle nodes relay library jar file with latest source code
Added dependencies smack.jar and smackx.jar

src/plugins/jingleNodes/changelog.html

@@ -49,9 +49,15 @@
     Jingle Nodes Plugin Changelog
 </h1>
 
+<p><b>0.1.3</b> -- May 9th, 2015</p>
+<ul>
+     <li>Replaced jingle nodes relay library jar file with latest source code</li>
+     <li>Added dependencies smack.jar and smackx.jar</li>
+</ul>
+
 <p><b>0.1.2</b> -- Apr 22, 2015</p>
 <ul>
-     <li>Not an official ignite release - fixed the plugin to allow advanced configuration of ip addresses, port numbers, and servers. Previously the code could not work right behind a firewall and the test STUN server hardcoded into the file was not operational.</li>
+     <li>Fixed the plugin to allow advanced configuration of ip addresses, port numbers, and servers. Previously the code could not work right behind a firewall and the test STUN server hardcoded into the file was not operational.</li>
 </ul>
 
 <p><b>0.1.1</b> -- Jan 16, 2015</p>

src/plugins/jingleNodes/plugin.xml

@@ -3,10 +3,10 @@
 <plugin>
     <class>org.jinglenodes.JingleNodesPlugin</class>
     <name>Jingle Nodes Plugin</name>
-    <description>Provides support for Jingle Nodes. This version is a custom modified version of 1.1.1 with a more advanced admin page exposing more properties and the ability to work behind a firewall.</description>
+    <description>Provides support for Jingle Nodes</description>
     <author>Jingle Nodes (Rodrigo Martins)</author>
-    <version>0.1.2</version>
-    <date>04/22/2015</date>
+    <version>0.1.3</version>
+    <date>05/09/2015</date>
     <minServerVersion>3.9.0</minServerVersion>
 
     <adminconsole>

src/plugins/jingleNodes/src/java/org/jinglenodes/JingleNodesPlugin.java

@@ -43,12 +43,12 @@ public class JingleNodesPlugin implements Plugin {
 
     private static final Logger Log = LoggerFactory.getLogger(JingleNodesPlugin.class);
 
-    public static final String JN_LOCAL_IP_PROPERTY = "jinglenodes.localIP";
-    public static final String JN_PUBLIC_IP_PROPERTY = "jinglenodes.publicIP";
-    public static final String JN_MIN_PORT_PROPERTY = "jinglenodes.minPort";
-    public static final String JN_MAX_PORT_PROPERTY = "jinglenodes.maxPort";
-    public static final String JN_TEST_STUN_SERVER_PROPERTY = "jinglenodes.testSTUNServer";
-    public static final String JN_TEST_STUN_PORT_PROPERTY = "jinglenodes.testSTUNPort";
+    public static final String JN_LOCAL_IP_PROPERTY = "jinglenodes.localip";
+    public static final String JN_PUBLIC_IP_PROPERTY = "jinglenodes.publicip";
+    public static final String JN_MIN_PORT_PROPERTY = "jinglenodes.minport";
+    public static final String JN_MAX_PORT_PROPERTY = "jinglenodes.maxport";
+    public static final String JN_TEST_STUN_SERVER_PROPERTY = "jinglenodes.teststunserver";
+    public static final String JN_TEST_STUN_PORT_PROPERTY = "jinglenodes.teststunport";
 
     private ComponentManager componentManager;
 

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/RelayChannel.java

+package org.xmpp.jnodes;
+
+import org.xmpp.jnodes.nio.DatagramListener;
+import org.xmpp.jnodes.nio.SelDatagramChannel;
+
+import java.io.IOException;
+import java.net.BindException;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.nio.ByteBuffer;
+
+public class RelayChannel {
+
+    private final SelDatagramChannel channelA;
+    private final SelDatagramChannel channelB;
+    private final SocketAddress addressA;
+    private final SocketAddress addressB;
+    private SocketAddress lastReceivedA;
+    private SocketAddress lastReceivedB;
+    private final SelDatagramChannel channelA_;
+    private final SelDatagramChannel channelB_;
+    private SocketAddress lastReceivedA_;
+    private SocketAddress lastReceivedB_;        
+    private long lastReceivedTimeA;
+    private long lastReceivedTimeB;
+    private final int portA;
+    private final int portB;
+    private final String ip;
+    private Object attachment;
+
+    public static RelayChannel createLocalRelayChannel(final String host, final int minPort, final int maxPort) throws IOException {
+        int range = maxPort - minPort;
+        IOException be = null;
+
+        for (int t = 0; t < 50; t++) {
+            try {
+                int a = Math.round((int) (Math.random() * range)) + minPort;
+                a = a % 2 == 0 ? a : a + 1;
+                return new RelayChannel(host, a);
+            } catch (BindException e) {
+                be = e;
+            } catch (IOException e) {
+                be = e;
+            }
+        }
+        throw be;
+    }
+
+    public RelayChannel(final String host, final int portA) throws IOException {
+
+        final int portB = portA + 2;
+
+        addressA = new InetSocketAddress(host, portA);
+        addressB = new InetSocketAddress(host, portB);
+
+        channelA = SelDatagramChannel.open(null, addressA);
+        channelB = SelDatagramChannel.open(null, addressB);
+
+        channelA.setDatagramListener(new DatagramListener() {
+            public void datagramReceived(final SelDatagramChannel channel, final ByteBuffer buffer, final SocketAddress address) {
+                lastReceivedA = address;
+                lastReceivedTimeA = System.currentTimeMillis();
+
+                if (lastReceivedB != null) {
+                    try {
+                        buffer.flip();
+                        channelB.send(buffer, lastReceivedB);
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        });
+
+        channelB.setDatagramListener(new DatagramListener() {
+            public void datagramReceived(final SelDatagramChannel channel, final ByteBuffer buffer, final SocketAddress address) {
+                lastReceivedB = address;
+                lastReceivedTimeB = System.currentTimeMillis();
+                if (lastReceivedA != null) {
+                    try {
+                        buffer.flip();
+                        channelA.send(buffer, lastReceivedA);
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        });
+
+        this.portA = portA;
+        this.portB = portB;
+
+        // RTCP Support
+        SocketAddress addressA_ = new InetSocketAddress(host, portA + 1);
+        SocketAddress addressB_ = new InetSocketAddress(host, portB + 1);
+
+        channelA_ = SelDatagramChannel.open(null, addressA_);
+        channelB_ = SelDatagramChannel.open(null, addressB_);
+
+        channelA_.setDatagramListener(new DatagramListener() {
+            public void datagramReceived(final SelDatagramChannel channel, final ByteBuffer buffer, final SocketAddress address) {
+                lastReceivedA_ = address;
+
+                if (lastReceivedB_ != null) {
+                    try {
+                        buffer.flip();
+                        channelB_.send(buffer, lastReceivedB_);
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        });
+
+        channelB_.setDatagramListener(new DatagramListener() {
+            public void datagramReceived(final SelDatagramChannel channel, final ByteBuffer buffer, final SocketAddress address) {
+                lastReceivedB_ = address;
+                if (lastReceivedA_ != null) {
+                    try {
+                        buffer.flip();
+                        channelA_.send(buffer, lastReceivedA_);
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        });
+
+        this.ip = host;
+    }
+
+    public SocketAddress getAddressB() {
+        return addressB;
+    }
+
+    public SocketAddress getAddressA() {
+        return addressA;
+    }
+
+    public int getPortA() {
+        return portA;
+    }
+
+    public int getPortB() {
+        return portB;
+    }
+
+    public String getIp() {
+        return ip;
+    }
+
+    public long getLastReceivedTimeA() {
+        return lastReceivedTimeA;
+    }
+
+    public long getLastReceivedTimeB() {
+        return lastReceivedTimeB;
+    }
+
+    public Object getAttachment() {
+        return attachment;
+    }
+
+    public void setAttachment(Object attachment) {
+        this.attachment = attachment;
+    }
+
+    public void close() {
+        try {
+            channelA.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        try {
+            channelB.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        try {
+            channelA_.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        try {
+            channelB_.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public SelDatagramChannel getChannelA() {
+        return channelA;
+    }
+
+    public SelDatagramChannel getChannelB() {
+        return channelB;
+    }
+
+    public SelDatagramChannel getChannelA_() {
+        return channelA_;
+    }
+
+    public SelDatagramChannel getChannelB_() {
+        return channelB_;
+    }
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/RelayPublicMask.java

+package org.xmpp.jnodes;
+
+import org.xmpp.jnodes.nio.PublicIPResolver;
+
+import java.net.InetSocketAddress;
+
+public class RelayPublicMask {
+
+    private final RelayChannel channel;
+
+    private InetSocketAddress addressA, addressB, addressA_, addressB_;
+
+    public RelayPublicMask(final RelayChannel channel) {
+        this.channel = channel;
+    }
+
+    public void discover(final String stunServer, final int port) {
+        addressA = PublicIPResolver.getPublicAddress(channel.getChannelA(), stunServer, port);
+        addressA_ = PublicIPResolver.getPublicAddress(channel.getChannelA_(), stunServer, port);
+        addressB = PublicIPResolver.getPublicAddress(channel.getChannelB(), stunServer, port);
+        addressB_ = PublicIPResolver.getPublicAddress(channel.getChannelB_(), stunServer, port);
+    }
+
+    public InetSocketAddress getAddressA() {
+        return addressA;
+    }
+
+    public InetSocketAddress getAddressB() {
+        return addressB;
+    }
+
+    public InetSocketAddress getAddressA_() {
+        return addressA_;
+    }
+
+    public InetSocketAddress getAddressB_() {
+        return addressB_;
+    }
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/nio/DatagramListener.java

+package org.xmpp.jnodes.nio;
+
+import java.net.SocketAddress;
+import java.nio.ByteBuffer;
+
+public interface DatagramListener {
+
+    public void datagramReceived(SelDatagramChannel channel, ByteBuffer buffer, SocketAddress address);
+
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/nio/LocalIPResolver.java

+package org.xmpp.jnodes.nio;
+
+import java.net.InetAddress;
+import java.net.NetworkInterface;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.util.Enumeration;
+
+public class LocalIPResolver {
+
+    private static String overrideIp;
+
+    public static String getLocalIP() {
+
+        if (overrideIp != null && overrideIp.length() >= 7) {
+            return overrideIp;
+        }
+
+        Enumeration ifaces;
+
+        try {
+            ifaces = NetworkInterface.getNetworkInterfaces();
+
+            while (ifaces.hasMoreElements()) {
+
+                NetworkInterface iface = (NetworkInterface) ifaces.nextElement();
+                Enumeration iaddresses = iface.getInetAddresses();
+
+                while (iaddresses.hasMoreElements()) {
+                    InetAddress iaddress = (InetAddress) iaddresses.nextElement();
+                    if (!iaddress.isLoopbackAddress() && !iaddress.isLinkLocalAddress() && !iaddress.isSiteLocalAddress()) {
+                        return iaddress.getHostAddress() != null ? iaddress.getHostAddress() : iaddress.getHostName();
+                    }
+                }
+            }
+
+            ifaces = NetworkInterface.getNetworkInterfaces();
+
+            while (ifaces.hasMoreElements()) {
+
+                NetworkInterface iface = (NetworkInterface) ifaces.nextElement();
+                Enumeration iaddresses = iface.getInetAddresses();
+
+                while (iaddresses.hasMoreElements()) {
+                    InetAddress iaddress = (InetAddress) iaddresses.nextElement();
+                    if (!iaddress.isLoopbackAddress() && !iaddress.isLinkLocalAddress()) {
+                        return iaddress.getHostAddress() != null ? iaddress.getHostAddress() : iaddress.getHostName();
+                    }
+                }
+            }
+
+            return InetAddress.getLocalHost().getHostAddress() != null ? InetAddress.getLocalHost().getHostAddress() : InetAddress.getLocalHost().getHostName();
+
+        }
+        catch (SocketException e) {
+            e.printStackTrace();
+        }
+        catch (UnknownHostException e) {
+            e.printStackTrace();
+        }
+
+        return "127.0.0.1";
+    }
+
+    public static String getOverrideIp() {
+        return overrideIp;
+    }
+
+    public static void setOverrideIp(String overrideIp) {
+        LocalIPResolver.overrideIp = overrideIp;
+    }   
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/nio/PublicIPResolver.java

+package org.xmpp.jnodes.nio;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.nio.ByteBuffer;
+import java.util.Random;
+
+public class PublicIPResolver {
+
+    final static byte BINDING_REQUEST_ID = 0x0001;
+    final static int MAPPED_ADDRESS = 0x0001;
+    final static byte CHANGE_REQUEST_NO_CHANGE[] = {0, 3, 0, 4, 0, 0, 0, 0};
+    final static Random r = new Random(System.nanoTime());
+
+    private static byte[] getHeader(final int contentLenght) {
+        final byte header[] = new byte[20];
+        header[0] = 0;
+        header[1] = BINDING_REQUEST_ID;
+        header[2] = 0;
+        header[3] = (byte) contentLenght;
+        header[4] = (byte) (r.nextInt(9));
+        header[5] = (byte) (r.nextInt(8));
+        header[6] = (byte) (r.nextInt(7));
+        header[7] = (byte) (r.nextInt(6));
+        return header;
+    }
+
+    public static ByteBuffer createSTUNChangeRequest() {
+        final byte header[] = getHeader(CHANGE_REQUEST_NO_CHANGE.length);
+        final byte data[] = new byte[header.length + CHANGE_REQUEST_NO_CHANGE.length];
+        System.arraycopy(header, 0, data, 0, header.length);
+        System.arraycopy(CHANGE_REQUEST_NO_CHANGE, 0, data, header.length, CHANGE_REQUEST_NO_CHANGE.length);
+        return ByteBuffer.wrap(data);
+    }
+
+    public static Header parseResponse(byte[] data) {
+        byte[] lengthArray = new byte[2];
+        System.arraycopy(data, 2, lengthArray, 0, 2);
+        int length = unsignedShortToInt(lengthArray);
+        byte[] cuttedData;
+        int offset = 20;
+
+        while (length > 0) {
+            cuttedData = new byte[length];
+            System.arraycopy(data, offset, cuttedData, 0, length);
+            Header h = parseHeader(cuttedData);
+
+            if (h.getType() == MAPPED_ADDRESS) {
+                return h;
+            }
+            length -= h.getLength();
+            offset += h.getLength();
+        }
+        return null;
+    }
+
+    private static Header parseHeader(byte[] data) {
+        byte[] typeArray = new byte[2];
+        System.arraycopy(data, 0, typeArray, 0, 2);
+        int type = unsignedShortToInt(typeArray);
+        byte[] lengthArray = new byte[2];
+        System.arraycopy(data, 2, lengthArray, 0, 2);
+        int lengthValue = unsignedShortToInt(lengthArray);
+        byte[] valueArray = new byte[lengthValue];
+        System.arraycopy(data, 4, valueArray, 0, lengthValue);
+        if (data.length >= 8) {
+            int family = unsignedByteToInt(valueArray[1]);
+            if (family == 1) {
+                byte[] portArray = new byte[2];
+                System.arraycopy(valueArray, 2, portArray, 0, 2);
+                int port = unsignedShortToInt(portArray);
+                int firstOctet = unsignedByteToInt(valueArray[4]);
+                int secondOctet = unsignedByteToInt(valueArray[5]);
+                int thirdOctet = unsignedByteToInt(valueArray[6]);
+                int fourthOctet = unsignedByteToInt(valueArray[7]);
+                final StringBuilder ip = new StringBuilder().append(firstOctet).append(".").append(secondOctet).append(".").append(thirdOctet).append(".").append(fourthOctet);
+                return new Header(new InetSocketAddress(ip.toString(), port), type, lengthValue + 4);
+            }
+        }
+        return new Header(null, -1, lengthValue + 4);
+    }
+
+    public static int unsignedShortToInt(final byte[] b) {
+        int a = b[0] & 0xFF;
+        int aa = b[1] & 0xFF;
+        return ((a << 8) + aa);
+    }
+
+    public static int unsignedByteToInt(byte b) {
+        return (int) b & 0xFF;
+    }
+
+    public static class Header {
+        final InetSocketAddress address;
+        final int type;
+        final int length;
+
+        public Header(final InetSocketAddress address, int type, int length) {
+            this.address = address;
+            this.type = type;
+            this.length = length;
+        }
+
+        public int getType() {
+            return type;
+        }
+
+        public InetSocketAddress getAddress() {
+            return address;
+        }
+
+        public int getLength() {
+            return length;
+        }
+    }
+
+    public static InetSocketAddress getPublicAddress(final String stunServer, final int port) {
+        int lport = 10002;
+
+        for (int t = 0; t < 3; t++) {
+            try {
+                final SelDatagramChannel channel = SelDatagramChannel.open(null, new InetSocketAddress(System.getProperty("os.name")!=null&&System.getProperty("os.name").toLowerCase().indexOf("win") > -1 ? LocalIPResolver.getLocalIP() : "0.0.0.0", lport));
+
+                return getPublicAddress(channel, stunServer, port);
+
+            } catch (IOException e) {
+                lport += r.nextInt(10) + 1;
+            }
+        }
+        return null;
+    }
+
+    public static InetSocketAddress getPublicAddress(final SelDatagramChannel channel, final String stunServer, final int port) {
+        final Header[] h = new Header[1];
+
+        try {
+
+            channel.setDatagramListener(new DatagramListener() {
+                public void datagramReceived(SelDatagramChannel channel, ByteBuffer buffer, SocketAddress address) {
+                    final byte b[] = new byte[buffer.position()];
+                    buffer.rewind();
+                    buffer.get(b, 0, b.length);
+                    h[0] = parseResponse(b);
+                }
+            });
+
+            channel.send(createSTUNChangeRequest(), new InetSocketAddress(stunServer, port));
+            Thread.sleep(100);
+            for (int i = 0; i < 5; i++) {
+                Thread.sleep(100);
+                if (h[0] != null) {
+                    return h[0].getAddress();
+                }
+                if (i % 2 == 0) {
+                    channel.send(createSTUNChangeRequest(), new InetSocketAddress(stunServer, port));
+                }
+            }
+            return null;
+        } catch (IOException e) {
+            return null;
+        } catch (InterruptedException e) {
+            return null;
+        }
+    }
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/nio/SelDatagramChannel.java

+package org.xmpp.jnodes.nio;
+
+import java.io.IOException;
+import java.net.SocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.DatagramChannel;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.Selector;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class SelDatagramChannel {
+
+    private final static ExecutorService executorService = Executors.newFixedThreadPool(10);
+    private static Selector selector;
+
+    // Instance Properties
+    protected final DatagramChannel channel;
+    private DatagramListener datagramListener;
+    private final static Object obj = new Object();
+
+    private static void init() {
+        try {
+            selector = Selector.open();
+
+            while (!selector.isOpen()) {
+                Thread.yield();
+            }
+
+            final Runnable task = new Runnable() {
+                public void run() {
+                    while (true) {
+                        try {
+                            final int n;
+
+                            synchronized (obj) {
+                            }
+                            n = selector.select();
+
+                            if (n == 0) {
+                                Thread.sleep(50);
+                                Thread.yield();
+                                continue;
+                            }
+
+                            final Set keys = selector.selectedKeys();
+
+                            // Iterate through the Set of keys.
+                            for (Iterator i = keys.iterator(); i.hasNext();) {
+                                // Get a key from the set, and remove it from the set
+                                final SelectionKey key = (SelectionKey) i.next();
+                                i.remove();
+
+                                // Get the channel associated with the key
+                                final DatagramChannel c = (DatagramChannel) key.channel();
+
+                                if (key.isValid() && key.isReadable()) {
+                                    final SelDatagramChannel sdc = (SelDatagramChannel) key.attachment();
+
+                                    if (sdc == null) {
+                                        // Discard Packet
+                                        c.receive(ByteBuffer.allocate(0));
+                                        continue;
+                                    }
+
+                                    final ByteBuffer b = ByteBuffer.allocateDirect(1450);
+                                    final SocketAddress clientAddress;
+                                    synchronized (sdc) {
+                                        clientAddress = sdc.channel.receive(b);
+                                    }
+                                    // If we got the datagram successfully, broadcast the Event
+                                    if (clientAddress != null) {
+                                        // Execute in a different Thread avoid serialization
+                                        if (sdc.datagramListener != null) {
+                                            executorService.submit(new Runnable() {
+                                                public void run() {
+                                                    sdc.datagramListener.datagramReceived(sdc, b, clientAddress);
+                                                }
+                                            });
+                                        }
+                                    }
+
+                                }
+                            }
+
+                        } catch (IOException e) {
+                            e.printStackTrace();
+                        }
+                        catch (Throwable t) {
+                            t.printStackTrace();
+                        }
+                    }
+                }
+            };
+
+            executorService.submit(task);
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    protected SelDatagramChannel(final DatagramChannel channel, final DatagramListener datagramListener) {
+        this.channel = channel;
+        this.datagramListener = datagramListener;
+    }
+
+    public static SelDatagramChannel open(final DatagramListener datagramListener, final SocketAddress localAddress) throws IOException {
+        synchronized (executorService) {
+            if (selector == null) {
+                init();
+            }
+        }
+
+        final DatagramChannel dc = DatagramChannel.open();
+        dc.configureBlocking(false);
+        dc.socket().bind(localAddress);
+        final SelDatagramChannel c = new SelDatagramChannel(dc, datagramListener);
+        synchronized (obj) {
+            selector.wakeup();
+            dc.register(selector, SelectionKey.OP_READ, c);
+        }
+        return c;
+    }
+
+    public int send(final ByteBuffer src, final SocketAddress target) throws IOException {
+        return this.channel.send(src, target);
+    }
+
+    public void close() throws IOException {
+        final SelectionKey k = channel.keyFor(selector);
+        if (k != null) {
+            synchronized (obj) {
+                selector.wakeup();
+                k.cancel();
+            }
+        }
+        synchronized (this) {
+            channel.close();
+        }
+    }
+
+    public void setDatagramListener(DatagramListener listener) {
+        this.datagramListener = listener;
+    }
+}
\ No newline at end of file

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/smack/JingleChannelIQ.java

+package org.xmpp.jnodes.smack;
+
+import org.jivesoftware.smack.packet.IQ;
+
+public class JingleChannelIQ extends IQ {
+
+    public static final String NAME = "channel";
+    public static final String NAMESPACE = "http://jabber.org/protocol/jinglenodes#channel";
+
+    public static final String UDP= "udp";
+    public static final String TCP= "tcp";
+
+    private String protocol = UDP;
+    private String host;
+    private int localport = -1;
+    private int remoteport = -1;
+    private String id;
+
+    public JingleChannelIQ() {
+        this.setType(Type.GET);
+        this.setPacketID(IQ.nextID());
+    }
+
+    public String getChildElementXML() {
+        final StringBuilder str = new StringBuilder();
+
+        str.append("<").append(NAME).append(" xmlns='").append(NAMESPACE).append("' protocol='").append(protocol).append("' ");
+        if (localport > 0 && remoteport > 0 && host != null) {
+            str.append("host='").append(host).append("' ");
+            str.append("localport='").append(localport).append("' ");
+            str.append("remoteport='").append(remoteport).append("' ");
+        }
+        str.append("/>");
+
+        return str.toString();
+    }
+
+    public boolean isRequest() {
+        return Type.GET.equals(this.getType());
+    }
+
+    public String getProtocol() {
+        return protocol;
+    }
+
+    public void setProtocol(String protocol) {
+        this.protocol = protocol;
+    }
+
+    public int getRemoteport() {
+        return remoteport;
+    }
+
+    public void setRemoteport(int remoteport) {
+        this.remoteport = remoteport;
+    }
+
+    public String getHost() {
+        return host;
+    }
+
+    public void setHost(String host) {
+        this.host = host;
+    }
+
+    public int getLocalport() {
+        return localport;
+    }
+
+    public void setLocalport(int localport) {
+        this.localport = localport;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public static IQ createEmptyResult(IQ iq) {
+        return createIQ(iq.getPacketID(), iq.getFrom(), iq.getTo(), IQ.Type.RESULT);
+    }
+
+    public static IQ createEmptyError(IQ iq) {
+        return createIQ(iq.getPacketID(), iq.getFrom(), iq.getTo(), IQ.Type.ERROR);
+    }
+
+    public static IQ createEmptyError() {
+        return createIQ(null, null, null, IQ.Type.ERROR);
+    }
+
+    public static IQ createIQ(String ID, String to, String from, IQ.Type type) {
+        IQ iqPacket = new IQ() {
+            public String getChildElementXML() {
+                return null;
+            }
+        };
+
+        iqPacket.setPacketID(ID);
+        iqPacket.setTo(to);
+        iqPacket.setFrom(from);
+        iqPacket.setType(type);
+
+        return iqPacket;
+    }
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/smack/JingleNodesProvider.java

+package org.xmpp.jnodes.smack;
+
+import org.jivesoftware.smack.provider.IQProvider;
+import org.xmlpull.v1.XmlPullParser;
+
+import java.util.IllegalFormatException;
+
+public class JingleNodesProvider implements IQProvider {
+
+    public JingleChannelIQ parseIQ(final XmlPullParser parser) throws Exception {
+
+        JingleChannelIQ iq = null;
+
+        boolean done = false;
+        int eventType;
+        String elementName;
+        String namespace;
+
+        while (!done) {
+
+            eventType = parser.getEventType();
+            elementName = parser.getName();
+            namespace = parser.getNamespace();
+
+            if (eventType == XmlPullParser.START_TAG) {
+                if (elementName.equals(JingleChannelIQ.NAME) && namespace.equals(JingleChannelIQ.NAMESPACE)) {
+
+                    final String protocol = parser.getAttributeValue(null, "protocol");
+                    final String porta = parser.getAttributeValue(null, "localport");
+                    final String portb = parser.getAttributeValue(null, "remoteport");
+                    final String host = parser.getAttributeValue(null, "host");
+
+                    try {
+                        iq = new JingleChannelIQ();
+                        iq.setProtocol(protocol == null ? JingleChannelIQ.UDP : protocol);
+                        if (host != null)
+                            iq.setHost(host);
+                        if (porta != null)
+                            iq.setLocalport(Integer.valueOf(porta));
+                        if (portb != null)
+                            iq.setRemoteport(Integer.valueOf(portb));
+                    } catch (final IllegalFormatException e) {
+                        e.printStackTrace();
+                    } catch (NumberFormatException e) {
+                        e.printStackTrace();
+                    }
+
+                }
+            } else if (eventType == XmlPullParser.END_TAG) {
+                done = true;
+            }
+            if (!done)
+                parser.next();
+        }
+
+        return iq;
+    }
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/smack/JingleTrackerIQ.java

+package org.xmpp.jnodes.smack;
+
+import org.jivesoftware.smack.packet.IQ;
+
+import java.util.Collection;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class JingleTrackerIQ extends IQ {
+
+    public static final String NAME = "services";
+    public static final String NAMESPACE = "http://jabber.org/protocol/jinglenodes";
+
+    private final ConcurrentHashMap<String, TrackerEntry> entries = new ConcurrentHashMap<String, TrackerEntry>();
+
+    public JingleTrackerIQ() {
+        this.setType(Type.GET);
+        this.setPacketID(IQ.nextID());
+    }
+
+    public boolean isRequest() {
+        return Type.GET.equals(this.getType());
+    }
+
+    public void addEntry(final TrackerEntry entry) {
+        entries.put(entry.getJid(), entry);
+    }
+
+    public void removeEntry(final TrackerEntry entry) {
+        entries.remove(entry.getJid());
+    }
+
+    public String getChildElementXML() {
+        final StringBuilder str = new StringBuilder();
+
+        str.append("<").append(NAME).append(" xmlns='").append(NAMESPACE).append("'>");
+        for (final TrackerEntry entry : entries.values()) {
+            str.append("<").append(entry.getType().toString());
+            str.append(" policy='").append(entry.getPolicy().toString()).append("'");
+            str.append(" address='").append(entry.getJid()).append("'");
+            str.append(" protocol='").append(entry.getProtocol()).append("'");
+            if (entry.isVerified()) {
+                str.append(" verified='").append(entry.isVerified()).append("'");
+            }
+            str.append("/>");
+        }
+        str.append("</").append(NAME).append(">");
+
+        return str.toString();
+    }
+
+    public Collection<TrackerEntry> getEntries() {
+        return entries.values();
+    }
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/smack/JingleTrackerProvider.java

+package org.xmpp.jnodes.smack;
+
+import org.jivesoftware.smack.provider.IQProvider;
+import org.xmlpull.v1.XmlPullParser;
+
+public class JingleTrackerProvider implements IQProvider {
+
+    public JingleTrackerIQ parseIQ(final XmlPullParser parser) throws Exception {
+
+        JingleTrackerIQ iq = new JingleTrackerIQ();
+
+        boolean done = false;
+        int eventType;
+        String elementName;
+
+        while (!done) {
+
+            eventType = parser.getEventType();
+            elementName = parser.getName();
+
+            if (eventType == XmlPullParser.START_TAG) {
+                final TrackerEntry.Type type;
+                if (elementName.equals(TrackerEntry.Type.relay.toString())) {
+                    type = TrackerEntry.Type.relay;
+                } else if (elementName.equals(TrackerEntry.Type.tracker.toString())) {
+                    type = TrackerEntry.Type.tracker;
+                } else {
+                    parser.next();
+                    continue;
+                }
+
+                final String protocol = parser.getAttributeValue(null, "protocol");
+                final TrackerEntry.Policy policy = TrackerEntry.Policy.valueOf("_" + parser.getAttributeValue(null, "policy"));
+                final String address = parser.getAttributeValue(null, "address");
+                final String verified = parser.getAttributeValue(null, "verified");
+
+                if (address != null && address.length() > 0) {
+                    final TrackerEntry entry = new TrackerEntry(type, policy, address, protocol);
+                    if (verified != null && verified.equals("true")) {
+                        entry.setVerified(true);
+                    }
+                    iq.addEntry(entry);
+                }
+
+            } else if (eventType == XmlPullParser.END_TAG) {
+                if (elementName.equals(JingleTrackerIQ.NAME)) {
+                    done = true;
+                }
+            }
+            if (!done) {
+                parser.next();
+            }
+        }
+
+        return iq;
+    }
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/smack/SmackServiceNode.java

+package org.xmpp.jnodes.smack;
+
+import org.jivesoftware.smack.*;
+import org.jivesoftware.smack.filter.PacketFilter;
+import org.jivesoftware.smack.filter.PacketIDFilter;
+import org.jivesoftware.smack.packet.IQ;
+import org.jivesoftware.smack.packet.Packet;
+import org.jivesoftware.smack.packet.Presence;
+import org.jivesoftware.smack.provider.ProviderManager;
+import org.jivesoftware.smackx.ServiceDiscoveryManager;
+import org.jivesoftware.smackx.packet.DiscoverItems;
+import org.jivesoftware.smackx.packet.DiscoverInfo;
+import org.xmpp.jnodes.RelayChannel;
+
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class SmackServiceNode implements ConnectionListener, PacketListener {
+
+    private final XMPPConnection connection;
+    private final ConcurrentHashMap<String, RelayChannel> channels = new ConcurrentHashMap<String, RelayChannel>();
+    private final Map<String, TrackerEntry> trackerEntries = Collections.synchronizedMap(new LinkedHashMap<String, TrackerEntry>());
+    private long timeout = 60000;
+    private final static ExecutorService executorService = Executors.newCachedThreadPool(); 
+    private final ScheduledThreadPoolExecutor scheduledExecutor = new ScheduledThreadPoolExecutor(1);
+    private final AtomicInteger ids = new AtomicInteger(0);
+
+    static {
+        ProviderManager.getInstance().addIQProvider(JingleChannelIQ.NAME, JingleChannelIQ.NAMESPACE, new JingleNodesProvider());
+        ProviderManager.getInstance().addIQProvider(JingleTrackerIQ.NAME, JingleTrackerIQ.NAMESPACE, new JingleTrackerProvider());
+    }
+
+    public SmackServiceNode(final XMPPConnection connection, final long timeout) {
+        this.connection = connection;
+        this.timeout = timeout;
+        setup();
+    }
+
+    public SmackServiceNode(final String server, final int port, final long timeout) {
+        final ConnectionConfiguration conf = new ConnectionConfiguration(server, port, server);
+        conf.setSASLAuthenticationEnabled(false);
+        conf.setSecurityMode(ConnectionConfiguration.SecurityMode.disabled);
+        connection = new XMPPConnection(conf);
+        this.timeout = timeout;
+    }
+
+    public void connect(final String user, final String password) throws XMPPException {
+        connect(user, password, false, Roster.SubscriptionMode.accept_all);
+    }
+
+    public void connect(final String user, final String password, final boolean tryCreateAccount, final Roster.SubscriptionMode mode) throws XMPPException {
+        connection.connect();
+        connection.addConnectionListener(this);
+        if (tryCreateAccount) {
+            try {
+                connection.getAccountManager().createAccount(user, password);
+                try {
+                    Thread.sleep(200);
+                } catch (InterruptedException e) {
+                    // Do Nothing
+                }
+            } catch (final XMPPException e) {
+                // Do Nothing as account may exists
+            }
+        }
+        connection.login(user, password);
+        connection.getRoster().setSubscriptionMode(mode);
+        setup();
+    }
+
+    private void setup() {
+        scheduledExecutor.scheduleWithFixedDelay(new Runnable() {
+            public void run() {
+                for (final RelayChannel c : channels.values()) {
+                    final long current = System.currentTimeMillis();
+                    final long da = current - c.getLastReceivedTimeA();
+                    final long db = current - c.getLastReceivedTimeB();
+
+                    if (da > timeout || db > timeout) {
+                        removeChannel(c);
+                    }
+                }
+            }
+        }, timeout, timeout, TimeUnit.MILLISECONDS);
+
+        connection.addPacketListener(this, new PacketFilter() {
+            public boolean accept(Packet packet) {
+                return packet instanceof JingleChannelIQ || packet instanceof JingleTrackerIQ;
+            }
+        });
+    }
+
+    public void connectionClosed() {
+        closeAllChannels();
+        scheduledExecutor.shutdownNow();
+    }
+
+    private void closeAllChannels() {
+        for (final RelayChannel c : channels.values()) {
+            removeChannel(c);
+        }
+    }
+
+    private void removeChannel(final RelayChannel c) {
+        channels.remove(c.getAttachment());
+        c.close();
+    }
+
+    public void connectionClosedOnError(Exception e) {
+        closeAllChannels();
+    }
+
+    public void reconnectingIn(int i) {
+
+    }
+
+    public void reconnectionSuccessful() {
+
+    }
+
+    public void reconnectionFailed(Exception e) {
+
+    }
+
+    protected IQ createUdpChannel(final JingleChannelIQ iq) {
+
+        try {
+            final RelayChannel rc = RelayChannel.createLocalRelayChannel("0.0.0.0", 10000, 40000);
+            final int id = ids.incrementAndGet();
+            final String sId = String.valueOf(id);
+            rc.setAttachment(sId);
+
+            channels.put(sId, rc);
+
+            final JingleChannelIQ result = new JingleChannelIQ();
+            result.setType(IQ.Type.RESULT);
+            result.setTo(iq.getFrom());
+            result.setFrom(iq.getTo());
+            result.setPacketID(iq.getPacketID());
+            result.setHost(rc.getIp());
+            result.setLocalport(rc.getPortA());
+            result.setRemoteport(rc.getPortB());
+            result.setId(sId);
+
+            return result;
+
+        } catch (IOException e) {
+            e.printStackTrace();
+            return JingleChannelIQ.createEmptyError();
+        }
+
+    }
+
+    public void processPacket(final Packet packet) {
+
+        System.out.println("Received: " + packet.toXML());
+        if (packet instanceof JingleChannelIQ) {
+            final JingleChannelIQ request = (JingleChannelIQ) packet;
+            if (request.isRequest()) {
+                connection.sendPacket(createUdpChannel(request));
+            }
+        } else if (packet instanceof JingleTrackerIQ) {
+            final JingleTrackerIQ iq = (JingleTrackerIQ) packet;
+            if (iq.isRequest()) {
+                final JingleTrackerIQ result = createKnownNodes();
+                result.setPacketID(packet.getPacketID());
+                result.setFrom(packet.getTo());
+                result.setTo(packet.getFrom());
+                connection.sendPacket(result);
+            }
+        }
+
+    }
+
+    public XMPPConnection getConnection() {
+        return connection;
+    }
+
+    public static JingleChannelIQ getChannel(final XMPPConnection xmppConnection, final String serviceNode) {
+        if (xmppConnection == null || !xmppConnection.isConnected()) {
+            return null;
+        }
+
+        final JingleChannelIQ iq = new JingleChannelIQ();
+        iq.setFrom(xmppConnection.getUser());
+        iq.setTo(serviceNode);
+
+        PacketCollector collector = xmppConnection.createPacketCollector(new PacketIDFilter(iq.getPacketID()));
+        xmppConnection.sendPacket(iq);
+        JingleChannelIQ result = (JingleChannelIQ) collector.nextResult(Math.round(SmackConfiguration.getPacketReplyTimeout() * 1.5));
+        collector.cancel();
+
+        return result;
+    }
+
+    public static JingleTrackerIQ getServices(final XMPPConnection xmppConnection, final String serviceNode) {
+        if (xmppConnection == null || !xmppConnection.isConnected()) {
+            return null;
+        }
+
+        final JingleTrackerIQ iq = new JingleTrackerIQ();
+        iq.setFrom(xmppConnection.getUser());
+        iq.setTo(serviceNode);
+
+        PacketCollector collector = xmppConnection.createPacketCollector(new PacketIDFilter(iq.getPacketID()));
+        xmppConnection.sendPacket(iq);
+        Packet result = collector.nextResult(Math.round(SmackConfiguration.getPacketReplyTimeout() * 1.5));
+        collector.cancel();
+
+        return result instanceof JingleTrackerIQ ? (JingleTrackerIQ) result : null;
+    }
+
+    private static void deepSearch(final XMPPConnection xmppConnection, final int maxEntries, final String startPoint, final MappedNodes mappedNodes, final int maxDepth, final int maxSearchNodes, final String protocol, final ConcurrentHashMap<String, String> visited) {
+        if (xmppConnection == null || !xmppConnection.isConnected()) {
+            return;
+        }
+        if (mappedNodes.getRelayEntries().size() > maxEntries || maxDepth <= 0) {
+            return;
+        }
+        if (startPoint.equals(xmppConnection.getUser())) {
+            return;
+        }
+        if (visited.size() > maxSearchNodes) {
+            return;
+        }
+
+        JingleTrackerIQ result = getServices(xmppConnection, startPoint);
+        visited.put(startPoint, startPoint);
+        if (result != null && result.getType().equals(IQ.Type.RESULT)) {
+            for (final TrackerEntry entry : result.getEntries()) {
+                if (entry.getType().equals(TrackerEntry.Type.tracker)) {
+                    mappedNodes.getTrackerEntries().put(entry.getJid(), entry);
+                    deepSearch(xmppConnection, maxEntries, entry.getJid(), mappedNodes, maxDepth - 1, maxSearchNodes, protocol, visited);
+                } else if (entry.getType().equals(TrackerEntry.Type.relay)) {
+                    if (protocol == null || protocol.equals(entry.getProtocol())) {
+                        mappedNodes.getRelayEntries().put(entry.getJid(), entry);
+                    }
+                }
+            }
+        }
+    }
+
+    public static MappedNodes aSyncSearchServices(final XMPPConnection xmppConnection, final int maxEntries, final int maxDepth, final int maxSearchNodes, final String protocol, final boolean searchBuddies) {
+        final MappedNodes mappedNodes = new MappedNodes();
+        final Runnable bgTask = new Runnable(){
+            @Override
+            public void run() {
+                searchServices(new ConcurrentHashMap<String, String>(), xmppConnection, maxEntries, maxDepth, maxSearchNodes, protocol, searchBuddies, mappedNodes);
+            }
+        };
+        executorService.submit(bgTask);
+        return mappedNodes;
+    }
+
+    public static MappedNodes searchServices(final XMPPConnection xmppConnection, final int maxEntries, final int maxDepth, final int maxSearchNodes, final String protocol, final boolean searchBuddies) {
+        return searchServices(new ConcurrentHashMap<String, String>(), xmppConnection, maxEntries, maxDepth, maxSearchNodes, protocol, searchBuddies, new MappedNodes());
+    }
+
+    private static MappedNodes searchServices(final ConcurrentHashMap<String, String> visited, final XMPPConnection xmppConnection, final int maxEntries, final int maxDepth, final int maxSearchNodes, final String protocol, final boolean searchBuddies, final MappedNodes mappedNodes) {
+        if (xmppConnection == null || !xmppConnection.isConnected()) {
+            return null;
+        }
+
+        searchDiscoItems(xmppConnection, maxEntries, xmppConnection.getServiceName(), mappedNodes, maxDepth - 1, maxSearchNodes, protocol, visited);
+
+        // Request to Server
+        deepSearch(xmppConnection, maxEntries, xmppConnection.getHost(), mappedNodes, maxDepth - 1, maxSearchNodes, protocol, visited);
+
+        // Request to Buddies
+        if (xmppConnection.getRoster() != null && searchBuddies) {
+            for (final RosterEntry re : xmppConnection.getRoster().getEntries()) {
+                for (final Iterator<Presence> i = xmppConnection.getRoster().getPresences(re.getUser()); i.hasNext();) {
+                    final Presence presence = i.next();
+                    if (presence.isAvailable()) {
+                        deepSearch(xmppConnection, maxEntries, presence.getFrom(), mappedNodes, maxDepth - 1, maxSearchNodes, protocol, visited);
+                    }
+                }
+            }
+        }
+
+        return mappedNodes;
+    }
+
+    private static void searchDiscoItems(final XMPPConnection xmppConnection, final int maxEntries, final String startPoint, final MappedNodes mappedNodes, final int maxDepth, final int maxSearchNodes, final String protocol, final ConcurrentHashMap<String, String> visited) {
+        final DiscoverItems items = new DiscoverItems();
+        items.setTo(startPoint);
+        PacketCollector collector = xmppConnection.createPacketCollector(new PacketIDFilter(items.getPacketID()));
+        xmppConnection.sendPacket(items);
+        DiscoverItems result = (DiscoverItems) collector.nextResult(Math.round(SmackConfiguration.getPacketReplyTimeout() * 1.5));
+
+        if (result != null) {
+            final Iterator<DiscoverItems.Item> i = result.getItems();
+            for (DiscoverItems.Item item = i.hasNext() ? i.next() : null; item != null; item = i.hasNext() ? i.next() : null) {
+                deepSearch(xmppConnection, maxEntries, item.getEntityID(), mappedNodes, maxDepth, maxSearchNodes, protocol, visited);
+            }
+        }
+        collector.cancel();
+    }
+
+    public static class MappedNodes {
+        final Map<String, TrackerEntry> relayEntries = Collections.synchronizedMap(new LinkedHashMap<String, TrackerEntry>());
+        final Map<String, TrackerEntry> trackerEntries = Collections.synchronizedMap(new LinkedHashMap<String, TrackerEntry>());
+
+        public Map<String, TrackerEntry> getRelayEntries() {
+            return relayEntries;
+        }
+
+        public Map<String, TrackerEntry> getTrackerEntries() {
+            return trackerEntries;
+        }
+    }
+
+    ConcurrentHashMap<String, RelayChannel> getChannels() {
+        return channels;
+    }
+
+    public JingleTrackerIQ createKnownNodes() {
+
+        final JingleTrackerIQ iq = new JingleTrackerIQ();
+        iq.setType(IQ.Type.RESULT);
+
+        for (final TrackerEntry entry : trackerEntries.values()) {
+            if (!entry.getPolicy().equals(TrackerEntry.Policy._roster)) {
+                iq.addEntry(entry);
+            }
+        }
+
+        return iq;
+    }
+
+    public void addTrackerEntry(final TrackerEntry entry) {
+        trackerEntries.put(entry.getJid(), entry);
+    }
+
+    public void addEntries(final MappedNodes entries) {
+        for (final TrackerEntry t : entries.getRelayEntries().values()) {
+            addTrackerEntry(t);
+        }
+        for (final TrackerEntry t : entries.getTrackerEntries().values()) {
+            addTrackerEntry(t);
+        }
+    }
+
+    public Map<String, TrackerEntry> getTrackerEntries() {
+        return trackerEntries;
+    }
+
+    public TrackerEntry getPreferedRelay() {
+        for (final TrackerEntry trackerEntry : trackerEntries.values()) {
+            if (TrackerEntry.Type.relay.equals(trackerEntry.getType())) {
+                return trackerEntry;
+            }
+        }
+        return null;
+    }
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/smack/TrackerEntry.java

+package org.xmpp.jnodes.smack;
+
+public class TrackerEntry {
+
+    public enum Type {
+        relay, tracker
+    }
+
+    public enum Policy {
+        _public, _roster;
+
+        public String toString() {
+            return this.name().substring(1);
+        }
+    }
+
+    private Type type;
+    private Policy policy;
+    private boolean verified = false;
+    private String protocol = JingleChannelIQ.UDP;
+    private String jid;
+
+    public TrackerEntry(final Type type, final Policy policy, final String jid, final String protocol) {
+        this.type = type;
+        this.policy = policy;
+        this.jid = jid;
+        this.protocol = protocol;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    public void setType(Type type) {
+        this.type = type;
+    }
+
+    public String getJid() {
+        return jid;
+    }
+
+    public void setJid(String jid) {
+        this.jid = jid;
+    }
+
+    public boolean isVerified() {
+        return verified;
+    }
+
+    public void setVerified(boolean verified) {
+        this.verified = verified;
+    }
+
+    public Policy getPolicy() {
+        return policy;
+    }
+
+    public void setPolicy(Policy policy) {
+        this.policy = policy;
+    }
+
+    public String getProtocol() {
+        return protocol;
+    }
+
+    public void setProtocol(String protocol) {
+        this.protocol = protocol;
+    }
+}

src/plugins/ofmeet/changelog.html

@@ -49,6 +49,12 @@
     Openfire Meetings Plugin Changelog
 </h1>
 
+<p><b>0.1.6</b> -- May 9th, 2015</p>
+
+<ul>
+    <li>Added support for media relaying using the JingleNodes plugin</li>
+</ul>
+
 <p><b>0.1.5</b> -- May 4th, 2015</p>
 
 <ul>

src/plugins/ofmeet/plugin.xml

@@ -5,8 +5,8 @@
     <name>Openfire Meetings</name>
     <description>Provides high quality, scalable video conferences using Jitsi Meet and Jitsi Videobridge</description>
     <author>Ignite Realtime</author>
-    <version>0.1.5</version>
-    <date>05/04/2015</date>
+    <version>0.1.6</version>
+    <date>05/09/2015</date>
     <minServerVersion>3.9.9</minServerVersion>
     
     <adminconsole>

src/plugins/ofmeet/readme.html

@@ -75,8 +75,12 @@
 	<p><span>Spark Plugin - </span>https://your-server.com:7443/ofmeet/spark/ofmeet-plugin.jar</p>
 	<p>Candy - https://your-server.com:7443/ofmeet/candy.html</p>
 	<p style="min-height: 8pt; padding: 0px;">&nbsp;</p><p><a href="https://community.igniterealtime.org/servlet/JiveServlet/showImage/38-1730-22278/ofmeet5.png"><img alt="ofmeet5.png" height="93" src="https://community.igniterealtime.org/servlet/JiveServlet/downloadImage/38-1730-22278/ofmeet5.png" style="height: auto;" width="300"/></a></p>
+</div>
+<div>
+	<p>It also has a meeting planner feature that enables you to schedule meetings in advance using a calendar.When you add a meeting to the calendar, a request to join the meeting is automatically generated and sent to each participant using Openfire's email service 15 mins before the meeting starts. Included in the email is a link to join the meeting from a Chrome web browser.</p><p><a href="https://community.igniterealtime.org/servlet/JiveServlet/showImage/38-1762-66498/Image2.jpg"><img alt="Image2.jpg" height="215" src="https://community.igniterealtime.org/servlet/JiveServlet/downloadImage/38-1762-66498/379-215/Image2.jpg" style="width:379px; height: 215.108108108108px;" width="379"></a><a href="https://community.igniterealtime.org/servlet/JiveServlet/showImage/38-1762-66502/Image5.jpg"><img alt="Image5.jpg" height="175" src="https://community.igniterealtime.org/servlet/JiveServlet/downloadImage/38-1762-66502/212-175/Image5.jpg" style="width:212px; height: 174.9px;" width="212"></a></p><p>In order to use this feature, you will need:<br><br></p><ul><li>Registered Openfire users with valid email address,</li><li>A persistent MUC room to host each planned meeting</li><li>The Openfire ClientControl plugin installed to create a room bookmark that links the room to users or user groups. Bookmarks with all users selected are ignored.<br><a href="https://community.igniterealtime.org/servlet/JiveServlet/showImage/38-1762-66501/Image6.jpg"><img alt="Image6.jpg"  height="210" src="https://community.igniterealtime.org/servlet/JiveServlet/downloadImage/38-1762-66501/375-210/Image6.jpg" style="width:375px; height: 209.879032258065px;" width="375"></a></li><li>The Openfire Email Service configured to deliver emails<br><a href="https://community.igniterealtime.org/servlet/JiveServlet/showImage/38-1762-66500/Image4.jpg"><img alt="Image4.jpg" height="408" src="https://community.igniterealtime.org/servlet/JiveServlet/downloadImage/38-1762-66500/Image4.jpg" style="width: 620px; height: 209px;" width="1210"></a></li></ul><p>The calendar is implemented using the excellent open source <a href="http://fullcalendar.io/" rel="nofollow" target="_blank">fullcalendar</a> jquery plugin by Adam Shaw.</p>
+</div>
 	<p>Discussion place is in the <a href="https://community.igniterealtime.org/community/plugins/commplugins/openfire-meetings/activity">community plugins, here</a></p>
+<div>
 </div>
-
 </body>
 </html>

src/plugins/ofmeet/src/chrome-extension/ofmeet-api.js

@@ -18551,6 +18551,10 @@ var ofmeet = (function(of)
 	    this.hadturncandidate = false;
 	    this.lasticecandidate = false;
 
+	    this.relayHost = null;
+	    this.relayLocalPort = null;
+	    this.relayRemotePort = null; 
+    
 	    this.statsinterval = null;
 
 	    this.reason = null;
@@ -18574,7 +18578,10 @@ var ofmeet = (function(of)
 	    this.hadstuncandidate = false;
 	    this.hadturncandidate = false;
 	    this.lasticecandidate = false;
-
+	    this.relayHost = null;
+	    this.relayLocalPort = null;
+	    this.relayRemotePort = null; 
+	    
 	    this.peerconnection
 		= new TraceablePeerConnection(
 		    this.connection.jingle.ice_config,
@@ -18806,6 +18813,8 @@ var ofmeet = (function(of)
 
 	JingleSession.prototype.sendIceCandidates = function (candidates) {
 	    //console.log('sendIceCandidates', candidates);
+	    var self = this;
+	    var relayDone = false;
 	    var cand = $iq({to: this.peerjid, type: 'set'})
 		.c('jingle', {xmlns: 'urn:xmpp:jingle:1',
 		    action: 'transport-info',
@@ -18823,6 +18832,36 @@ var ofmeet = (function(of)
 		    for (var i = 0; i < cands.length; i++) {
 			cand.c('candidate', SDPUtil.candidateToJingle(cands[i].candidate)).up();
 		    }
+		    
+		    if (!self.relayDone )
+		    {
+			    console.log('sendIceCandidates: send jingle nodes request');            
+			    var iqRelay = $iq({type: "get", to: "relay." + self.connection.domain}).c('channel', {xmlns: "http://jabber.org/protocol/jinglenodes#channel", protocol: 'udp'});
+
+			    self.connection.sendIQ(iqRelay, function(response)
+			    {
+				if ($(response).attr('type') == "result")
+				{
+					console.log('sendIceCandidates: jingle nodes response', response);  
+					self.hadturncandidate = true;
+
+					$(response).find('channel').each(function() 
+					{
+						self.relayHost = $(this).attr('host');
+						self.relayLocalPort = $(this).attr('localport');
+						self.relayRemotePort = $(this).attr('remoteport');
+
+						var relayCandidate = "a=candidate:3707591233 1 udp 2113937151 " + self.relayHost + " " + self.relayRemotePort + " typ relay generation 0 ";
+
+						console.log("add JingleNodes candidate: " + self.relayHost + " " + self.relayLocalPort + " " + self.relayRemotePort); 
+						cand.c('candidate', SDPUtil.candidateToJingle(relayCandidate)).up();
+					});
+
+				}		
+			    }, function(err) {console.error("jingle nodes request error", err)});
+			    
+			    relayDone = true;
+		    }	    	    
 		    // add fingerprint
 		    if (SDPUtil.find_line(this.localSDP.media[mid], 'a=fingerprint:', this.localSDP.session)) {
 			var tmp = SDPUtil.parse_fingerprint(SDPUtil.find_line(this.localSDP.media[mid], 'a=fingerprint:', this.localSDP.session));
@@ -18838,6 +18877,8 @@ var ofmeet = (function(of)
 		    cand.up(); // transport
 		    cand.up(); // content
 		}
+		
+		self.relayDone = relayDone;
 	    }
 	    // might merge last-candidate notification into this, but it is called alot later. See webrtc issue #2340
 	    //console.log('was this the last candidate', this.lasticecandidate);
@@ -18963,6 +19004,14 @@ var ofmeet = (function(of)
 		    this.remoteSDP.raw = this.remoteSDP.session + this.remoteSDP.media.join('');
 		}
 	    }
+	    
+	    if (this.relayHost != null && this.relayLocalPort != null)
+	    {
+		var candidate = new RTCIceCandidate({sdpMLineIndex: "0", candidate: "a=candidate:3707591233 1 udp 2113937151 " + this.relayHost + " " + this.relayLocalPort + " typ relay generation 0 "});
+		this.peerconnection.addIceCandidate(candidate);  
+		this.hadturncandidate = true;
+	    }
+	    
 	    var remotedesc = new RTCSessionDescription({type: desctype, sdp: this.remoteSDP.raw});
 
 	    this.peerconnection.setRemoteDescription(remotedesc,
@@ -20406,7 +20455,7 @@ var ofmeet = (function(of)
 	    connection: null,
 	    sessions: {},
 	    jid2session: {},
-	    ice_config: {iceServers: []},
+	    ice_config: {'iceServers': [{ 'url': 'stun:stun.l.google.com:19302' }]},
 	    pc_constraints: {},
 	    media_constraints: {
 		mandatory: {
@@ -20503,7 +20552,7 @@ var ofmeet = (function(of)
 			}
 			sess.media_constraints = this.media_constraints;
 			sess.pc_constraints = this.pc_constraints;
-			sess.ice_config = this.ice_config;
+			sess.ice_config = config.iceServers ? config.iceServers : this.ice_config;
 
 			sess.initiate(fromJid, false);
 			// FIXME: setRemoteDescription should only be done when this call is to be accepted
@@ -20590,7 +20639,7 @@ var ofmeet = (function(of)
 		}
 		sess.media_constraints = this.media_constraints;
 		sess.pc_constraints = this.pc_constraints;
-		sess.ice_config = this.ice_config;
+		sess.ice_config = config.iceServers ? config.iceServers : this.ice_config;
 
 		sess.initiate(peerjid, true);
 		this.sessions[sess.sid] = sess;
@@ -29484,14 +29533,56 @@ var ofmeet = (function(of)
 	       connection: null,
 	       audioChannels: {},
 	       localStream: null,
+	       dtmfSender: null,
 
 		init: function (conn) 
 		{
 			this.connection = conn; 
-
+        		this.connection.addHandler(this.onRayo.bind(this), 'urn:xmpp:rayo:1');  
+        	
 			console.log("strophe plugin inum enabled");                              
 		},
+		
+		onRayo: function (packet) 
+		{
+			//console.log("inum - onRayo", packet);
+			var from = $(packet).attr('from');
+			var callId = Strophe.getNodeFromJid(from); 
+			var callerId = null;
+			var calledId = null;			
 
+			$(packet).find('header').each(function() 
+			{		
+				var name = $(this).attr('name');
+				var value = $(this).attr('value');
+
+				//console.log("inum - onRayo header", name, value);
+
+				if (name == "caller_id") callerId = value;
+				if (name == "called_id") calledId = value;				
+			});	
+
+			$(packet).find('answered').each(function() 
+			{	
+				$(document).trigger('inum.answered', [callId, callerId, calledId]);
+			});
+
+			$(packet).find('hangup').each(function() 
+			{	
+				$(document).trigger('inum.hangup', [callId, callerId, calledId]);			
+			});	
+
+			return true;
+		},
+
+		sendTones: function (tones)
+		{
+			if (this.dtmfSender) 
+			{
+				this.dtmfSender.insertDTMF(tones);
+			}		
+		},
+		
 		hangup: function (callId)
 		{
 		    var self = this;
@@ -29595,7 +29686,9 @@ var ofmeet = (function(of)
 
 		handleOffer: function(offer) 
 		{
-			var offerSDP = new SDP('v=0\r\no=- 5151055458874951233 2 IN IP4 127.0.0.1\r\ns=-\r\nt=0 0\r\nm=audio 1 RTP/SAVPF 111 0 126\r\nc=IN IP4 0.0.0.0\r\na=rtcp:1 IN IP4 0.0.0.0\r\na=mid:audio\r\na=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level\r\na=sendrecv\r\na=rtpmap:111 opus/48000/2\r\na=fmtp:111 minptime=10\r\na=rtpmap:0 PCMU/8000\r\na=rtpmap:126 telephone-event/8000\r\na=maxptime:60\r\nm=video 1 RTP/SAVPF 100 116 117\r\nc=IN IP4 0.0.0.0\r\na=rtcp:1 IN IP4 0.0.0.0\r\na=mid:video\r\na=extmap:2 urn:ietf:params:rtp-hdrext:toffset\r\na=extmap:3 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\r\na=sendrecv\r\na=rtpmap:100 VP8/90000\r\na=rtcp-fb:100 ccm fir\r\na=rtcp-fb:100 nack\r\na=rtcp-fb:100 goog-remb\r\na=rtpmap:116 red/90000\r\na=rtpmap:117 ulpfec/90000\r\n');                   
+			//var offerSDP = new SDP('v=0\r\no=- 5151055458874951233 2 IN IP4 127.0.0.1\r\ns=-\r\nt=0 0\r\nm=audio 1 RTP/SAVPF 111 0 126\r\nc=IN IP4 0.0.0.0\r\na=rtcp:1 IN IP4 0.0.0.0\r\na=mid:audio\r\na=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level\r\na=sendrecv\r\na=rtpmap:111 opus/48000/2\r\na=fmtp:111 minptime=10\r\na=rtpmap:0 PCMU/8000\r\na=rtpmap:126 telephone-event/8000\r\na=maxptime:60\r\nm=video 1 RTP/SAVPF 100 116 117\r\nc=IN IP4 0.0.0.0\r\na=rtcp:1 IN IP4 0.0.0.0\r\na=mid:video\r\na=extmap:2 urn:ietf:params:rtp-hdrext:toffset\r\na=extmap:3 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\r\na=sendrecv\r\na=rtpmap:100 VP8/90000\r\na=rtcp-fb:100 ccm fir\r\na=rtcp-fb:100 nack\r\na=rtcp-fb:100 goog-remb\r\na=rtpmap:116 red/90000\r\na=rtpmap:117 ulpfec/90000\r\n');                   
+			
+			var offerSDP = new SDP('v=0\r\no=- 5151055458874951233 2 IN IP4 127.0.0.1\r\ns=-\r\nt=0 0\r\nm=audio 1 RTP/SAVPF 0 126\r\nc=IN IP4 0.0.0.0\r\na=rtcp:1 IN IP4 0.0.0.0\r\na=mid:audio\r\na=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level\r\na=sendrecv\r\na=rtpmap:0 PCMU/8000\r\na=rtpmap:126 telephone-event/8000\r\na=maxptime:60\r\nm=video 1 RTP/SAVPF 100 116 117\r\nc=IN IP4 0.0.0.0\r\na=rtcp:1 IN IP4 0.0.0.0\r\na=mid:video\r\na=extmap:2 urn:ietf:params:rtp-hdrext:toffset\r\na=extmap:3 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\r\na=sendrecv\r\na=rtpmap:100 VP8/90000\r\na=rtcp-fb:100 ccm fir\r\na=rtcp-fb:100 nack\r\na=rtcp-fb:100 goog-remb\r\na=rtpmap:116 red/90000\r\na=rtpmap:117 ulpfec/90000\r\n');                   			
 			offerSDP.media[1] = null;
 
 			console.log("handleOffer", offer, this.localStream, offerSDP);
@@ -29695,8 +29788,17 @@ var ofmeet = (function(of)
 				{
 					that.audioChannels[confId].peerconnection.setLocalDescription(desc);
 					$(document).trigger('inum.connected', [confId, audioId]);					
-				});                                                           
-			};                                             
+				}); 
+				
+				that.dtmfSender = that.audioChannels[confId].peerconnection.createDTMFSender(that.localStream.getTracks()[0]);
+				
+				that.dtmfSender.ontonechange = function(tone)
+				{
+					console.log("sent dtmf tone", tone);
+					$(document).trigger('inum.tone', [confId, audioId, tone]);
+				};
+				
+			}                                         
 
 			that.audioChannels[confId].peerconnection.addStream(that.localStream);
 			that.audioChannels[confId].peerconnection.setRemoteDescription(new RTCSessionDescription({type: "offer", sdp : offerSDP.raw}));
@@ -29791,7 +29893,7 @@ var ofmeet = (function(of)
 
 				function (res) {
 				    console.log('sendAnswer ok', res);  
-				    $(document).trigger('inum.answered', [confId, audioId]);				    
+				    $(document).trigger('inum.delivered', [confId, audioId]);				    
 				},
 
 				function (err) {
@@ -29836,8 +29938,10 @@ var ofmeet = (function(of)
 			
 			this.audioChannels[confId].peerconnection = null;
 			this.localStream = null;
+			this.dtmfSender = null
 		}                              
 	});  
+ 
 
 	/**
 	 * messageHandler
@@ -32426,7 +32530,14 @@ var ofmeet = (function(of)
 
 	of.ready = function (username, password) 
 	{
-		$.ajax({type: "GET", url: "/ofmeet/config", dataType: "script", headers: {"Authorization": "Basic " + btoa(username + ":" + password)}}).done(function()
+		var headers = null;
+		
+		if (username && password)
+		{
+			headers = {"Authorization": "Basic " + btoa(username + ":" + password)}
+		}
+		
+		$.ajax({type: "GET", url: "/ofmeet/config", dataType: "script", headers: headers}).done(function()
 		{
 			var cssId = 'ofmeet-css';
 
@@ -32560,7 +32671,7 @@ var ofmeet = (function(of)
 	}
 	
     	of.VideoLayout = VideoLayout;
-    	of.connection = connection;    	
+    	of.connection = connection;  
     	
     	return of;
 }(ofmeet || {}));
\ No newline at end of file

src/plugins/ofmeet/src/inum/att.phonenumber.js

+/*global io MediaServices Phono*/
+(function () {
+    // Utils and references
+    var root = this,
+        att = {};
+
+    // global utils
+    var _ = att.util = {
+        _uuidCounter: 0,
+        uuid: function () {
+            return Math.random().toString(16).substring(2) + (_._uuidCounter++).toString(16);
+        },
+        slice: Array.prototype.slice,
+        isFunc: function (obj) {
+            return Object.prototype.toString.call(obj) == '[object Function]';
+        },
+        extend: function (obj) {
+            this.slice.call(arguments, 1).forEach(function (source) {
+                if (source) {
+                    for (var prop in source) {
+                        obj[prop] = source[prop];
+                    }
+                }
+            });
+            return obj;
+        },
+        each: function (obj, func) {
+            if (!obj) return;
+            if (obj instanceof Array) {
+                obj.forEach(func);
+            } else {
+                for (var key in obj) {
+                    func(key, obj[key]);
+                }
+            }
+        },
+        getQueryParam: function (name) {
+            // query string parser
+            var cleaned = name.replace(/[\[]/, "\\[").replace(/[\]]/, "\\]"),
+                regexS = "[\\?&]" + cleaned + "=([^&#]*)",
+                regex = new RegExp(regexS),
+                results = regex.exec(window.location.search);
+            return (results) ? decodeURIComponent(results[1].replace(/\+/g, " ")) : undefined;
+        },
+        // used to try to determine whether they're using the ericsson leif browser
+        // this is not an ideal way to check, but I'm not sure how to do it since
+        // leif if pretty much just stock chromium.
+        h2sSupport: function () {
+            return !!window.webkitPeerConnection00 && window.navigator.userAgent.indexOf('Chrome/24') !== -1;
+        }
+    };
+
+    var phoneNumber = {};
+    
+    phoneNumber.stringify = function (text) {
+        // strip all non numbers
+        var cleaned = phoneNumber.parse(text),
+            len = cleaned.length,
+            countryCode = (cleaned.charAt(0) === '1'),
+            arr = cleaned.split(''),
+            diff;
+    
+        // if it's long just return it unformatted
+        if (len > (countryCode ? 11 : 10)) return cleaned;
+    
+        // if it's too short to tell
+        if (!countryCode && len < 4) return cleaned;
+    
+        // remove country code if we have it
+        if (countryCode) arr.splice(0, 1);
+    
+        // the rules are different enough when we have
+        // country codes so we just split it out
+        if (countryCode) {
+            if (len > 1) {
+                diff = 4 - len;
+                diff = (diff > 0) ? diff : 0;
+                arr.splice(0, 0, " (");
+                // back fill with spaces
+                arr.splice(4, 0, (new Array(diff + 1).join(' ') + ") "));
+                
+                if (len > 7) {
+                    arr.splice(8, 0, '-');
+                }
+            }
+        } else {
+            if (len > 7) {
+                arr.splice(0, 0, "(");
+                arr.splice(4, 0, ") ");
+                arr.splice(8, 0, "-");
+            } else if (len > 3) {
+                arr.splice(3, 0, "-");
+            }
+        }
+    
+        // join it back when we're done with the CC if it's there
+        return (countryCode ? '1' : '') + arr.join('');
+    };
+    
+    phoneNumber.parse = function (input) {
+        return String(input)
+            .toUpperCase()
+            .replace(/[A-Z]/g, function (l) {
+                return (l.charCodeAt(0) - 65) / 3 + 2 - ("SVYZ".indexOf(l) > -1) | 0;
+            })
+            .replace(/\D/g, '');
+    };
+    
+    phoneNumber.getCallable = function (input, countryAbr) {
+        var country = countryAbr || 'us',
+            cleaned = phoneNumber.parse(input);
+        if (cleaned.length === 10) {
+            if (country == 'us') {
+                return '1' + cleaned;
+            }
+        } else if (country == 'us' && cleaned.length === 11 && cleaned.charAt(0) === '1') {
+            return cleaned;
+        } else {
+            return false;
+        }
+    };
+    
+    att.phoneNumber = phoneNumber;
+
+
+
+
+    // attach to window or export with commonJS
+    if (typeof exports !== 'undefined') {
+        module.exports = att;
+    } else {
+        // make sure we've got an "att" global
+        root.ATT || (root.ATT = {});
+        _.extend(root.ATT, att);
+    }
+
+}).call(this);

src/plugins/ofmeet/src/inum/index.html

+<html>
+<head>
+	<title>iNum Demo Application</title>
+	<link rel="import" href="ui-telephone.html"></link>
+    <script src="../chrome-extension/ofmeet-api.js"></script>
+	<script type="text/javascript" src="index.js"></script>
+	<style>
+      html, body {
+        height: 100%;
+        margin: 0;
+		background: #f0f0f0;
+        font-family: sans-serif;
+      }
+
+      inum-telephone {
+        height: 100%;
+        display: none;
+      }
+	</style>
+</head>
+<body>
+  	<h1 id='pleasewait'>Please Wait...</h1>
+	<inum-telephone id="telephone1"></inum-telephone>
+</body>
+</html>
\ No newline at end of file

src/plugins/ofmeet/src/inum/index.js

+
+var dialer = null;
+var offHook = false;
+var conn = null;
+var audioChannelId = null;
+var mixerId = null;
+var cleared = false;
+var ringtone = null;
+var domain = urlParam("domain");
+var username = urlParam("username");
+var password = urlParam("password");
+
+window.addEventListener("unload", function () 
+{
+	if (conn && mixerId && audioChannelId) conn.inum.expireWebrtcDevice(mixerId, audioChannelId);
+	if (conn) conn.disconnect();
+});
+                
+window.addEventListener("load", function()
+{
+	dialer = document.querySelector("inum-telephone");
+
+	dialer.addEventListener('Telephone.Dialer.Button', function (event)
+	{
+		//console.log("Telephone.Dialer.Button", event, dialer);
+
+		if (event.detail.label == "Call")
+			telephoneAction({action: "dial", destination: event.detail.number});
+
+		else if (dialer.call) {
+			telephoneAction({action: "hangup", call_id: dialer.call.id});
+		}
+	});
+
+	dialer.addEventListener('Telephone.Dialer.Number', function (event)
+	{
+		console.log("Telephone.Dialer.Number", event);
+		//telephoneAction({action: "dial", call_id: event.detail.number});						
+	});
+
+	dialer.addEventListener('Telephone.Dialer.Press', function (event)
+	{
+		//console.log("Telephone.Dialer.Press", event);	
+	});
+
+	dialer.addEventListener('Telephone.Dialer.Action', function (event)
+	{
+		console.log("Telephone.Dialer.Action", event);
+
+		if (event.detail.action == 'end') 	telephoneAction({action: "hangup", call_id: event.detail.call.id});
+		if (event.detail.action == 'hold') 	telephoneAction({action: "hold", call_id: event.detail.call.id});
+		if (event.detail.action == 'unhold') 	telephoneAction({action: "join", mixer: event.detail.call.mixer});
+				
+		if ("#*0123456789".indexOf(event.detail.action) > -1)
+		{
+			telephoneAction({action: "dtmf", tone: event.detail.action});
+		}		
+	});
+	
+	$(document).bind('ofmeet.connected', function (event, connection)
+	{
+		console.log("ofmeet connected", connection);
+		
+		ofmeet.visible(false);		
+		connection.inum.createWebrtcDevice();
+		conn = connection;
+	});
+	
+	$(document).bind('inum.offered', function (event, confId, audioId)
+	{
+		console.log("inum.offered", confId, audioId);
+		audioChannelId = audioId;
+		mixerId = confId;
+		
+		$("inum-telephone").css("display", "block");
+		$('#pleasewait').css("display", "none");
+	});
+
+	$(document).bind('inum.streamadded', function (event, confId, audioId, data)
+	{
+		console.log("inum.streamadded", confId, audioId, data);
+	});
+
+	$(document).bind('inum.delivered', function (event, confId, audioId)
+	{
+		console.log("inum.delivered", confId, audioId);
+	});
+	
+	$(document).bind('inum.cleared', function(event, callId)
+	{
+		console.log("inum.cleared", callId);	
+	});	
+
+	$(document).bind('inum.dialled', function (event, confId, to, callId)
+	{
+		console.log("inum.dialled", confId, to, callId);
+		
+		dialer.call = {id: callId, mixer: confId, to: to}		
+		dialer.setLabel("Hangup");
+	});
+
+
+	$(document).bind('inum.answered', function(event, callId, callerId, calledId)
+	{
+		console.log("inum.answered", callId, callerId, calledId);
+		dialer.setState("active");
+		stopTone();
+	});
+	
+	
+	$(document).bind('inum.hangup', function(event, callId, callerId, calledId)
+	{
+		console.log("inum.hangup", callId, callerId, calledId);
+		
+		dialer.setLabel("Call");
+		dialer.setState("inactive");				
+		dialer.call = null
+		stopTone();		
+	});
+
+
+	$(document).bind('ofmeet.ready', function ()
+	{
+		console.log("ofmeet.ready");
+		ofmeet.connect();
+	});	
+		
+	ofmeet.ready(username, password);	
+})
+
+
+function urlParam(name)
+{
+	var results = new RegExp('[\\?&]' + name + '=([^&#]*)').exec(window.location.href);
+	if (!results) { return undefined; }
+	return unescape(results[1] || undefined);
+};
+
+function telephoneAction(request)
+{
+	console.log("telephoneAction", request);
+	
+	if (request.action == "dial")
+	{
+		conn.inum.dial(mixerId, domain ? "sip:" + request.destination + "@" + domain : request.destination);
+		startTone("ringback-uk");
+	}
+	
+	if (request.action == "hangup")
+	{
+		conn.inum.hangup(request.call_id);	
+		stopTone();
+	}
+	
+	if (request.action == "dtmf") conn.inum.sendTones(request.tone);		
+}
+
+function startTone(name)
+{
+	if (!ringtone)
+	{
+		ringtone = new Audio();
+		ringtone.loop = true;
+		ringtone.src = "ringtones/" + name + ".mp3";
+		ringtone.play();
+	}
+}
+
+function stopTone()
+{
+	if (ringtone)
+	{
+		ringtone.pause();
+		ringtone = null;
+	}
+}

src/plugins/ofmeet/src/inum/ui-telephone.html

+<html>
+  <template id="dialerTemplate">
+    <style>
+		article, aside, details, figcaption, figure, footer, header, hgroup, nav, section {
+		  display: block; }
+
+		audio, canvas, video {
+		  display: inline-block;
+		  *display: inline;
+		  *zoom: 1; }
+
+		audio:not([controls]) {
+		  display: none; }
+
+		[hidden] {
+		  display: none; }
+
+		html {
+		  font-size: 100%;
+		  -webkit-text-size-adjust: 100%;
+		  -ms-text-size-adjust: 100%; }
+
+		html, button, input, select, textarea {
+		  font-family: sans-serif;
+		  color: #222222; }
+
+		body {
+		  margin: 0;
+		  font-size: 1em;
+		  overflow: hidden;
+		  background: #959595;
+		  line-height: 1.4; }
+
+		a {
+		  color: #0000ee; }
+
+		a:visited {
+		  color: #551a8b; }
+
+		a:hover {
+		  color: #0066ee; }
+
+		a:focus {
+		  outline: thin dotted; }
+
+		a:hover, a:active {
+		  outline: 0; }
+
+		abbr[title] {
+		  border-bottom: 1px dotted; }
+
+		b, strong {
+		  font-weight: bold; }
+
+		blockquote {
+		  margin: 1em 40px; }
+
+		dfn {
+		  font-style: italic; }
+
+		hr {
+		  display: block;
+		  height: 1px;
+		  border: 0;
+		  border-top: 1px solid #cccccc;
+		  margin: 1em 0;
+		  padding: 0; }
+
+		ins {
+		  background: #ffff99;
+		  color: black;
+		  text-decoration: none; }
+
+		mark {
+		  background: yellow;
+		  color: black;
+		  font-style: italic;
+		  font-weight: bold; }
+
+		pre, code, kbd, samp {
+		  font-family: monospace, serif;
+		  _font-family: "courier new", monospace;
+		  font-size: 1em; }
+
+		pre {
+		  white-space: pre-wrap;
+		  word-wrap: break-word; }
+
+		q {
+		  quotes: none; }
+
+		q:before, q:after {
+		  content: none; }
+
+		small {
+		  font-size: 85%; }
+
+		sub, sup {
+		  font-size: 75%;
+		  line-height: 0;
+		  position: relative;
+		  vertical-align: baseline; }
+
+		sup {
+		  top: -0.5em; }
+
+		sub {
+		  bottom: -0.25em; }
+
+		ul, ol {
+		  margin: 1em 0;
+		  padding: 0 0 0 40px; }
+
+		dd {
+		  margin: 0 0 0 40px; }
+
+		nav ul, nav ol {
+		  list-style: none;
+		  list-style-image: none;
+		  margin: 0;
+		  padding: 0; }
+
+		img {
+		  border: 0;
+		  -ms-interpolation-mode: bicubic;
+		  vertical-align: middle; }
+
+		svg:not(:root) {
+		  overflow: hidden; }
+
+		figure {
+		  margin: 0; }
+
+		form {
+		  margin: 0; }
+
+		fieldset {
+		  border: 0;
+		  margin: 0;
+		  padding: 0; }
+
+		label {
+		  cursor: pointer; }
+
+		legend {
+		  border: 0;
+		  *margin-left: -7px;
+		  padding: 0;
+		  white-space: normal; }
+
+		button, input, select, textarea {
+		  font-size: 100%;
+		  margin: 0;
+		  vertical-align: baseline;
+		  *vertical-align: middle; }
+
+		button, input {
+		  line-height: normal; }
+
+		button, input[type="button"], input[type="reset"], input[type="submit"] {
+		  cursor: pointer;
+		  -webkit-appearance: button;
+		  *overflow: visible; }
+
+		button[disabled], input[disabled] {
+		  cursor: default; }
+
+		input[type="checkbox"], input[type="radio"] {
+		  box-sizing: border-box;
+		  padding: 0;
+		  *width: 13px;
+		  *height: 13px; }
+
+		input[type="search"] {
+		  -webkit-appearance: textfield;
+		  -moz-box-sizing: content-box;
+		  -webkit-box-sizing: content-box;
+		  box-sizing: content-box; }
+
+		input[type="search"]::-webkit-search-decoration, input[type="search"]::-webkit-search-cancel-button {
+		  -webkit-appearance: none; }
+
+		button::-moz-focus-inner, input::-moz-focus-inner {
+		  border: 0;
+		  padding: 0; }
+
+		textarea {
+		  overflow: auto;
+		  vertical-align: top;
+		  resize: vertical; }
+
+		input:invalid, textarea:invalid {
+		  background-color: #f0dddd; }
+
+		table {
+		  border-collapse: collapse;
+		  border-spacing: 0; }
+
+		td {
+		  vertical-align: top; }
+
+		.clearfix:before, .clearfix:after {
+		  content: "\0020";
+		  display: block;
+		  height: 0;
+		  visibility: hidden; }
+
+		.clearfix:after {
+		  clear: both; }
+
+		.clearfix {
+		  zoom: 1; }
+
+		.dialerwrapper {
+		  width: 280px;
+		  height: 350px;
+		  background-color: #cccccc; }
+		  .dialerwrapper .numberEntry {
+		   font-family: sans-serif;
+			width: 100%;
+			height: 15%;
+			text-align: center;
+			text-shadow: 1px 1px 0 #555555;
+			font-size: 2em;
+			color: white;
+			outline: 0;
+			border: 0;
+			background: #959595;
+			background: -moz-linear-gradient(top, #959595 50%, #767676 50%, #565656 100%);
+			background: -webkit-gradient(linear, left top, left bottom, color-stop(50%, #959595), color-stop(50%, #767676), color-stop(100%, #565656));
+			background: -webkit-linear-gradient(top, #959595 50%, #767676 50%, #565656 100%);
+			background: -o-linear-gradient(top, #959595 50%, #767676 50%, #565656 100%);
+			background: -ms-linear-gradient(top, #959595 50%, #767676 50%, #565656 100%);
+			background: linear-gradient(top, #959595 50%, #767676 50%, #565656 100%);
+			padding: 0;
+			margin: 0;
+			border-top: 1px solid #777777; }
+			.dialerwrapper .numberEntry:focus {
+			  outline: 0; }
+		  .dialerwrapper #dialpad {
+			width: 100%;
+			height: 100%;
+			list-style: none;
+			margin: 0;
+			padding: 0; }
+			.dialerwrapper #dialpad li {
+			  width: inherit;
+			  height: 21.25%;
+			  white-space: nowrap;
+			  font-size: 0;
+			  margin: 0;
+			  padding: 0; }
+			.dialerwrapper #dialpad button {
+			  display: inline-block;
+			  vertical-align: top;
+			  width: 33.3%;
+			  height: 100%;
+			  background: #eeeeee;
+			  font-size: 20px;
+			  text-align: center;
+			  outline: 0;
+			  border-top: 1px solid white;
+			  border-right: 1px solid white;
+			  border-bottom: 1px solid #c7c7c7;
+			  border-left: 1px solid #c7c7c7;
+			  border-radius: 0;
+			  margin: 0;
+			  padding: 0;
+			  color: #555555;
+			  vertical-align: middle; }
+			  .dialerwrapper #dialpad button:hover {
+				background-color: #cecece; }
+			  .dialerwrapper #dialpad button p {
+				width: 100%;
+				display: inline-table;
+				font-size: 1.2em;
+				font-weight: 700;
+				margin: 0; }
+			  .dialerwrapper #dialpad button div {
+				text-transform: uppercase;
+				font-size: 0.6em; }
+		  .dialerwrapper #actions nav {
+			position: relative; }
+		  .dialerwrapper #actions a {
+			width: 33.3%; }
+
+		.close_dialer {
+		  background-color: #555555;
+		  height: 25px;
+		  width: 100%;
+		  display: block;
+		  position: relative; }
+
+		.cancel_dialer {
+		  position: absolute;
+		  top: 4px;
+		  right: 10px;
+		  padding: 3px;
+		  line-height: 9px;
+		  display: block;
+		  color: white;
+		  border: 1px solid white;
+		  background-color: #666666; }
+		  .cancel:hover {
+			color: white;
+			background-color: #bb0000;
+			cursor: pointer; }
+
+		  .call {
+			cursor: hand;
+			font-family: sans-serif;
+			width: 280px;
+		  }
+
+		#screen {
+		  position: relative;
+  		  -webkit-transition: top 1s;
+		  overflow: hidden;
+		  width: 280px;
+		  padding: 15px 15px 0 15px;
+		  z-index: 99; }
+
+		  #screen.candybarVisible {
+			top: 100px; }
+
+		  #screen header {
+			background-color: #555555; }
+		  #screen header, #screen footer {
+			height: 40px;
+			width: 100%;
+			padding: 10px 0;
+			display: block; }
+			#screen header nav, #screen footer nav {
+			  width: 100%;
+			  display: table;
+			  margin: 0 auto;
+			  border: 1px solid #222222;
+			  border-radius: 10px; }
+			  #screen header nav a, #screen footer nav a {
+				display: table-cell;
+				width: 50%;
+				color: #eeeeee;
+				font-weight: 900;
+				text-decoration: none;
+				text-align: center;
+				text-shadow: 1px 1px 0 #222222;
+				letter-spacing: 0.3px;
+				padding: 10px 0;
+				border-left: 1px solid #222222;
+				border-right: 1px solid #777777;
+				background: #888888;
+				background: -moz-linear-gradient(top, #888888 0%, #555555 100%) repeat-x, #888888;
+				background: -webkit-gradient(linear, left top, left bottom, color-stop(0%, #888888) repeat-x, color-stop(100%, #555555)), #888888;
+				background: -webkit-linear-gradient(top, #888888 0%, #555555 100%) repeat-x, #888888;
+				background: -o-linear-gradient(top, #888888 0%, #555555 100%) repeat-x, #888888;
+				background: -ms-linear-gradient(top, #888888 0%, #555555 100%) repeat-x, #888888;
+				background: linear-gradient(top, #888888 0%, #555555 100%) repeat-x, #888888;
+				-moz-transition: background 1s linear;
+				-webkit-transition: all 0.3s linear 0;
+				-moz-transition-property: all;
+				-moz-transition-duration: 1s;
+				-moz-transition-timing-function: linear;
+				-moz-transition-delay: linear; }
+				#screen header nav a:first-child, #screen footer nav a:first-child {
+				  border-left: 0;
+				  border-top-left-radius: 10px;
+				  border-bottom-left-radius: 10px; }
+				#screen header nav a:last-child, #screen footer nav a:last-child {
+				  margin: 0;
+				  border-right: 0;
+				  border-top-right-radius: 10px;
+				  border-bottom-right-radius: 10px; }
+				#screen header nav a:hover, #screen footer nav a:hover {
+				  background-position: 0 15px;
+				  cursor: pointer; }
+
+		#login #screen {
+		  padding: 0;
+		  margin: 0 10px 10px 10px;
+		  position: relative; }
+		  #login #screen:after {
+			content: "";
+			width: 280px;
+			height: 1px;
+			display: block;
+			position: absolute;
+			left: 1px;
+			bottom: 0px;
+			background: #cccccc;
+			z-index: 200000000; }
+		#login footer {
+		  display: none; }
+		#login .dialerwrapper {
+		  background-color: white;
+		  border-right: 1px solid #cccccc; }
+		#login .numberEntry {
+		  border-left: 0px solid #dddddd;
+		  margin-left: 1px;
+		  margin-right: 2px;
+		  padding-top: 3px;
+		  border-top: 1px solid #dddddd;
+		  background-image: #eeeeee;
+		  background-image: -moz-linear-gradient(top, #eeeeee, #dddddd);
+		  background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, #eeeeee), color-stop(1, #dddddd));
+		  -ms-filter: progid:DXImageTransform.Microsoft.gradient(startColorStr='$top', EndColorStr='$bottom');
+		  color: #555555;
+		  text-shadow: white 0 1px 0px;
+		  -ms-filter: progid:DXImageTransform.Microsoft.Shadow(Color=white,Direction=135,Strength=0); }
+
+		 body {
+		  font-family: sans-serif;
+		 }
+
+		#callStatus {
+		  position: fixed;
+		  top: -120px;
+		  left: 0px;
+		  -webkit-transition: background-color 1s;
+		  -webkit-transition: top 1s;
+		  width: 100%;
+		  height: 80px;
+		  padding: 10px;
+		  z-index: 1000; }
+		  #callStatus.visible {
+			top: 0px; }
+		  #callStatus.havatar .callActions {
+			left: 100px; }
+		  #callStatus.havatar .caller {
+			margin-left: 90px; }
+		  #callStatus.incoming {
+			background-color: #41ade0;
+			background-image: rgba(255, 255, 255, 0.3);
+			background-image: -moz-linear-gradient(top, rgba(255, 255, 255, 0.3), rgba(50, 50, 50, 0.1));
+			background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, rgba(255, 255, 255, 0.3)), color-stop(1, rgba(50, 50, 50, 0.1)));
+			-ms-filter: progid:DXImageTransform.Microsoft.gradient(startColorStr='$top', EndColorStr='$bottom');
+			border-top: 2px solid #63cfff;
+			border-bottom: 2px solid #00699c;
+			-webkit-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-moz-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-ms-filter: progid:DXImageTransform.Microsoft.Shadow(Color=rgba(0, 0, 0, 0.2),Direction=135,Strength=5); }
+			#callStatus.incoming .callTime {
+			  display: none; }
+			#callStatus.incoming .callerName:before {
+			  content: "Incoming: "; }
+		  #callStatus.waiting {
+			background-color: #f47820;
+			background-image: rgba(255, 255, 255, 0.3);
+			background-image: -moz-linear-gradient(top, rgba(255, 255, 255, 0.3), rgba(50, 50, 50, 0.1));
+			background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, rgba(255, 255, 255, 0.3)), color-stop(1, rgba(50, 50, 50, 0.1)));
+			-ms-filter: progid:DXImageTransform.Microsoft.gradient(startColorStr='$top', EndColorStr='$bottom');
+			border-top: 2px solid #ff9a42;
+			border-bottom: 2px solid #b03400;
+			-webkit-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-moz-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-ms-filter: progid:DXImageTransform.Microsoft.Shadow(Color=rgba(0, 0, 0, 0.2),Direction=135,Strength=5); }
+			#callStatus.waiting .spinner div {
+			  background-color: white; }
+		  #callStatus.calling {
+			background-color: #41ade0;
+			background-image: rgba(255, 255, 255, 0.3);
+			background-image: -moz-linear-gradient(top, rgba(255, 255, 255, 0.3), rgba(50, 50, 50, 0.1));
+			background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, rgba(255, 255, 255, 0.3)), color-stop(1, rgba(50, 50, 50, 0.1)));
+			-ms-filter: progid:DXImageTransform.Microsoft.gradient(startColorStr='$top', EndColorStr='$bottom');
+			border-top: 2px solid #63cfff;
+			border-bottom: 2px solid #00699c;
+			-webkit-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-moz-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-ms-filter: progid:DXImageTransform.Microsoft.Shadow(Color=rgba(0, 0, 0, 0.2),Direction=135,Strength=5); }
+			#callStatus.calling .callTime {
+			  display: none; }
+			#callStatus.calling .callerName:before {
+			  content: "Calling: "; }
+		  #callStatus.active {
+			background-color: #77a803;
+			background-image: rgba(255, 255, 255, 0.3);
+			background-image: -moz-linear-gradient(top, rgba(255, 255, 255, 0.3), rgba(50, 50, 50, 0.1));
+			background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, rgba(255, 255, 255, 0.3)), color-stop(1, rgba(50, 50, 50, 0.1)));
+			-ms-filter: progid:DXImageTransform.Microsoft.gradient(startColorStr='$top', EndColorStr='$bottom');
+			border-top: 2px solid #99ca25;
+			border-bottom: 2px solid #336400;
+			-webkit-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-moz-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-ms-filter: progid:DXImageTransform.Microsoft.Shadow(Color=rgba(0, 0, 0, 0.2),Direction=135,Strength=5); }
+			#callStatus.active .callerName:before {
+			  content: "On Call: "; }
+		  #callStatus.busy {
+			background-color: #bbbbbb;
+			background-image: rgba(255, 255, 255, 0.3);
+			background-image: -moz-linear-gradient(top, rgba(255, 255, 255, 0.3), rgba(50, 50, 50, 0.1));
+			background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, rgba(255, 255, 255, 0.3)), color-stop(1, rgba(50, 50, 50, 0.1)));
+			-ms-filter: progid:DXImageTransform.Microsoft.gradient(startColorStr='$top', EndColorStr='$bottom');
+			border-top: 2px solid white;
+			border-bottom: 2px solid #bbbbbb;
+			-webkit-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-moz-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-ms-filter: progid:DXImageTransform.Microsoft.Shadow(Color=rgba(0, 0, 0, 0.2),Direction=135,Strength=5); }
+			#callStatus.busy .callerName:before {
+			  content: "Busy: "; }
+		  #callStatus.muted {
+			background-color: #bbbb00;
+			background-image: rgba(255, 255, 255, 0.3);
+			background-image: -moz-linear-gradient(top, rgba(255, 255, 255, 0.3), rgba(50, 50, 50, 0.1));
+			background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, rgba(255, 255, 255, 0.3)), color-stop(1, rgba(50, 50, 50, 0.1)));
+			-ms-filter: progid:DXImageTransform.Microsoft.gradient(startColorStr='$top', EndColorStr='$bottom');
+			border-top: 2px solid white;
+			border-bottom: 2px solid #bbbbbb;
+			-webkit-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-moz-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-ms-filter: progid:DXImageTransform.Microsoft.Shadow(Color=rgba(0, 0, 0, 0.2),Direction=135,Strength=5); }
+			#callStatus.muted .callerName:before {
+			  content: "Muted: "; }
+		  #callStatus.held {
+			background-color: #ff3434;
+			background-image: rgba(255, 255, 255, 0.3);
+			background-image: -moz-linear-gradient(top, rgba(255, 255, 255, 0.3), rgba(50, 50, 50, 0.1));
+			background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, rgba(255, 255, 255, 0.3)), color-stop(1, rgba(50, 50, 50, 0.1)));
+			-ms-filter: progid:DXImageTransform.Microsoft.gradient(startColorStr='$top', EndColorStr='$bottom');
+			border-top: 2px solid white;
+			border-bottom: 2px solid #bbbbbb;
+			-webkit-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-moz-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-ms-filter: progid:DXImageTransform.Microsoft.Shadow(Color=rgba(0, 0, 0, 0.2),Direction=135,Strength=5); }
+			#callStatus.held .callerName:before {
+			  content: "Held: "; }
+		  #callStatus.conferenced {
+			background-color: #74e0ff;
+			background-image: rgba(255, 255, 255, 0.3);
+			background-image: -moz-linear-gradient(top, rgba(255, 255, 255, 0.3), rgba(50, 50, 50, 0.1));
+			background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, rgba(255, 255, 255, 0.3)), color-stop(1, rgba(50, 50, 50, 0.1)));
+			-ms-filter: progid:DXImageTransform.Microsoft.gradient(startColorStr='$top', EndColorStr='$bottom');
+			border-top: 2px solid white;
+			border-bottom: 2px solid #bbbbbb;
+			-webkit-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-moz-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-ms-filter: progid:DXImageTransform.Microsoft.Shadow(Color=rgba(0, 0, 0, 0.2),Direction=135,Strength=5); }
+			#callStatus.conferenced .callerName:before {
+			  content: "Conferenced: "; }
+		  #callStatus.inactive {
+			background-color: white;
+			background-image: rgba(255, 255, 255, 0.3);
+			background-image: -moz-linear-gradient(top, rgba(255, 255, 255, 0.3), rgba(50, 50, 50, 0.1));
+			background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, rgba(255, 255, 255, 0.3)), color-stop(1, rgba(50, 50, 50, 0.1)));
+			-ms-filter: progid:DXImageTransform.Microsoft.gradient(startColorStr='$top', EndColorStr='$bottom');
+			border-top: 2px solid white;
+			border-bottom: 2px solid #bbbbbb;
+			-webkit-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-moz-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-ms-filter: progid:DXImageTransform.Microsoft.Shadow(Color=rgba(0, 0, 0, 0.2),Direction=135,Strength=5); }
+		  #callStatus.remote {
+			background-color: #74e0ff;
+			background-image: rgba(255, 255, 255, 0.3);
+			background-image: -moz-linear-gradient(top, rgba(255, 255, 255, 0.3), rgba(50, 50, 50, 0.1));
+			background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, rgba(255, 255, 255, 0.3)), color-stop(1, rgba(50, 50, 50, 0.1)));
+			-ms-filter: progid:DXImageTransform.Microsoft.gradient(startColorStr='$top', EndColorStr='$bottom');
+			border-top: 2px solid #96ffff;
+			border-bottom: 2px solid #309cbb;
+			-webkit-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-moz-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-ms-filter: progid:DXImageTransform.Microsoft.Shadow(Color=rgba(0, 0, 0, 0.2),Direction=135,Strength=5); }
+			#callStatus.remote .callTime {
+			  display: none; }
+		  #callStatus.ending {
+			background-color: #bbbbbb;
+			background-image: rgba(255, 255, 255, 0.3);
+			background-image: -moz-linear-gradient(top, rgba(255, 255, 255, 0.3), rgba(50, 50, 50, 0.1));
+			background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, rgba(255, 255, 255, 0.3)), color-stop(1, rgba(50, 50, 50, 0.1)));
+			-ms-filter: progid:DXImageTransform.Microsoft.gradient(startColorStr='$top', EndColorStr='$bottom');
+			border-top: 2px solid #dddddd;
+			border-bottom: 2px solid #777777;
+			-webkit-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-moz-box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			box-shadow: rgba(0, 0, 0, 0.2) 0 3px 5px;
+			-ms-filter: progid:DXImageTransform.Microsoft.Shadow(Color=rgba(0, 0, 0, 0.2),Direction=135,Strength=5); }
+			#callStatus.ending .callerName:before {
+			  content: "Ending: "; }
+		  #callStatus .callActions {
+			position: absolute;
+			left: 10px;
+			top: 50px;
+			display: block;
+			width: 100%; }
+		  #callStatus nav {
+			float: left; }
+		  #callStatus button {
+			min-width: auto;
+			background-color: rgba(255, 255, 255, 0.3);
+			background-image: rgba(255, 255, 255, 0.5);
+			background-image: -moz-linear-gradient(top, rgba(255, 255, 255, 0.5), rgba(0, 0, 0, 0.1));
+			background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, rgba(255, 255, 255, 0.5)), color-stop(1, rgba(0, 0, 0, 0.1)));
+			-ms-filter: progid:DXImageTransform.Microsoft.gradient(startColorStr='$top', EndColorStr='$bottom');
+			border-top: 1px solid rgba(255, 255, 255, 0.6);
+			border-bottom: 1px solid rgba(0, 0, 0, 0.1);
+			border-left: 1px solid rgba(255, 255, 255, 0.2);
+			border-right: 1px solid rgba(255, 255, 255, 0.2);
+			width: 100px;
+			margin-right: 10px;
+			font-size: 16px;
+			color: rgba(0, 0, 0, 0.75);
+			text-shadow: rgba(255, 255, 255, 0.5) 0 1px 0px;
+			-ms-filter: progid:DXImageTransform.Microsoft.Shadow(Color=rgba(255, 255, 255, 0.5),Direction=135,Strength=0);
+			float: left;
+			-webkit-box-shadow: rgba(0, 0, 0, 0.3) 0 1px 3px;
+			-moz-box-shadow: rgba(0, 0, 0, 0.3) 0 1px 3px;
+			box-shadow: rgba(0, 0, 0, 0.3) 0 1px 3px;
+			-ms-filter: progid:DXImageTransform.Microsoft.Shadow(Color=rgba(0, 0, 0, 0.3),Direction=135,Strength=3); }
+			#callStatus button:hover {
+			  background-color: rgba(255, 255, 255, 0.4); }
+			#callStatus button:active {
+			  box-shadow: inset rgba(0, 0, 0, 0.2) 0 1px 3px;
+			  -moz-box-shadow: inset rgba(0, 0, 0, 0.2) 0 1px 3px;
+			  -webkit-box-shadow: inset rgba(0, 0, 0, 0.2) 0 1px 3px;
+			  padding-top: 11px;
+			  padding-bottom: 9px;
+			  border-bottom: 1px solid white;
+			  border-top: 1px solid rgba(0, 0, 0, 0.2); }
+		  #callStatus .callerAvatar {
+			float: left;
+			width: 65px;
+			height: 65px;
+			border: 5px solid #eeeeee;
+			margin-right: 10px; }
+		  #callStatus .callerName, #callStatus .callTime {
+			font-weight: bold;
+			color: white;
+			text-shadow: rgba(0, 0, 0, 0.7) 0 1px 0px;
+			-ms-filter: progid:DXImageTransform.Microsoft.Shadow(Color=rgba(0, 0, 0, 0.7),Direction=135,Strength=0);
+			line-height: 1; }
+		  #callStatus .caller {
+			margin-top: 0px;
+			margin-right: 30px;
+			margin-left: 0px;
+			font-size: 20px;
+			padding-bottom: 0px;
+			border-bottom: 2px groove rgba(255, 255, 255, 0.4); }
+		  #callStatus .callerName {
+			display: inline; }
+		  #callStatus .callerNumber {
+			display: inline;
+			margin-left: 10px; }
+		  #callStatus .callTime {
+			position: absolute;
+			top: 12px;
+			right: 40px;
+			font-size: 20px;
+			margin: 0; }
+
+		button.hidden {
+			display: none;
+		}
+
+
+    </style>
+	 <div id="callStatus">
+		  <h1 class="caller"><span class="callerName"></span><span class="callerNumber"></span></h1>
+		  <h2 class="callTime"></h2>
+		  <div class="callActions">
+			<button data-value="end" class="hidden end">End</button>
+			<button data-value="hold" class="hidden hold">Hold</button>
+			<button data-value="unhold" class="hidden unhold">Unhold</button>
+			<button class="hidden answer">Answer</button>
+			<button class="hidden ignore">Ignore</button>
+			<button class="hidden end">End</button>
+			<button class="hidden cancel">Cancel</button>
+			<button class="hidden mute">Mute</button>
+			<button class="hidden redirect">Redirect</button>
+			<button class="hidden record">Record</button>
+			<button class="hidden onspeaker">SpkrOn</button>
+			<button class="hidden offspeaker">SpkrOff</button>
+			<button class="hidden speakertalk">MicOn</button>
+			<button class="hidden speakeruntalk">MicOff</button>
+			<button class="hidden say">Say</button>
+			<button class="hidden pause">Pause</button>
+			<button class="hidden resume">Resume</button>
+		  </div>
+	</div>
+	<div id="screen">
+	  <div class="dialerwrapper">
+		<div class="numberEntry"></div>
+		<ul id="dialpad">
+		  <li>
+			<button data-value="1">
+			  <p>1</p>
+			  <div>&nbsp;</div>
+			</button>
+			<button data-value="2">
+			  <p>2</p>
+			  <div>abc</div>
+			</button>
+			<button data-value="3">
+			  <p>3</p>
+			  <div>def</div>
+			</button>
+		  </li>
+		  <li>
+			<button data-value="4">
+			  <p>4</p>
+			  <div>ghi</div>
+			</button>
+			<button data-value="5">
+			  <p>5</p>
+			  <div>jki</div>
+			</button>
+			<button data-value="6">
+			  <p>6</p>
+			  <div>mno</div>
+			</button>
+		  </li>
+		  <li>
+			<button data-value="7">
+			  <p>7</p>
+			  <div>pqrs</div>
+			</button>
+			<button data-value="8">
+			  <p>8</p>
+			  <div>tuv</div>
+			</button>
+			<button data-value="9">
+			  <p>9</p>
+			  <div>wxyz</div>
+			</button>
+		  </li>
+		  <li>
+			<button data-value="#">
+			  <p>#</p>
+			  <div>&nbsp;</div>
+			</button>
+			<button data-value="0">
+			  <p>0</p>
+			  <div>abc</div>
+			</button>
+			<button data-value="*">
+			  <p>*</p>
+			  <div>&nbsp;</div>
+			</button>
+		  </li>
+		</ul>
+	  </div>
+	  <footer>
+		<nav id="actions"><a id="call_button" class="call">Call</a></nav>
+	  </footer>
+	</div>
+   </div>
+  </template>
+  <script src="att.phonenumber.js"></script>
+  <script src="ui-telephone.js"></script>
+</html>
\ No newline at end of file

src/plugins/ofmeet/src/inum/ui-telephone.js

+(function () {
+	var importDoc = document.currentScript.ownerDocument;
+	var proto = Object.create( HTMLElement.prototype );
+	var phoney = window.ATT && window.ATT.phoneNumber || window.phoney;
+		
+	proto.createdCallback = function() {
+		var that = this;
+		var template = importDoc.querySelector('#dialerTemplate');		
+		this.readAttributes();
+
+		this.shadow = this.createShadowRoot();
+		this.shadow.appendChild(template.content.cloneNode(true));
+		
+		this.addClickHandlers();
+		this.number = '';
+		this.numberField = this.shadow.querySelector('.numberEntry');
+		this.callStatus = this.shadow.querySelector('#callStatus');
+		this.dialpad = this.shadow.querySelector('#screen');
+		
+		
+	    	this.button = this.shadow.querySelector('.call');  		
+
+		this.boundKeyHandler = function () 
+		{
+			that.handleKeyDown.apply(that, arguments);
+		};		
+    		document.addEventListener('keydown', this.boundKeyHandler, true);  		
+	};
+
+	proto.readAttributes = function() {
+
+	};
+
+	proto.attributeChangedCallback = function( attrName, oldVal, newVal ) {
+
+	};
+
+	proto.addClickHandlers = function () 
+	{
+	    var self = this;
+	    var buttons = this.shadow.querySelectorAll('button');
+	    var callButton = this.shadow.querySelector('.call');   
+
+	    Array.prototype.forEach.call(buttons, function (button) 
+	    {
+	      	button.addEventListener('click', function (e) 
+	      	{
+			var data = this.attributes['data-value'];
+			var value = data && data.nodeValue;
+
+			if (value)
+			{
+				if (value == 'del') {
+				  	self.removeLastNumber();
+				  	
+				} else if (self.call) {
+										
+					var myEvent = new CustomEvent("Telephone.Dialer.Action", {detail: {action: value, call: self.call}});
+					self.dispatchEvent(myEvent);					
+				
+				} else {
+				  	self.addNumber(value);
+				}
+			}
+			return false;
+	      }, true);
+	    });
+
+	    if (callButton) 
+	    {
+	      callButton.addEventListener('click', function () 
+	      {
+		var myEvent = new CustomEvent("Telephone.Dialer.Button", {detail: {number: self.getNumber(), label: callButton.innerHTML}});
+		self.dispatchEvent(myEvent);
+		
+	      }, false);
+	    }
+	};
+
+	proto.getNumber = function () 
+	{
+		return this.number;
+	};
+
+	proto.getLabel = function () 
+	{
+	    	return this.button.innerHTML;
+	};
+	
+	proto.setLabel = function (label) 
+	{
+	    	this.button.innerHTML = label
+	};	
+
+	proto.setNumber = function (number) 
+	{
+		var newNumber = phoney.parse(number);
+		var oldNumber = this.number;
+		var callable = phoney.getCallable(newNumber);
+		
+		this.number = newNumber;
+		this.numberField.innerHTML = phoney.stringify(this.number); 
+		
+		if (callable) 
+		{
+			var myEvent = new CustomEvent("Telephone.Dialer.Number", {detail: {number: callable}});
+			this.dispatchEvent(myEvent);
+		}
+	};
+
+	proto.clear = function () 
+	{
+		this.setNumber('');
+	};
+	
+	proto.addNumber = function (number) 
+	{
+		var newNumber = (this.getNumber() + '') + number;
+		var myEvent = new CustomEvent("Telephone.Dialer.Press", {detail: {number: number}});
+		this.dispatchEvent(myEvent);
+		this.setNumber(newNumber);
+	};
+
+	proto.removeLastNumber = function () 
+	{
+		this.setNumber(this.getNumber().slice(0, -1));
+	};
+
+    	proto.handleKeyDown = function(e)
+    	{
+	    var number, keyCode = e.which;
+
+	    if (keyCode >= 48 && keyCode <= 57) {
+	      number = keyCode - 48;
+	      this.addNumber(number + '');
+	    }
+
+	    if (keyCode === 8) {
+	      this.removeLastNumber();
+	      e.preventDefault();
+	    }
+
+	    if (keyCode === 13) {
+		var myEvent = new CustomEvent("Telephone.Dialer.Number", {detail: {number: this.getNumber()}});
+		this.dispatchEvent(myEvent);
+	    }    	
+    	}		
+
+	proto.startTimer = function () 
+	{
+		this.timerStartTime = Date.now();
+		this.timerStopped = false;
+		this.updateTimer();
+		return this;
+	};
+
+	proto.stopTimer = function () {
+		this.timerStopped = true;
+		return this;
+	};
+
+	proto.resetTimer = function () {
+		this.timerStopped = true;
+		this.setTimeInDom('0:00:00');
+		return this;
+	};
+
+	proto.updateTimer = function () 
+	{
+		if (this.timerStopped) return;
+
+		var diff = Date.now() - this.timerStartTime,
+		s = Math.floor(diff / 1000) % 60,
+		min = Math.floor((diff / 1000) / 60) % 60,
+		hr = Math.floor(((diff / 1000) / 60) / 60) % 60,
+		time = [hr, this.zeroPad(min), this.zeroPad(s)].join(':');
+
+		if (this.time !== time) {
+			this.time = time;
+			this.setTimeInDom(time);
+		}
+
+		setTimeout(this.updateTimer.bind(this), 100);
+	};
+
+	proto.setTimeInDom = function (timeString) {
+		if (!this.shadow) return;
+		this.shadow.querySelector('.callTime').innerHTML = timeString;
+	};
+
+	proto.zeroPad = function (num) {
+		return ((num + '').length === 1) ? '0' + num : num;
+	};
+	
+	proto.setState = function (state, number) 
+	{
+		var noRender = false;
+		var timer = false;
+		var self = this;
+		
+		this.shadow.querySelector('.callerNumber').innerHTML = number ? number : this.getNumber();			
+		
+		this.shadow.querySelector('button.end').classList.add('hidden');
+		this.shadow.querySelector('button.hold').classList.add('hidden');			
+		this.shadow.querySelector('button.unhold').classList.add('hidden');
+		
+		this.callStatus.classList.remove("active");
+		this.callStatus.classList.remove("inactive");		
+		this.callStatus.classList.remove("held");
+		this.callStatus.classList.remove("ending");		
+		
+		this.callStatus.classList.add(state);		
+
+		if (state == "active")
+		{
+			noRender = false;
+			timer = true;
+			this.shadow.querySelector('button.end').classList.remove('hidden');
+			this.shadow.querySelector('button.hold').classList.remove('hidden');						
+		}
+		
+		if (state == "held")
+		{
+			noRender = false;
+			timer = true;
+			this.shadow.querySelector('button.unhold').classList.remove('hidden');						
+		}
+		
+		if (state == "inactive")
+		{
+			noRender = true;
+			timer = false;			
+		}		
+		
+		if (noRender)
+		{
+			this.stopTimer();
+			this.callStatus.classList.add('ending');
+			
+			setTimeout(function () 
+			{
+				self.callStatus.classList.remove('visible');
+
+				setTimeout(function () 
+				{
+					self.callStatus.classList.remove('visible');
+					self.dialpad.classList.remove('candybarVisible');
+					//self.clearUser();
+				}, 1000);
+			}, 1000);
+			
+		} else {
+			this.callStatus.classList.add('visible');
+			this.dialpad.classList.add('candybarVisible');			
+			if (timer) this.startTimer(); 				
+		}		
+		      
+	}	
+	
+	document.registerElement( "inum-telephone", {
+		prototype: proto
+	});
+})(window);
\ No newline at end of file

src/plugins/ofmeet/src/libs/strophe/strophe.jingle.adapter.js

@@ -578,7 +578,7 @@ function setupRTC() {
             browser: 'chrome',
             getUserMedia: navigator.webkitGetUserMedia.bind(navigator),
             attachMediaStream: function (element, stream) {
-                element.attr('src', webkitURL.createObjectURL(stream));
+                element.attr('src', URL.createObjectURL(stream));
             },
             // DTLS should now be enabled by default but..
             pc_constraints: {'optional': [{'DtlsSrtpKeyAgreement': 'true'}]},

src/plugins/ofmeet/src/libs/strophe/strophe.jingle.js

@@ -3,7 +3,7 @@ Strophe.addConnectionPlugin('jingle', {
     connection: null,
     sessions: {},
     jid2session: {},
-    ice_config: {iceServers: []},
+    ice_config: config.iceServers ? config.iceServers : {'iceServers': [{ 'url': 'stun:stun.l.google.com:19302' }]},
     pc_constraints: {},
     media_constraints: {
         mandatory: {

src/plugins/ofmeet/src/libs/strophe/strophe.jingle.session.js

@@ -34,6 +34,10 @@ function JingleSession(me, sid, connection) {
     this.statsinterval = null;
 
     this.reason = null;
+    
+    this.relayHost = null;
+    this.relayLocalPort = null;
+    this.relayRemotePort = null;  
 
     this.wait = true;
     this.localStreamsSSRC = null;
@@ -54,6 +58,9 @@ JingleSession.prototype.initiate = function (peerjid, isInitiator) {
     this.hadstuncandidate = false;
     this.hadturncandidate = false;
     this.lasticecandidate = false;
+    this.relayHost = null;
+    this.relayLocalPort = null;
+    this.relayRemotePort = null;     
 
     this.peerconnection
         = new TraceablePeerConnection(
@@ -215,6 +222,7 @@ JingleSession.prototype.sendIceCandidate = function (candidate) {
                     // start 20ms callout
                     window.setTimeout(function () {
                         if (self.drip_container.length === 0) return;
+    			//console.log('sendIceCandidates timeout', self.usetrickle, self.usedrip, self.drip_container);                        
                         self.sendIceCandidates(self.drip_container);
                         self.drip_container = [];
                     }, 20);
@@ -223,7 +231,8 @@ JingleSession.prototype.sendIceCandidate = function (candidate) {
                 this.drip_container.push(candidate);
                 return;
             } else {
-                self.sendIceCandidate([candidate]);
+    		//console.log('sendIceCandidates single', self.usetrickle, self.usedrip, candidate);                 
+                self.sendIceCandidates([candidate]);
             }
         }
     } else {
@@ -286,6 +295,8 @@ JingleSession.prototype.sendIceCandidate = function (candidate) {
 
 JingleSession.prototype.sendIceCandidates = function (candidates) {
     console.log('sendIceCandidates', candidates);
+    var self = this; 
+    var relayDone = false;
     var cand = $iq({to: this.peerjid, type: 'set'})
         .c('jingle', {xmlns: 'urn:xmpp:jingle:1',
             action: 'transport-info',
@@ -301,8 +312,39 @@ JingleSession.prototype.sendIceCandidates = function (candidates) {
                 name: (cands[0].sdpMid? cands[0].sdpMid : mline.media)
             }).c('transport', ice);
             for (var i = 0; i < cands.length; i++) {
-                cand.c('candidate', SDPUtil.candidateToJingle(cands[i].candidate)).up();
+               cand.c('candidate', SDPUtil.candidateToJingle(cands[i].candidate)).up();
             }
+            
+            if (!self.relayDone)
+            {
+    		    console.log('sendIceCandidates: send jingle nodes request');            
+		    var iqRelay = $iq({type: "get", to: "relay." + self.connection.domain}).c('channel', {xmlns: "http://jabber.org/protocol/jinglenodes#channel", protocol: 'udp'});
+
+		    self.connection.sendIQ(iqRelay, function(response)
+		    {
+			if ($(response).attr('type') == "result")
+			{
+    		    		console.log('sendIceCandidates: jingle nodes response', response);  
+    		    		self.hadturncandidate = true;
+    		    		
+				$(response).find('channel').each(function() 
+				{
+					self.relayHost = $(this).attr('host');
+					self.relayLocalPort = $(this).attr('localport');
+					self.relayRemotePort = $(this).attr('remoteport');
+
+					var relayCandidate = "a=candidate:3707591233 1 udp 2113937151 " + self.relayHost + " " + self.relayRemotePort + " typ relay generation 0 ";
+
+					console.log("add JingleNodes candidate: " + self.relayHost + " " + self.relayLocalPort + " " + self.relayRemotePort); 
+					cand.c('candidate', SDPUtil.candidateToJingle(relayCandidate)).up();
+				});
+
+			}		
+		    }, function(err) {console.error("jingle nodes request error", err)});
+		    
+		    relayDone = true;		    
+	    }
+            
             // add fingerprint
             if (SDPUtil.find_line(this.localSDP.media[mid], 'a=fingerprint:', this.localSDP.session)) {
                 var tmp = SDPUtil.parse_fingerprint(SDPUtil.find_line(this.localSDP.media[mid], 'a=fingerprint:', this.localSDP.session));
@@ -318,6 +360,7 @@ JingleSession.prototype.sendIceCandidates = function (candidates) {
             cand.up(); // transport
             cand.up(); // content
         }
+	self.relayDone = relayDone;        
     }
     // might merge last-candidate notification into this, but it is called alot later. See webrtc issue #2340
     //console.log('was this the last candidate', this.lasticecandidate);
@@ -443,6 +486,13 @@ JingleSession.prototype.setRemoteDescription = function (elem, desctype) {
             this.remoteSDP.raw = this.remoteSDP.session + this.remoteSDP.media.join('');
         }
     }
+    
+    if (this.relayHost != null && this.relayLocalPort != null)
+    {
+	var candidate = new RTCIceCandidate({sdpMLineIndex: "0", candidate: "a=candidate:3707591233 1 udp 2113937151 " + this.relayHost + " " + this.relayLocalPort + " typ relay generation 0 "});
+	this.peerconnection.addIceCandidate(candidate);  
+	this.hadturncandidate = true;
+    }
     var remotedesc = new RTCSessionDescription({type: desctype, sdp: this.remoteSDP.raw});
 
     this.peerconnection.setRemoteDescription(remotedesc,