Secret Lab

So, here’s another something that we’ve been working on.

Captain is a lightweight library that lets you add hooks to your code, using JavaScript. We designed it for two reasons:

• If you’ve got a bunch of objects, each needing a small amount of custom objects, creating a subclass for each variation is cumbersome, and devising a sophisticated data-driven architecture is often overkill and sometimes impossible for your use case.
• Extremely rapid iteration, skipping the compile/install phase, is awesome.

Many of the games we make involve a lot of special-cased behaviour. Like all halfway decent developers, we try to minimise this, but sometimes you really just need a sprite that walks two feet left, three right, and does a twirl, and there’s nothing else in the game that you can generalise into a nice, reusable system.

We’ve already found some great results in allowing field-testers and non-programmers to make modifications to iOS applications by exposing certain resources to iTunes File Sharing. For example, if you’re writing an app that has a lot of sound effects, it makes your sound designer’s life a heck of a lot easier if they can open up iTunes and drop in a replacement sound file, and see how it sounds in your app without having to get another build.

What we ended up doing was using JavaScriptCore, which is the built-in JavaScript runtime on iOS, to create a very loose binding to Objective-C, and then allow Objective-C objects to delegate parts of their behaviour out to JavaScript.

Captain isn’t a scripting bridge. This means that it’s a slightly different thing to libraries like the excellent jscocoa. Most scripting bridges allow you to write entire apps in other languages, which is super cool. However, we really like Objective-C, and find that using the native language for the iOS platform is the best way to approach most things.

Captain, therefore, lets you expose very specific parts of your application’s behaviour to scripts, effectively creating a domain-specific language for your app. Plus, it’s all designed to be super lightweight.

An important note: Apple’s rules say your app isn’t allowed to get scripts from the outside world and run them. This means that you can’t use Captain to build a plugin architecture for your app, but you can use it during development to make your edit-build-compile cycles faster and more flexible.

How to use it

The most basic use case for Captain is when you want to run a JavaScript function, and get back whatever the function returned.

When you work with Captain, you first create a JSContext object, which serves as the execution environment for all of your scripts. You can create as many contexts as you like, but each one is kept separate from each other, and variables won’t be shared between them.

Creating a JSContext looks like this:

JSContext* context = [[JSContext alloc] init];

Once a context has been set up, you can give it JavaScript code to execute. You do this using the evaluateScript:error: method:

NSError* error = nil;
[context evaluateScript:@"1+1" error:&error];

This method returns whatever the result of the script you passed in was. If the JavaScript code threw an exception for any reason, the error variable will contain information about it.

Any values returned by the evaluateScript: method are returned as Objective-C objects, and are automatically converted from their JavaScript type into the most appropriate Objective-C type. Strings are turned into NSStrings, numbers become NSNumbers, and JavaScript objects get turned into NSDictionary objects.

NSNumber* returnedNumber = [context evaluateScript:@”31337” error:nil];
   // returnedNumber == @(31337)

Calling native functions from JavaScript

Basic stuff, right? However, the fun stuff happens when you give the JavaScript code some native functions that it can call.

You can add register functions in the JavaScript context that scripts can call, by creating a block object and giving it to the JSContext. These block objects take one parameter, an NSArray that contains the parameters that were passed in from JavaScript, and return an id, which will be automatically converted back to a JavaScript value.

Example time!

JSFunction addTwoNumbers = ^(NSArray* parameters) {
        if (parameters.count < 2)
            return 0;
        NSNumber* firstNumber = parameters[0];
        NSNumber* secondNumber = parameters[1];
        return @(firstNumber.intValue + secondNumber.intValue);
    };

[context addFunction:doSomethingFunction withName:@"doSomething"];

Once you’ve added a function, you can call it from JavaScript.

NSString* code = @"doSomething(1,2)";
NSNumber* returnedNumber = [context evaluateScript:code error:nil];
// returnedNumber == @(3)

Calling JavaScript functions from native code

Things get really interesting when your native code can call JavaScript code. Because you can load the new code at run-time, or even replace code without having to re-launch your app, you get a crazy amount of flexibility.

If you run some JavaScript code that returns a function, it will be returned to as a JSFunction block, which can be called just like a function.

NSString* code = @"(function(personName) { return \"hello, \" + personName; })";
JSFunction returnedFunction = [context evaluateScript:code error:nil];

NSString* string = returnedFunction(@["world"]);
// string == @"hello, world!"

Working with native objects in JavaScript

Working in only numbers and strings is boring. What would be really awesome is if Captain could let JavaScript work with Objective-C objects in a clean, simple way that had zero programmer overhead, and let the developer write clean code in both languages.

Wait, you can? BONUS.

TestObject* myObject = [TestObject new];
myObject.name = @"Bob";

[context setProperty:@"testObject" toObject:testObject];

[context evaluateScript:@"testObject.name = \"Alice\"" error:nil];

// myObject.name == @"Alice"

Any property that uses the standard compiler-generated setter and getter methods can be modified by JavaScript code.

In addition to working with data, you can also call methods on Objective-C objects from JavaScript.

But doesn’t Objective-C have crazy weird method names that look ugly in other langauges?

That’s right, it does. That’s part of the reason why Captain only exposes certain methods to JavaScript.

If your Objective-C object has a method named handleFoo:, which takes one parameter, it will be exposed through JavaScript as “foo”. Only methods that meet these requirements are callable from JavaScript.

The reasoning behind this is that Captain is intended to be a simple way to expose limited amounts of domain-specific functionality to a scripting environment, rather than a comprehensive scripting bridge. By only having to support a limited amount of interaction between native code and the script, life is made easier for both worlds.

Example! Here’s an Objective-C object:

@interface MyObject : NSObject

- (id) handleDoSomethingUseful:(NSDictionary*)parameters;

@end

@implementation MyObject

- (id) handleDoSomethingUseful:(NSDictionary*)parameters {
    // Assume parameters[0] is a string

    return [parameters[0] stringByAppendingString:@", yes!"];
}    

@end

And here’s code that interacts with it:

MyObject* foo = [MyObject new];

[context setProperty:@"foo" toObject:foo];

NSString* code = @"foo.doSomethingUseful(\"Bruces\")"

NSString* returnedString = [context evaluateScript:code error:nil];

// returnedString == @"Bruces, yes!"

Loading scripts

The final piece to this is in loading a large number of JavaScript functions, which native objects can use.

Let’s say you’ve got a JavaScript file named “UsefulFunctions.js”, and it contains this:

this.doSomething = function () {
    log("Hello from inside JavaScript!");
    return 123;
}

this.frobnicate = function(a) {
    return a + " " + a;
}

You can register the entire set of functions contained in the script using the loadScriptNamed:error: method.

[context loadScriptNamed:@"UsefulFunctions" error:nil];

Doing this causes the JSContext to look for the file “UsefulFunctions.js”, first in the Documents folder, and then in the built-in bundle resources. Because it looks in this order, you can modify the app’s functionality by simply dropping in a replacement file with the same name in iTunes File Sharing, and re-launching the app.

Delegating behaviour to JavaScript

The functions that you load in can also be used by Objective-C objects to delegate some of their behaviour to.

For example, say you have a JavaScript file ‘Foo.js’, containing the following code:

this.doSomething = function() {
    this.name = "Bob";
}

Once Foo.js is loaded in, you can call the function, and additionally provide it with an object to use for the this variable.

MyObject* foo = [MyObject new];
[context callFunction:"Foo.doSomething" withParameters:nil thisObject:foo error:nil];

// foo.name == @"Bob"

With this method, your classes can easily call out to JavaScript when they need some work done.

Conclusion

We hope you enjoy using Captain, and we’d love to see what else you do with it. Captain is on GitHub! We welcome pull requests, and if you’ve got any questions, shoot us an email at lab@secretlab.com.au

Enjoy!