Please ask about problems and questions regarding this tutorial on answers.ros.org. Don't forget to include in your question the link to this page, the versions of your OS & ROS, and also add appropriate tags.

Generating RosJava Message Artifacts (Catkin Style)

About

Many of the awkward tricks from hydro are now no longer necessary and the biggest step forward is an implicit message generator that embeds inside the ros message generating infrastructure. So if you have a message package, and genjava installed, it will now magically generate the required java artifacts.

The only drawback right now is that this is not an official generator, so they are not available to you when downloading the corresponding msg deb. This is being worked on, but right now the message generation is just too slow (compare with python and c++ where no compile step is needed). This is not a huge drawback though - we will endeavour to host pre-built artifacts on the rosjava maven repository for as many 'official' message types as possible as well as provide a script that will let you generate them locally from what is already installed.

Prerequisites

You will need genjava, either from source:

> wstool set genjava --git https://github.com/rosjava/genjava --version=indigo

or from debs:

> sudo apt-get install ros-indigo-genjava

Usage

There are three ways you can ensure your message artifacts are created:

• Command Line : generate for all installed messages in your local environment, in one shot.
• Genjava : generate from your source workspaces via genjava and message_generation.
• Meta Msg Pkgs : does message generation for a strict subset of packages.

Command Line

The following commands build artifacts in the current directory under a build subfolder (use -o to change) and puts them in your current workspace's devel/share/maven folder.

1) Build all message artifacts discoverable in your current source workspace or its underlays:

# Make sure you have the latest message packages installed
> sudo apt-get install --only-upgrade ros-indigo-*
# Build them all!
> genjava_message_artifacts --verbose

2) Build a specific message artifact along with all its dependencies:

> genjava_message_artifacts --verbose -p std_msgs

3) Build a specific set of message artifacts along with their dependencies:

> genjava_message_artifacts --verbose -p std_msgs geometry_msgs

Genjava

Simply make sure genjava has been installed and then it will automatically generate artifacts for any source message package it finds alongside python/c++ interfaces. These artifacts will be deployed in your devel/share/maven/org/rosjava/messages folder.

Meta Msg Pkgs

It's nice to be able to structure your packages so that everything can be installed via a wstool rosinstall, and a rosdep install command. That is, you'd like your java message artifacts available as a deb. Neither of the above methods facilitate this, so this method is a stopgap to make that happen until the message generator is considered official.

An example of this kind is the rosjava_messages package. This is a strictly zero-code catkin package that depends on genjava and whatever message packages you choose and includes a cmake instruction to generate artifacts for those dependencies.

> mkdir -p ~/rosjava_messages
> wstool init -j4 ~/rosjava_messages/src https://raw.githubusercontent.com/rosjava/rosjava/indigo/rosjava_messages.rosinstall
> source /opt/ros/indigo/setup.bash
> cd ~/rosjava_messages
# Make sure we've got all rosdeps and the latest msg packages.
> rosdep update
> rosdep install --from-paths src -i -y
> sudo apt-get install --only-upgrade ros-indigo-*
> catkin_make

The package.xml dependencies:

  <buildtool_depend>catkin</buildtool_depend>
  <build_depend>rosjava_build_tools</build_depend>
  <build_depend>genjava</build_depend>
  <!-- needed for genjava rosdistro dependency -->
  <build_depend>python-rosdistro</build_depend>
  <!-- needed for genjava roslib dependency -->
  <build_depend>roslib</build_depend>

  <!-- your custom messages -->
  <build_depend>std_msgs</build_depend>
  <build_depend>ros_comm_msgs</build_depend>            # ros/ros_comm_msgs
  <build_depend>rosjava_test_msgs</build_depend>        # rosjava/rosjava_test_msgs
  <build_depend>actionlib_msgs</build_depend>           # ros/common_msgs
  <build_depend>diagnostic_msgs</build_depend>
  ...

And CMakeLists.txt excerpts:

find_package(catkin REQUIRED genjava)

generate_rosjava_messages(
  PACKAGES
    std_msgs
    ros_comm_msgs            # ros/ros_comm_msgs
    rosjava_test_msgs        # rosjava/rosjava_test_msgs
    actionlib_msgs           # ros/common_msgs
    common_msgs
    diagnostic_msgs
    ...
)

On subsequent calls to catkin_make, this will not rebuild the artifacts. You can ensure a rebuild by cleaning the package:

> catkin_make --pkg=rosjava_messages --make-args clean
OR
> cd build/rosjava_messages; make clean; cd ../..
# Rebuild
> catkin_make

Since this has a full rosdep list of dependencies, you can now depend on this package when rosinstalling sources, or even get this package rolling on the build farm as an installable deb. It's also a nice easy way to generate a subset of artifacts ready for pushing them to maven.