Robotlegs Introduction

Robotlegs Workshop
29 january 2011
Eric-Paul Lecluse & Erik van Nieuwburg

Monday, January 31, 2011

What is Robotlegs?
• MVC framework
• Looks a lot like pureMVC
• Focused on wiring application tiers
• Lightweight / small footprint
• Based on ‘dependency injection’ via
SwiftSuspenders library


Dependency Injection?

• It’s the act of supplying objects with their
required data.
• Passing an argument to a constructor is an
example of dependency injection.
• Less boilerplate code
• Flexible adding of alternative
implementations of a given service.


Robotlegs + Dependency Injection
• Based on SwiftSuspenders (metadata driven
Inversion Of Control solution for AS3)
• Evolves around 2 meta tags: [Inject] and
[PostConstruct]
• If you don’t use the supplied SWC ﬁles ,
add these parameters to MXMLC:
• -keep-as3-metadata+=Inject
• -keep-as3-metadata+=PostConstruct

So what does a class look like?
package com.rumblingskies.view
{
import com.rumblingskies.model.ScoreModel;
import org.robotlegs.mvcs.Mediator;

public class BallMediator extends Mediator
{
[Inject]
public var scoreModel:ScoreModel;

override public function onRegister() : void
{
}
}
}


But how to inject?

Typically, during startup of your app, you deﬁne
injector rules. You can do that in 4 ways:

injector.mapValue(MyClass, myClassInstance);

injector.mapClass(MyClass, MyClass);

injector.mapSingleton(MyClass);

injector.mapSingletonOf(IMyClass, MyClass);


injector.mapValue
(MyClass, myClassInstance);
When asked for
a speciﬁc class,
use this speciﬁc instance of the class
for injection.


injector.mapClass
(MyClass, MyClass);
When asked for
a speciﬁc class,
create and inject a new instance
of that class.


injector.mapSingleton(MyClass);

When asked for
a speciﬁc class,
always provide the same instance
of that class.

No more writing Singleton logic :-)
This is a managed single instance, enforced by the
framework, and not a Singleton enforced within the
class itself.

injector.mapSingletonOf

(IMyClass, MyClass);
When asked for
a speciﬁc class,
always provide the same instance
of the implementation that class.

No more writing Singleton logic :-)
This is a managed single instance, enforced by the
framework, and not a Singleton enforced within the
class itself.

Robotlegs Architecture
Built up in 4 tiers:
•Model
•View
•Controller
•Services
Services are models, but for communication with
the outside world. For instance loading an image
from Flickr.


Model

Contains / maintains your application’s data /
state

Extends ‘Actor’ class so it can dispatch events

Dumb objects: receive value changes and then
dispatch events. That’s it.


public class ScoreModel extends Actor
{
private var _score:Number;

public function ScoreModel()
{
}

public function get score() : Number
{
return _score;
}

public function set score(score : Number) : void
{
_score = score;
dispatch(new ScoreEvent(ScoreEvent.UPDATE));
}
}


Model Instantiation

Typically, you inject Model instances.

So during system startup, deﬁne injector rules for
injection of Models:

injector.mapSingleton(ScoreModel);

This way your ScoreModel class is behaving as a
Singleton.


View

The visual elements of your app

To interact with the framework they have a
seperate Mediator class

Mediators listen to
• events travelling through the framework
• events sent by their view component


View instantiation
Again, during system startup you typically tell the
framework which views and mediators work
together.
mediatorMap.mapView( viewClass, mediatorClass, injectViewAs,
autoCreate, autoRemove );

By default, mediators are auto-created when a
view is ADDED_TO_STAGE!

It’s fully automated! Yeah.....i know.....it rocks :-)


public class Ball extends Sprite
{
public function Ball()
{
redraw();
}

public function redraw() : void
{
graphics.clear();
graphics.beginFill(0xffffff *
Math.random());
graphics.drawCircle(0, 0, 25);
}
}


public class BallMediator extends Mediator
{
[Inject]
public var ballView : Ball;

[Inject]
public var stats:StatsModel;

override public function onRegister() : void
{
addViewListener(MouseEvent.CLICK, handleViewClick);
addContextListener(HelloRobotLegsEvent.BALL_CLICKED,
handleBallClicked);
}

private function handleViewClick(e : MouseEvent) : void
{
stats.recordBallClick();
dispatch(new HelloRobotLegsEvent
(HelloRobotLegsEvent.BALL_CLICKED));
}

private function handleBallClicked(e : HelloRobotLegsEvent) : void
{
ballView.redraw();
}
}


Commands
Are similar to pureMVC commands.

Run an execute() method

At system startup, map your Commands to
framework Events like this:
commandMap.mapEvent(MyAppDataEvent.DATA_WAS_RECEIVED,
MyCoolCommand, MyAppDataEvent);

Robotlegs natively does not have a
MacroCommand like pureMVC.

public class CreateBallCommand extends Command
{
[Inject]
public var event:HelloRobotLegsEvent;

override public function execute() : void
{
var ball : Ball = new Ball(event.ballName);
ball.x = Math.random() * 500;
ball.y = Math.random() * 400;
contextView.addChildAt(ball, 0);
}
}


Quickstart Help
Download ZIP file here:
www.rumblingskies.com/files/robotlegs-workshop/pong.zip

1) Subclass Context class and overwrite the startup() method
2) Configure the injector
3) fill mediatorMap
4) fill commandMap
5) add children to contextView
6) start writing logic in Model, Mediator,View and Command
classes.

Robotlegs Introduction

More Related Content

What's hot

Viewers also liked

Similar to Robotlegs Introduction

Recently uploaded

Robotlegs Introduction