android {
    // [...]
    packagingOptions {
        pickFirst 'META-INF/LICENSE.txt'
        pickFirst 'META-INF/NOTICE.txt'
        pickFirst 'META-INF/INDEX.LIST'
    }
}

dependencies {
    // [...]
    compile 'eu.hgross:blaubot-android:2+'
    compile 'eu.hgross:blaubot-websockets:2+' // optional
}
   

       
<!-- NFC -->
<uses-permission android:name="android.permission.NFC" />
<uses-permission android:name="android.permission.VIBRATE"/>

<!--  Multicast- and Bonjour-Beacon  -->
<uses-permission android:name="android.permission.CHANGE_WIFI_MULTICAST_STATE" />

<!-- WIFI Direct, Ethernet, Multicast- and Bonjour-Beacon -->
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

<!-- Bluetooth -->
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_PRIVILEGED" />
<uses-permission android:name="android.permission.INTERNET" />
   

       
// Generate a UUID that is unique for your application
// see http://www.famkruithof.net/uuid/uuidgen
final UUID APP_UUID = UUID.fromString("ec127529-2e9c-4046-a5a5-144feb30465f");

// Now create Blaubot using an existing wifi network and multicasts to discover
Blaubot blaubot = BlaubotFactory.createEthernetBlaubot(APP_UUID);
// or RFCOMM-Bluetooth (Android) for the network and discovery
BlaubotAndroid blaubot = BlaubotAndroidFactory.createBluetoothBlaubot(APP_UUID);
// or RFCOMM-Bluetooth (Android) for the network and NFC-Interactions for discovery
BlaubotAndroid blaubot = BlaubotAndroidFactory.createBluetoothBlaubotWithNFCBeacon(APP_UUID, [...]);
   

       
// Example usage of BlaubotAndroid from an activity or service
// onCreate()
   create a blaubot instance
// onResume() / onServiceStart():
   call blaubot.startBlaubot();
   call blaubot.registerReceivers(this);
   call blaubot.setContext(this);
   call blaubot.onResume(this) // if activity
// onPause()
   call blaubot.unregisterReceivers(this);
   call blaubot.onPause(this) // if activity
// onStop()
   call blaubot.stopBlaubot();
// onNewIntent(Intent intent)
   call blaubot.onNewIntent(intent);
   

       
// create the channel
final IBlaubotChannel channel = blaubot.createChannel(1);

// Send messages to all subscribers of this channel
channel.publish("Hello world!".getBytes());

// Subscribe to the channel to receive messages
// Note that subscriptions can only be made when connected (after onConnected())!
channel.subscribe(new IBlaubotMessageListener() {
    @Override
    public void onMessage(BlaubotMessage message) {
        // we got a message - our payload is a byte array
        // deserialize
        String msg = new String(message.getPayload());
        // .. do something useful ..
    }
});
   

       
// attach life cycle listener
blaubot.addLifecycleListener(new ILifecycleListener() {
    @Override
    public void onDisconnected() {
        // THIS device disconnected from the network
    }

    @Override
    public void onDeviceLeft(IBlaubotDevice blaubotDevice) {
        // ANOTHER device disconnected from the network
    }

    @Override
    public void onDeviceJoined(IBlaubotDevice blaubotDevice) {
        // ANOTHER device connected to the network THIS device is on
    }

    @Override
    public void onConnected() {
        // THIS device connected to a network
        // you can now subscribe to channels and use them:
        myChannel.subscribe();
        myChannel.publish("Hello world!".getBytes());
        // onDeviceJoined(...) calls will follow for each OTHER device that was already connected
    }

    @Override
    public void onPrinceDeviceChanged(IBlaubotDevice oldPrince, IBlaubotDevice newPrince) {
        // if the network's king goes down, the prince will rule over the remaining peasants
    }

    @Override
    public void onKingDeviceChanged(IBlaubotDevice oldKing, IBlaubotDevice newKing) {

    }
});
   

       
// force a minimum delay of 500 ms between messages
channel.getChannelConfig().setMessageRateLimit(500);
// set a picking strategy: When the messages in the queue are picked to send
// (with a minimum time period of 500 ms in between), just take the newest and
// discard all older messages
channel.getChannelConfig().setMessagePickerStrategy(BlaubotChannelConfig.MessagePickerStrategy.DISCARD_OLD);
// send the messages with a low priority
channel.getChannelConfig().setPriority(BlaubotMessage.Priority.LOW);
// limit the message queue capacity to 10 messages
channel.getChannelConfig().setQueueCapacity(10);

// reduce network traffic for some cases where we publish to 
// a channel to which we are subscribed.
channel.getChannelConfig().setTransmitReflexiveMessages(false); 
// always publish messages, even if we call publish() on a 
// channel without any subscribers
channel.getChannelConfig().setTransmitIfNoSubscribers(true);
   

       
<!-- Add this to your app's ui -->
<eu.hgross.blaubot.android.views.DebugView
    android:id="@+id/debugView"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content" />
   

       
// in your onCreate() or onServiceConnected() or ...
mDebugView  = (DebugView) findViewById(R.id.debugView);
mDebugView.registerBlaubotInstance(blaubot);

[...]

// onStop()
mDebugView.unregisterBlaubotInstance();
   

       
SwingUtilities.invokeLater(new Runnable() {
    @Override
    public void run() {
        SwingDebugView sdb = new SwingDebugView();
        sdb.registerBlaubotInstance(yourBlaubotInstance);

        // to view it in its own window ...
        JFrame frame = new JFrame();
        frame.add(sdb);
        frame.pack();
        frame.setVisible(true);
    }
});
   

       
// create a BlaubotServer using the WebSocketAdapter on port 8080
final int serverPort = 8080;
final int BlaubotDevice serverDevice = new BlaubotDevice("YourServerUniqueDeviceId");
final BlaubotServer websocketServer = BlaubotFactory.createBlaubotWebsocketServer(serverDevice, serverPort);

// attach a listener
websocketServer.addServerLifeCycleListener(new IBlaubotServerLifeCycleListener () {
    @Override
    public void onKingdomConnected(BlaubotKingdom kingdom) {
        // a Blaubot network established the connection to the server
        // you can now add an IBlaubotLifeCycleListeners to the kindom instance
        // and create channels

        // create a channel
        final short yourChannelId = 1;
        final IBlaubotChannel yourChannel = kingdom.getChannelManager().getOrCreateChannel(yourChannelId);

        // we send something
        yourChannel.publish("Hello World".getBytes());

        // and attach a listener to receive messages
        yourChannel.subscribe(new IBlaubotMessageListener() {
            @Override
            public void onMessage(BlaubotMessage blaubotMessage) {
                byte[] receivedData = blaubotMessage.getPayload();
                System.out.println(new String(receivedData));
            }
        });

        // we can also react to the network events
        kingdom.addLifecycleListener(new ILifecycleListener() {
            @Override
            public void onDisconnected() {
               // THIS device disconnected from the network => The server connection is down.
            }

            @Override
            public void onDeviceLeft(IBlaubotDevice blaubotDevice) {
               // ANOTHER device disconnected from the network
            }

            @Override
            public void onDeviceJoined(IBlaubotDevice blaubotDevice) {
                // ANOTHER device connected to the network THIS device is on
            }

            @Override
            public void onConnected() {
                // THIS device connected to a network
                // onDeviceJoined(...) calls will follow for each OTHER device that was already connected
            }

            @Override
            public void onKingDeviceChanged(IBlaubotDevice oldKing, IBlaubotDevice newKing) {

            }

            @Override
            public void onPrinceDeviceChanged(IBlaubotDevice oldPrince,	IBlaubotDevice newPrince) {
               // if the network's king goes down, the prince will rule over the remaining peasants
            }
        });
    }

    @Override
    public void onKingdomDisconnected(BlaubotKingdom kingdom) {
        // a Blaubot network's connection to the server is down

    }
});

websocketServer.startBlaubotServer();
   

       
// We create a Blaubot instance using an existing wifi network and multicasts to discover
UUID APP_UUID = UUID.fromString("ec127529-2e9c-4046-a5a5-144feb30465f");
Blaubot blaubot = BlaubotFactory.createEthernetBlaubot(APP_UUID);

// we create a connector for our server side
BlaubotServerConnector connector;
String hostnameOrIp = "www.yourHost.de";                  // or IPv4 Address
int websocketServerPort = 8080;                           // has to match the server's port
String serverUniqueDeviceId = "YourServerUniqueDeviceId"; // has to match the server's id set by us (see server side above)
IBlaubotDevice ownDevice = blaubot.getOwnDevice();
connector = BlaubotFactory.createWebSocketServerConnector(hostOrIp, websocketServerPort, "/blaubot", ownDevice, serverUniqueDeviceId);

// we add it to our BlaubotInstance
blaubot.setServerConnector(connector);

// now we can activate/deactivate the connector as we like
// setting it to false also disconnects a server connection from our device
connector.setDoConnect(true);

// we create a the channel with same id as the server (channel 1, see above)
final IBlaubotChannel channel = blaubot.createChannel(1);

// if we connect to a network, we send a hello world once
blaubot.addLifecycleListener(new ILifecycleListener() {
    @Override
    public void onDisconnected() {
    }

    @Override
    public void onDeviceLeft(IBlaubotDevice blaubotDevice) {
    }

    @Override
    public void onDeviceJoined(IBlaubotDevice blaubotDevice) {
    }

    @Override
    public void onConnected() {
        channel.publish("Hello Server!".getBytes());
    }

    @Override
    public void onKingDeviceChanged(IBlaubotDevice oldKing, IBlaubotDevice newKing) {
    }

    @Override
    public void onPrinceDeviceChanged(IBlaubotDevice oldPrince,	IBlaubotDevice newPrince) {
    }
});

// fire it up
blaubot.startBlaubot();