By: Fernando de Sousa

One of my current tasks with the Serval Project is the redevelopment of the Serval Maps application, which was the focus of my honours thesis last year.

As part of the redevelopment I’ve implemented a new data interchange format that takes advantage of the Rhizome capabilities of the Serval Mesh software. I’ve decided to use Google Protocol Buffers as the basis for my binary file format.

To write the messages to the file it is necessary to use the writeDelimitedTo method of my Message class to write the messages to the file. By using this method each message is delimited in the file.

The code looks something like this:

try {
	FileOutputStream mOutput = new FileOutputStream(mOutputPath + mFileName, true);
	mMessageBuilder.build().writeDelimitedTo(mOutput);
	mOutput.close();
} catch (FileNotFoundException e) {
	Log.e(TAG, "unable to create the output file", e);
	return;
} catch (IOException e) {
	Log.e(TAG, "unable to write to the output file", e);
	return;
}

Reading back the messages from the file requires the use of the mergeDelimitedFrom method to read the messages out of the file and process them. The code looks like this:

try {
	while(mMessageBuilder.mergeDelimitedFrom(mInput) == true) {

		// process each message in turn
	}
} catch (IOException e) {
	Log.e(TAG, "unable to read from the input file", e);
	return;
} finally {
	try {
		mInput.close();
	} catch (IOException e) {
		Log.e(TAG, "unable to close input file", e);
	}
}

It took me some time this afternoon to work this out, including a large number of Google searches. I hope this post helps someone else who is working through similar issues.

The photo “Binary” was uploaded to Flickr by Fernando de Sousa and used under the terms of a Creative Commons License.

One of my development tasks this past week was to extract the contents of a file that was compressed and stored in a zip file using Java for the Serval Maps Android application that I’m developing as part of my work for the Serval Project.

The file in question contains a list of coordinates that I use as a source of location data that I can provide to my application using mock locations. Using this class I can provide geo-coordinates to my application during testing that appear to come from the GPS hardware, from the perspective of the rest of the code. The coordinates are in fact sourced from the file. I’ll write about this improved class in a future post.

The code that I developed to extract the contents of the file looks something like this:

// declare helper constants
private final String LOCATION_FILE = "mock-locations.txt";
private final String LOCATION_ZIP_FILE = "mock-locations.zip";

// open the zip file and get the required file inside
ZipInputStream mZipInput = new ZipInputStream(context.getAssets().open(LOCATION_ZIP_FILE));
ZipEntry mZipEntry;

// look for the required file
while((mZipEntry = mZipInput.getNextEntry())!= null) {

  // read the bytes from the file and convert them to a string
  if(mZipEntry.getName().equals(LOCATION_FILE)) {

    // store the incoming data in a byte array stream
    ByteArrayOutputStream mByteStream = new ByteArrayOutputStream();
    byte[] mBuffer = new byte[1024];
    int mCount;

    // read in the data until it is all gone
    while((mCount = mZipInput.read(mBuffer)) != -1) {
      mByteStream.write(mBuffer, 0, mCount);
    }

    // store the data for later
    locations = new String(mByteStream.toByteArray(), "UTF-8");
  }

  // play nice and tidy up
  mZipInput.closeEntry();
}

// play nice and tidy up
mZipInput.close();

The basic process that this code undertakes is to:

1. Open the zip file stored in the assets folder using the ZipInputStream class
2. Loop through the contents of the zip file looking for the required file by examining the series ZipEntry objects
3. Once found read the contents of the file into a ByteArrayOutputStream
4. Convert the byte array into a string and store it for later use

Earlier this month Linux.conf.au 2012 was held in Ballarat, Vic. The Serval Project was fortunate to be awarded two presentation slots at the conference. I was scheduled to present, but unfortunately had to pull out at the last moment due to illness.

My presentation was to focus on my work on the prototype Serval Maps application, which was the topic of my honours thesis last year.

Fortunately Dr Paul Gardner-Stephen, Serval Project Co-Founder and Shuttleworth Fellow, was able to attend and presented instead. You can read his notes on the conference here.

The presentation by Paul is now available on YouTube here.

The Serval Project also had another presentation at the conference which focused on our Rhizome technology. That presentation, by Jeremy Lakeman, is also available on YouTube here.

It is unfortunate that I was unable to attend and present, it was something that I was looking forward to. Hopefully I’ll be able to present next year on one of the many interesting things that the Serval Project is undertaking this year.

By: Sam Hames

This past year I’ve been studying part time for a Bachelor of Science (Honours) degree specialising in Computer Science at Flinders University. The focus of my studies has been my honours thesis. My thesis explored the following research question:

Is it possible to provide collaborative mapping services on mobile devices in an infrastructure independent manner?

To explore this question I developed an Android based application that could support four core objectives. They were:

1. have the users own geographic location displayed on a map;
2. add incidents, represented by a marker, onto a map;
3. be able to see the geographic location of other users of the application on the map; and
4. share details of incidents with other users of the application on the network.

The software that I developed uses the resilient Ad Hoc mesh network provided by the Serval Project to ensure that communication between instances of the application are infrastructure independent.

The thesis is available online on my Stuff by Techxplorer website.

The photo “Writing Thesis” was uploaded to Flickr by Sam Hames and used under the terms of a Creative Commons License.