Sunday, June 5, 2016

Babbler Version 0.7.0 Released

Version 0.7.0 of the XMPP Java library has just been released!

As always you can find the artifacts in Maven Central:

<dependency>
    <groupId>rocks.xmpp</groupId>
    <artifactId>xmpp-core-client</artifactId>
    <version>0.7.0</version>
</dependency>
<dependency>
    <groupId>rocks.xmpp</groupId>
    <artifactId>xmpp-extensions-client</artifactId>
    <version>0.7.0</version>
</dependency>

Release highlights are support for WebSocket connection, the new XMPP Address Format (RFC 7395), asynchronous API for IQ queries and XEP-0198: Stream Management (which is still a bit experimental).

Some API has also been revised for less ambigious and easier usage, e.g. timeouts are now represented by java.time.Duration instead of a int/long (which somtimes were seconds, sometimes milliseconds) and the xml:lang attribute is now represented by java.util.Locale instead of String to prevent improper usage.

Here's a more complete list of changes:
  • Add support for XEP-0198: Stream Management
  • Add support for WebSocket connection method (RFC 7395).
  • Update Jid class to the new XMPP Address Format (RFC 7622)
  • IQ queries can now be executed asynchronously (non-blocking) using Java 8’s java.util.concurrent.CompletableFuture API.
  • Represent xml:lang attributes as java.util.Locale, not as String.
  • Represent timeouts as java.time.Duration instead of int/long for better clearness.
  • Add a very minimalistic DNS resolver for resolving SRV and TXT records in order to remove the dependency to com.sun.* classes.
  • Add more ReconnectionStrategy implementations.
  • Check connected state of socket before connecting (to prevent SocketException when a SocketFactory provides a connected socket)
  • Add XmppSession#isAuthenticated() method.
  • Add static XmppSession#addCreationListener() method to allow to listen for newly created sessions.
  • Update XEP-0080 to version 1.9 (add altaccuracy element).
  • Add API to destroy a MUC room without a reason.
  • More documentation, e.g. clarify the use of ConnectionConfiguration#secure()
  • Don’t include an empty body in Message Delivery Receipts.
  • Add correct XML names to component namespace stanzas.
  • Eagerly release unused port to prevent ports-leaks due to delayed GC
  • Improve thread-safety during connect() and login()
  • Fix encoding issues, caused by missing UTF-8 encoding, mainly in the debugger.
  • XEP-0033: Address should have extensions.
  • Add workaround for a JDK bug causing memory issues and high CPU.
  • Add documentation for custom SASL authentication.

Sunday, January 3, 2016

Precis (RFC 7564/7613) - A Java Implementation

Since a few months, there are a few new specifications around concerning internationalized strings in application protocols, which obsoletes the old Stringprep specification (RFC 3454).
  • RFC 7564: PRECIS Framework: Preparation, Enforcement, and Comparison of Internationalized Strings in Application Protocols
  • RFC 7613: Preparation, Enforcement, and Comparison of Internationalized Strings Representing Usernames and Passwords
  • RFC 7700: Preparation, Enforcement, and Comparison of Internationalized Strings Representing Nicknames

These are also used by XMPP, especially by the new Address Format specification, RFC 7622 (The local and resource part must conform to Precis profiles).

After working on a Java implementation for Precis for some time, I'd finally like to announce the first release of the open source software, which supports all of the three Precis specifications:

Project site with more information

Maven coordinates:

<dependency>
    <groupId>rocks.xmpp</groupId>
    <artifactId>precis</artifactId>
    <version>0.1.0</version>
</dependency>

Anybody who likes to upgrade the obsolete Libidn's Stringprep class is invited to give it a try.

Sunday, September 13, 2015

XMPP.rocks: Babbler Version 0.6.1 released

A new version 0.6.1 of the Java XMPP library has just been released to Maven Central.

This is primarily a bug fix release, which addresses some issues which were recently discovered and improves things here and there. It is compatible to version 0.6.0.

For detailed release notes, you can find the changelog here.

Thursday, August 13, 2015

Babbler Version 0.6.0

I am happy to announce the release of version 0.6.0 of the Java XMPP library, which has also been released to Maven Central!

This version is an important milestone because it’s the first version which is written solely for Java 8!

In particular that means, it leverages many of the new Java 8 goodies, most notably the new Date/Time API, Functional Interfaces (e.g. Predicate) and Lambda Expressions and paves the way for future improvements (e.g. Stream API) to keep the library modern.

The legacy Date API (java.util.Date/Calendar/TimeZone) has been replaced by the new java.time package, i.e. Instant, OffsetDateTime and ZoneOffset.

Event Listeners have been replaced by java.util.function.Consumer, which really saved a lot of similar interfaces and thanks to lambdas there isn’t even a syntactical difference.

New Features

A special release highlight is the support for the Jabber Component Protocol, which allows you to write External Components for an XMPP server. So the library isn’t exclusively usable for client development anymore, but now also for server component development! More about that in a future blog post.

Further new features are:

The full changelog with more information can be found here.

The updated documentation can be found here.

Support for XEP-0198: Stream Management is nearly done, but still needs some polishing, so it’s postponed to the next version.

Thanks for everybody who provided feedback and bug reports! I’m happy to hear more from you!

Wednesday, July 8, 2015

XMPP Real-time Text in Action

XMPP Real-time Text is definitively one of the most fun XMPP extension out there, from user's point of view as well as from a developer's point of view! Recently I've added support for it in the upcoming version 0.6.0 and I thought I'd make a short video which demonstrates this cool new feature in action!

It shows how it could look like when two XMPP contacts are chatting with each other and having real-time text enabled. Enjoy!

Roughly speaking you have to create a new outbound real-time message and just update its text while typing:

// Create a chat session with another user.
Chat chat = xmppClient.getManager(ChatManager.class).createChatSession(contact);
RealTimeTextManager realTimeTextManager = xmppClient.getManager(RealTimeTextManager.class);
// Create an new RTT message.
OutboundRealTimeMessage realTimeMessage = realTimeTextManager.createRealTimeMessage(chat);
TextArea textArea = new TextArea();
textArea.textProperty().addListener((observable, oldValue, newValue) -> {
    realTimeMessage.update(newValue);
});

When done typing, commit the message (which will send the current message as normal chat message):

realTimeMessage.commit();

On the receiver side, you can listen for it like this (and e.g. display it to a Label).

Label label = new Label();
// Upon receiving a RTT message, display it.
realTimeTextManager.addRealTimeMessageListener(e -> {
    InboundRealTimeMessage rtt = e.getRealTimeMessage();
    rtt.addRealTimeTextChangeListener(e1 -> Platform.runLater(() -> label.setText(e1.getText())));
});

Saturday, March 21, 2015

Version 0.5.0 Release Notes

Yay, after a few months of work, version 0.5.0 has been released and pushed to Maven Central!

This release contains some new features, most noteworthy:

And as always bug fixes, more JavaDoc, minor improvements, micro optimizations etc.

A more comprehensive list can be found in the changelog.

Special thanks goes to Markus Karg, who has provided many good ideas and test results, issued bugs and suggested improvements!

What’s next?

Moving to Java 8

0.5.0 will be the last release for Java 7, future releases will be for Java 8.

The reasons behind this decision are:
  • Java 8 offers so much cool new stuff, which is worth exploring and probably helps improving the API in a sustainable way. I am thinking especially about the Stream API, java.time and java.util.function packages and the new Async API.
  • As of now, this library is developed and tested with Java 8 only, which makes maintaining Java 7 compatibility a burden.

New Features

I only want to give a vague preview here, but my plans for new features are currently to implement XEP-0198: Stream Management and finally finish XEP-0301: In-Band Real Time Text.

Happy coding!

Friday, February 13, 2015

Bringing XMPP Chat States to JavaFX

Chat States. Everybody knows them from Instant Messengers or Facebook Chat. Those tiny notifications, which tell you, if your chat partner is currently composing a message, is (in)active or has paused typing. E.g. "XY is typing..."

XMPP defines these states in XEP-0085: Chat State Notifications as:
  • active
  • inactive
  • gone
  • composing
  • paused

Each of them - except "gone" - are applicable to a "message input interface". So let's translate them to a JavaFX TextArea!

First we define, that whenever the TextArea receives focus, we want to change the state from 'inactive' (which is the initial default state) to 'active' (if there's no text) or to 'paused' (if there's already text):

Secondly we have to change to 'composing', whenever the text changes. Easy.

The slightly tricky part is to change to the 'paused' state. To achieve this, we can set up a javafx.animation.PauseTransition and restart it everytime the text or focus has changed. Eventually, when the transition has finished (e.g. after 3 seconds), it will automatically change the state to 'paused':

Lastly, we change to 'inactive' when focus is lost:

And here's my take on a simple implementation. Enjoy!

import javafx.animation.PauseTransition;
import javafx.beans.property.ObjectProperty;
import javafx.beans.property.ReadOnlyObjectProperty;
import javafx.beans.property.ReadOnlyObjectWrapper;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.control.TextArea;
import javafx.util.Duration;
import rocks.xmpp.extensions.chatstates.model.ChatState;

public class ChatStateTextArea extends TextArea {

    private final PauseTransition pauseTransition = new PauseTransition(Duration.seconds(3));

    private final ReadOnlyObjectWrapper<ChatState> chatState = new ReadOnlyObjectWrapper<>();

    public ChatStateTextArea() {
        // This is the initial state.
        chatState.set(ChatState.INACTIVE);

        focusedProperty().addListener(new ChangeListener<Boolean>() {
            @Override
            public void changed(ObservableValue<? extends Boolean> observableValue, Boolean aBoolean, Boolean
                    aBoolean2) {
                if (aBoolean2) {
                    if (getText().isEmpty()) {
                        // If we have received focus in an empty text field, immediately transition to "active".
                        chatState.set(ChatState.ACTIVE);
                        pauseTransition.stop();
                    } else {
                        // If we have received focus in an non-empty text field, transition to "paused".
                        chatState.set(ChatState.PAUSED);
                        // Start the timer, which will automatically transition to the next state.
                        pauseTransition.playFromStart();
                    }
                } else {
                    pauseTransition.playFromStart();
                }
            }
        });

        textProperty().addListener(new ChangeListener<String>() {
            @Override
            public void changed(ObservableValue<? extends String> observableValue, String s, String s2) {
                // We are in "composing" state.
                chatState.set(ChatState.COMPOSING);
                // Restart the timer.
                pauseTransition.playFromStart();
            }
        });

        pauseTransition.setOnFinished(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent actionEvent) {
                // When the time is up, switch to "paused", if there's any text, otherwise to active.
                if (isFocused()) {
                    if (getText() != null && !getText().isEmpty()) {
                        chatState.set(ChatState.PAUSED);
                    } else {
                        chatState.set(ChatState.ACTIVE);
                    }
                } else {
                    chatState.set(ChatState.INACTIVE);
                }
            }
        });
    }

    // Ommitted getters and setters for clearness.
}