OSC on Android

I just bought myself a HTC Hero so im starting to learn all the Android development stuff.

So the first thing i’ve tried is to see how easy it is to get my OSCLib stuff working. There isnt a lot to the actual library itself as most of the hard work is handled by Apache Mina. I started a new Android project in eclipse and just tried to send a simple OSC message to a test server on my local machine. It didnt work, the dalvik VM told me I had a verify error. I eventually narrowed this down to the SLF4J library. At this stage I had no clue about how to fix it so back to google to see if someone else had done the hardwork. :)

I found this thread where Thorsten Möller says he actually has a version of slf4j but its not on the main site yet, just in his git repo. So after a clone of that and a run of maven I had a shiny new slf4j-android.jar which I’ve upload to my site here.

I added that jar to the dependencies of my OscAndroDemo test project and it worked. Easy. :)

All the source is available from the OSCLib assembla project. The main library is in /trunk/java, its an eclipse project and in there you can run the OSCServer class for testing. It’ll spit out some info to stdout when it receives a message. The android project is in /trunk/android/AndrOscDemo which you can check out from SVN directly into eclipse.

The demo just connects to and sends a single message. The next stage is to try and do some interesting stuff with the various sensors like the accelerometer and see if any issues arrive once I start sending lots of messages.

Voronoi diagram generator in flash

After reading Ross Bencina’s paper : “The Metasurface – Applying Natural Neighbour Interpolation to Two to Many Mapping”, I decided to have a go at building a similar system myself and hopefully revive an earlier project for creating different ways of modulating parametric systems (for me that means audio).

The first pass is done and you can see it working right here (flash player 10 required)

The code will be up somewhere soon, at the moment its mainly a port of the code from this page (but refactored to seperate the voronoi model, the scanner and the renderer). Thats combined with an implementation of the FastClip algo from this wikipedia page to keep the lines in the bounding box.

next up is gathering the line segments into polygons and linking stuff together ready for some nearest-neighbour evaluation.

OSC – Open Sound Control

For some reason, MIDI isnt dead yet, although it is indeed ‘ubiquitous and lightweight’ that doesn’t mean it should stick around. For some tasks its fine, but its definitely starting to show its age. One of the alternatives for communication between audio / video software and devices is Open Sound Control – OSC.

Im not going to go into a deep discussion of MIDI vs. OSC at this point, there are of course some benefits to MIDI which OSC should deal with in some way (e.g. a standardised namespace for representing MIDI semantics, or a discovery mechanism for that namespace..)..anyway, I just want to let you know that I’ve been working on some OSC related stuff to make using it easier from both Actionscript 3 and Max/MSP.

First up is OSCLib, this is intended as a low level set of OSC libraries which you can use in other applications. Actionscript 3 doesnt have UDP, only HTTP sockets whereas most OSC implementations (e.g. Reaktor, Bidule) are UDP based although one notable exception is SuperCollider which supports both. So to help bridge the gap there are java implementations for both HTTP and UDP clients and servers (well, the UDP server is currently missing but should be done in a day or two..)

For Max/MSP there is an MXJ object which wraps the HTTP server so you can send messages from a Flash / Flex client directly to Max/MSP.

There is some documentation on the project wiki pages for getting your dev environment setup and also a Flash / Max demo you can try out.

As a side note if anyone has a Korg Kontrol49 then i’ve also got a project based on OSCLib for working with the Kontrol49 in native mode : KontrolTools. This allows you to have full control of the lights and text displays via OSC as well as generate OSC message from all the knobs, sliders and buttons.

Reaktor Sample Map Generator

Reaktor is great, but one thing that i dont like about it is the built in sample management, you have to create these ‘sample maps’ to use your own samples but the UI for it is a bit rubbish, like an awful version of kontakt. so i built a tool to generate map files automatically.

I’ve built a new version in Java which is tested and working on both Windows and OSX. You can download the app here.

I’ll put the source up soon when I get a spare minute.

comments, suggestions, modifications are all welcome.

If you are wondering how to run a .jar file then you will need to first download and install java then you should then be able to just double-click the .jar file. If for some reason that doesnt work you can ‘Open With…’ and then find where java is installed, somewhere like : C:/Program Files/Java/jre1.6.0_07/bin and choose the ‘javaw.exe’ program.

Flash, file uploads, a 403 and mod_security

If, like me, you have just spent a good while pulling your hair wondering why your file upload from flash mysteriously return a 403 : access forbidden even though the url is accessible from the browser and you might have even gone to the trouble of building an html form to prove that the damn thing works. then, you might be running into a problem with mod_security.

The solution :

add this to a .htaccess file :

SecFilterEngine Off
SecFilterScanPOST Off

PixLib part 3. Abstract Factory

Today I found yet another good reason to test PixLib (and I still have some others in mind that are to come, like removing all my dependencies on the mx.* packages)

To give a bit of background, the application im building is a drag-and-drop based story creator for schoolkids. Theres a stage onto which they can add different types of things (aka artifacts) and move them around, scale, rotate etc.. Now most artifacts behave the same way, but some need special abilities, for example speech bubbles have text which can be edited ‘live’ (i.e. inside the bubble not in a seperate text field) and there are other types of artifact with their own peculiarities. Each of these types of artifact inherits from one base class and its this base class which most of the application deals with. It doesnt need to know about the difference between a normal artifact and a speech bubble it just wants to keep a list of them, save and restore their state etc..

To attain this goal i have decided to use a factory to create the artifacts. A factory is just a class (or often a single method) that is used to create objects. If you havent heard of these then Wikipedia has some more information: Factory Method Pattern and Abstract Factory

At creation time I know the type of the artifact I want (its a string property of an Artifact model object) and I need to create the corresponding UI object. I could code my own factory method or factory class and use a big if / else (or switch / case) construct to decide what to build depending on the artifact type but there has to be a better way. Enter PixLib’s AbstractFactory.

If you look at the API for AbstractFactory its very minimal, the only public method is push (sKey:String, classConstructor:Function). This is used to register the types of objects I want to build.
Now if you look at the source you will notice the more interesting method _buildInstance (much like the buildInstance from the HashCodeFactory from the previous post).
Because its an AbstractFactory that means I have to make my own concrete subclass which will implement my factory method. I also need to register the types I want to create by their string identifiers.

(Its worth noting at this point that the PixLib AbstractFactory class doesnt play the exact role of the AbstractFactory class in the canonical AbstractFactory Pattern. It is ‘Abstract’ because you create concrete subclasses and dont use it directly but unlike the usual AbstractFactory in the pattern it doesnt have the same interface as those subclasses, instead it provides a facility for dynamically linking identifiers to class constructors which the concrete subclasses can use to create objects.

If thats just made things even more confusing dont worry about it..)

First, I need to extend the Abstract Factory and register my types :

class EditableObjectFactory extends AbstractFactory
    // private constructor for Singleton
    private function EditableObjectFactory()
        // register artifact types



Then I can implement my factory method which looks a bit like this :

public function createEditableObject(artifact:ArtifactModel,mc:MovieClip):EditableObject
    // Create instance according to artifact type (i.e. Character.TYPE_ID, SpeechBubble.TYPE_ID etc..)
    return _buildInstance(artifact.getType(),mc);

Then the application code can just ask the EditableObjectFactory to create the appropriate item when a user requests a new artifact to be added to the stage.

Another benefit of this is that each of the 3 versions of the application can easily add their own custom artifact types. They each just register the type with EditableObjectFactory at startup and the rest happens like magic. :)

Another examples is available within PixLib. If you look at the TweenFactory class in the com.bourre.transitions package you will see that it subclasses AbstractFactory to be able to create instances of Tween objects.

If you find yourself in the situation where you are dealing with a set of if / else or switch / case statements when you are creating objects then its definitely worth considering using a factory and encapsulating the creational process into its own class.