Framework | Soundstep, daily ActionScript.

Posts Tagged “framework”

06 06 2011

SomaAssets demo

Posted by: Romuald in SomaCore, talking, tags: as3, flash, flex, framework, SomaCore

As requested, I Just made a quick demo how to implement the SomaAssets plugin in your application.

See the demo.
Download the demo.
View source.
Demo on github.

I'll make a quick descrition here. I'll be using the following XML config:

Plain Text

XML:

<?xml version="1.0" encoding="UTF-8"?>
<loader connection="1">
<asset id="image0" src="assets/img/image0.jpg" smoothing="true" transparent="true"/>
<asset id="image1" src="assets/img/image1.jpg" smoothing="true" transparent="true"/>
<group id="group0">
<group id="group00">
<asset id="image2" src="assets/img/image2.jpg" smoothing="true" transparent="true"/>
<asset id="image3" src="assets/img/image3.jpg" smoothing="true" transparent="true"/>
</group>
<group id="group01">
<asset id="css" src="assets/css/stylesheet.css" preventCache="true" weight="352"/>
<asset id="json" src="assets/json/data.json" preventCache="true" weight="582"/>
<asset id="sound" src="assets/sounds/sample.mp3" preventCache="true" weight="16718"/>
<asset id="text" src="assets/text/text.txt" preventCache="true" weight="574"/>
<asset id="xml" src="assets/xml/sample.xml" preventCache="true" weight="79"/>
<asset id="video" src="assets/video/sample.flv" weight="1550580"/>
<asset id="zip" src="assets/zip/file.zip" weight="3493"/>
</group>
</group>
</loader>

First step, I create a SomaCore application.

Plain Text

Actionscript:

public function Main() {
_app = new SomaApplication(this);
}

In the application facade, I create a command from a SomaAssets just to demo how to monitor the assets loading at a framework level. I also register 3 views and 3 mediators to show how to get the assets at different moments. I create the plugin SomaAssets and I finally create a simple wire class "InitializeWire" to handle some global events (config loaded, assets loaded, etc).

Plain Text

Actionscript:

package com.soma.plugins.assets.demo {
import com.soma.plugins.assets.demo.commands.ExampleAssetCommand;
import com.soma.plugins.assets.events.SomaAssetsEvent;
import com.soma.core.Soma;
import com.soma.core.di.SomaInjector;
import com.soma.core.interfaces.ISoma;
import com.soma.plugins.assets.SomaAssets;
import com.soma.plugins.assets.demo.views.ImageGroup;
import com.soma.plugins.assets.demo.views.ImageGroupMediator;
import com.soma.plugins.assets.demo.views.ImageWhenAllLoaded;
import com.soma.plugins.assets.demo.views.ImageWhenAllLoadedMediator;
import com.soma.plugins.assets.demo.views.ImageWhenNotLoaded;
import com.soma.plugins.assets.demo.views.ImageWhenNotLoadedMediator;
import com.soma.plugins.assets.demo.wires.InitializeWire;
import com.soma.plugins.assets.vo.SomaAssetsVO;
/**
* @author Romuald Quantin
*/
public class SomaApplication extends Soma implements ISoma {
private var _container:Main;
public function SomaApplication(container:Main) {
_container = container;
super(_container.stage, SomaInjector);
}
// create a command for a demo purpose to monitor the assets that are loaded
override protected function registerCommands():void {
addCommand(SomaAssetsEvent.ASSET_LOADED, ExampleAssetCommand);
}
// register mediators to views
// the views won't be created at the same moment to show how you can handle your loading
override protected function registerViews():void {
mediators.mapView(ImageWhenAllLoaded, ImageWhenAllLoadedMediator);
mediators.mapView(ImageWhenNotLoaded, ImageWhenNotLoadedMediator);
mediators.mapView(ImageGroup, ImageGroupMediator);
}
// create the plugin and register an external assets configuration to load
override protected function registerPlugins():void {
createPlugin(SomaAssets, new SomaAssetsVO(this, "xml/assets.xml"));
}
// create an wire where you could handle the "global" loading process
override protected function start():void {
injector.createInstance(InitializeWire);
}
// just the document class to add some views to
public function get container():Main {
return _container;
}
}
}

In the InitializeWire class, I add some event listeners to handle errors, when the XML config is loaded and when the assets are all loaded. I used it mostly to create views and mediators at different moments of the loading process to show you how to handle you loaders, events and assets.

Plain Text

Actionscript:

package com.soma.plugins.assets.demo.wires {
import com.soma.plugins.assets.demo.views.ImageGroup;
import com.soma.core.interfaces.IWire;
import com.soma.core.wire.Wire;
import com.soma.plugins.assets.demo.SomaApplication;
import com.soma.plugins.assets.demo.views.ImageWhenAllLoaded;
import com.soma.plugins.assets.demo.views.ImageWhenNotLoaded;
import com.soma.plugins.assets.events.SomaAssetsEvent;
import flash.display.DisplayObjectContainer;
import org.assetloader.core.IAssetLoader;
/**
* @author Romuald Quantin
*/
public class InitializeWire extends Wire implements IWire {
[Inject(name="assets")]
public var loader:IAssetLoader;
// register some SomaAssets events for monitoring
override public function initialize():void {
addEventListener(SomaAssetsEvent.CONFIG_LOADED, configLoaded);
addEventListener(SomaAssetsEvent.LOADER_COMPLETE, assetsComplete);
addEventListener(SomaAssetsEvent.ERROR, assetsErrorHandler);
}
// shortcut to get the document class
private function get container() isplayObjectContainer {
return SomaApplication(instance).container;
}
// in case there's an error for both the assets config or the assets
private function assetsErrorHandler(event:SomaAssetsEvent):void {
trace("Asset Error:", event.errorMessage, event.errorType);
}
// the external XML assets config has been loaded here
private function configLoaded(event:SomaAssetsEvent):void {
container.addChild(new ImageWhenNotLoaded());
container.addChild(new ImageGroup());
trace("config loaded");
loader.start();
}
// all assets container in the config XML have been loaded here
private function assetsComplete(event:SomaAssetsEvent):void {
container.addChild(new ImageWhenAllLoaded());
}
}
}

In the ImageWhenAllLoadedMediator mediator, I inject directly an asset (Bitmap) as everything is loaded when the mediator gets created.

Plain Text

Actionscript:

package com.soma.plugins.assets.demo.views {
import com.soma.core.interfaces.IMediator;
import com.soma.core.mediator.Mediator;
import flash.display.Bitmap;
/**
* @author Romuald Quantin
*/
public class ImageWhenAllLoadedMediator extends Mediator implements IMediator {
[Inject]
public var view:ImageWhenAllLoaded;
// all the assets are loaded at this point
// we can inject the asset (or loaders)
[Inject(name="image0")]
public var image:Bitmap;
override public function initialize():void {
image.scaleX = image.scaleY = 0.1;
image.x = 130;
view.addChild(image);
}
override public function dispose():void {
while (view.numChildren> 0) view.removeChildAt(0);
view = null;
image = null;
}
}
}

The ImageWhenNotLoadedMediator mediator gets created when the XML config has been loaded. The assets are not loaded yet and I show how to retrieve the loader of a specific asset to monitor when it starts, the loading progress and when it has been completed.

Plain Text

Actionscript:

package com.soma.plugins.assets.demo.views {
import flash.display.Bitmap;
import com.soma.core.interfaces.IMediator;
import com.soma.core.mediator.Mediator;
import org.assetloader.core.ILoader;
import org.assetloader.events.AssetLoaderErrorEvent;
import org.assetloader.events.AssetLoaderEvent;
import org.assetloader.events.AssetLoaderProgressEvent;
/**
* @author Romuald Quantin
*/
public class ImageWhenNotLoadedMediator extends Mediator implements IMediator {
[Inject]
public var view:ImageWhenNotLoaded;
// here we get the loader of an asset for monitoring purpose
// this one is an ImageLoader but we keep the interface as a type
[Inject(name="image1")]
public var imageLoader:ILoader;
// add some listeners to monitor the loading of a single loader
override public function initialize():void {
imageLoader.addEventListener(AssetLoaderErrorEvent.ERROR, errorHandler);
imageLoader.addEventListener(AssetLoaderEvent.START, startHandler);
imageLoader.addEventListener(AssetLoaderProgressEvent.PROGRESS, progressHandler);
imageLoader.addEventListener(AssetLoaderEvent.COMPLETE, completeHandler);
}
private function errorHandler(event:AssetLoaderErrorEvent):void {
trace("Error", event.errorType, event.message);
}
private function startHandler(event:AssetLoaderEvent):void {
trace("Loading started (" + ILoader(event.currentTarget).id + ")");
}
private function progressHandler(event:AssetLoaderProgressEvent):void {
trace("Loading progress (" + ILoader(event.currentTarget).id + ") progress:", event.progress, ", speed:", event.speed);
}
// the loader is complete, the asset is ready
private function completeHandler(event:AssetLoaderEvent):void {
trace("Loading completed (" + ILoader(event.currentTarget).id + ")");
var image:Bitmap = event.data;
image.scaleX = image.scaleY = 0.1;
view.addChild(image);
}
override public function dispose():void {
while (view.numChildren> 0) view.removeChildAt(0);
view = null;
imageLoader = null;
}
}
}

The ImageGroupMediator mediator does the same job as the mediator above but applied to an IAssetLoader (loader containing others loaders). The way to monitor the loading process is exactly the same. I also show different ways to retrieve the assets of this group, once the groupe has been loaded. You will notice the special injection name of the loader, it is a path generated from the XML config using the group and assets ids and a delimiter.

Plain Text

Actionscript:

package com.soma.plugins.assets.demo.views {
import flash.display.Bitmap;
import com.soma.plugins.assets.SomaAssets;
import com.soma.core.interfaces.IMediator;
import com.soma.core.mediator.Mediator;
import org.assetloader.core.IAssetLoader;
import org.assetloader.core.ILoader;
import org.assetloader.events.AssetLoaderErrorEvent;
import org.assetloader.events.AssetLoaderEvent;
import org.assetloader.events.AssetLoaderProgressEvent;
import flash.utils.Dictionary;
/**
* @author Romuald Quantin
*/
public class ImageGroupMediator extends Mediator implements IMediator {
[Inject]
public var view:ImageGroup;
// here we get the plugin
[Inject(name="assets")]
public var assets:SomaAssets;
// here we get a group using a path (ids + delimiter)
[Inject(name="group0/group00")]
public var imageGroup:IAssetLoader;
// add some listeners to monitor the loading of a single group
override public function initialize():void {
imageGroup.addEventListener(AssetLoaderErrorEvent.ERROR, errorHandler);
imageGroup.addEventListener(AssetLoaderEvent.START, startHandler);
imageGroup.addEventListener(AssetLoaderProgressEvent.PROGRESS, progressHandler);
imageGroup.addEventListener(AssetLoaderEvent.COMPLETE, completeHandler);
}
private function errorHandler(event:AssetLoaderErrorEvent):void {
trace("Error", event.errorType, event.message);
}
private function startHandler(event:AssetLoaderEvent):void {
trace("Loading started (" + ILoader(event.currentTarget).id + ")");
}
private function progressHandler(event:AssetLoaderProgressEvent):void {
trace("Loading progress (" + ILoader(event.currentTarget).id + ") progress:", event.progress, ", speed:", event.speed);
}
// now the group is loaded, get the 2 images from the group
private function completeHandler(event:AssetLoaderEvent):void {
trace("Loading completed (" + ILoader(event.currentTarget).id + ")");
var images:Dictionary = event.data;
trace("asset from dictionary", images["image3"]);
trace("asset from loader:", imageGroup.getAsset("image3"));
trace("asset from plugin:", assets.getAssets("group0/group00/image3"));
var image2:Bitmap = images["image2"];
var image3:Bitmap = images["image3"];
image2.x = 290;
image2.scaleX = image2.scaleY = 0.1;
image3.x = 340;
image3.scaleX = image3.scaleY = 0.1;
view.addChild(image2);
view.addChild(image3);
}
override public function dispose():void {
while (view.numChildren> 0) view.removeChildAt(0);
view = null;
imageGroup = null;
}
}
}

The ExampleAssetCommand command is just a demo to show that you can use the SomaAssetsEvent class to directly create commands from it. In this example I used the type SomaAssetsEvent.ASSET_LOADED. The command will get created every time an asset is loaded.

Plain Text

Actionscript:

package com.soma.plugins.assets.demo.commands {
import com.soma.core.controller.Command;
import com.soma.core.interfaces.ICommand;
import com.soma.plugins.assets.SomaAssets;
import com.soma.plugins.assets.demo.SomaApplication;
import com.soma.plugins.assets.events.SomaAssetsEvent;
import flash.display.DisplayObjectContainer;
import flash.events.Event;
import flash.media.Sound;
import flash.media.Video;
import flash.net.NetStream;
import flash.text.TextField;
import flash.utils.getQualifiedClassName;
/**
* @author Romuald Quantin
*/
public class ExampleAssetCommand extends Command implements ICommand {
[Inject]
public var evt:SomaAssetsEvent;
[Inject(name="assets")]
public var assets:SomaAssets;
// just some examples
public function execute(event:Event):void {
var container:DisplayObjectContainer = SomaApplication(instance).container;
trace("Command Example (" + evt.path + ")> " + assets.getLoader(evt.path).type + " Loaded: " + getQualifiedClassName(evt.asset));
// you can use a switch to find the assets:
switch (evt.path) {
case "group0/group01/css":
break;
case "group0/group01/json":
break;
case "group0/group01/sound":
var sound:Sound = evt.asset;
sound.play(0);
break;
case "group0/group01/text":
var textfield:TextField = new TextField();
textfield.multiline = textfield.wordWrap = true;
textfield.text = evt.asset;
container.addChild(textfield);
break;
case "group0/group01/xml":
break;
case "group0/group01/video":
var video:Video = new Video();
var stream:NetStream = evt.asset;
container.addChild(video);
video.y = 80;
video.smoothing = true;
video.attachNetStream(stream);
stream.resume();
break;
case "group0/group01/zip":
break;
}
}
}
}

This implementation is just an example as it could be handled in very different ways, but that should get you started.

No Comments »

03 06 2011

SomaCore plugin to load and manage assets: SomaAssets

Posted by: Romuald in SomaCore, talking, tags: as3, class, flash, flex, framework, SomaCore

Two new releases today, an asset loader and the SomaCore plugin: SomaAssets.

The AssetLoader library is a port from Matan's AssetLoader library to be event-based, it makes you able to load and manage multiple assets (image, video, xml, sound, etc) in your application.

SomaAssets is a plugin based on the AssetLoader library to easily access to your assets and effectively integrate them in your SomaCore application with paths and automatic mapping name generation for injection.

Special thanks to Matan for his help with the AssetLoader and his joy in general, a pleasure to "meet" him.

You can read the SomaAssets wiki section to get started with it, but I'll post below a few hints of what you can easily do with it within a SomaCore application.

AssetLoader source
AssetLoader wiki
SomaAssets source
SomaAssets wiki

Easily create the plugin and add a XML config file for the assets.

Plain Text

Actionscript:

createPlugin(SomaAssets, new SomaAssetsVO(this, "xml/assets_config.xml"))

Easily retrieve the assets with paths through the XML config.

Plain Text

Actionscript:

var image:Bitmap = assets.getAssets("group0/group00/img0");

Easily retrieve the plugin, main loader, config and assets with injection in a SomaCore application. The following mapping names have been automatically generated from the XML config.

Plain Text

Actionscript:

[Inject(name="assets")]
public var plugin:SomaAssets;
[Inject(name="assets")]
public var loader:IAssetLoader;
[Inject(name="group0/group00/img0")]
public var loaderType1:ImageLoader;
[Inject(name="group0/group00/img0")]
public var assetType1:Bitmap;

3 Comments »

14 03 2011

SomaCore wiki and framework flow

Posted by: Romuald in SomaCore, tags: as3, flash, flex, framework, SomaCore, tutorial

I've added some more information on the SomaCore wiki.

You can find some code and explanation how to use, create and remove Wires within the framework, using injection or not. I also explained how to monitor and control the application flow with methods you are used to, such as dispatchEvent, addEventListener, preventDefault and so on.

You can also find explanation to handle the views in the framework.

Last addition is a diagram showing the commands flow from other framework elements, I've added it to the previous SomaCore diagram.

Next step in the wiki are about commands and 2 others diagrams related to them.

Hope that will help to get you started.

No Comments »

09 02 2011

SomaCore tutorial framework instance

Posted by: Romuald in SomaCore, tags: air, as3, flash, flex, framework, SomaCore, tutorial

I'll be writing in the next days a series of wiki, manual, best practices with tons of code example. It should help you to get started. I will be explaining in-depth how SomaCore works and what you can do with it.

The first one is about the Framework Instance. The different ways to create a SomaCore application, what is required, how to enable dependency injection and how to access to this instance.

2 Comments »

07 02 2011

SomaCore AS3 MVC Framework v2 release

Posted by: Romuald in SomaCore, tags: air, as3, flash, flex, framework, soma, SomaCore

SomaCore is a lightweight AS3 MVC event-based framework that provides a very flexible structure for your Flash, Flex and AIR projects.

The main addition in this version 2 is Dependency Injection, but it is up to you how you want to use SomaCore because injection is optional.

Information

SomaCore Main Page (tutorials, demos, source)
Repository SomaCore (github)
Repository Demos (github)
Repository Plugins (github)
Documentation

Don't want to read, just show me some code!

SomaCore Hello World
SomaCore CafeTownSend (Flex)
Twitter Search demo (pure as3)

SomaCore is both a registry and dependency injection framework

As a base, SomaCore is a registry framework, much like PureMVC. The framework makes you able to add and remove elements to the framework instance to be able to access them from anywhere (such as addView, getView, addWire, getWire, addModel, getModel, addCommand, and so on).

Enable injection

You are now able to use dependency injection. It can be enabled by sending an ISomaInjector class to the constructor of the Soma class:

Plain Text

Actionscript:

public class SomaApplication extends Soma implements ISoma {
public function SomaApplication(stage:Stage) {
super(stage, SomaInjector);
}
}

The injector is accessible from framework instances, wires and commands using the property injector.

Here is a quick example:

Plain Text

Actionscript:

injector.mapToInstance(MyModel, new MyModel());
injector.mapSingleton(MyWire);
injector.getInstance(MyWire);

Plain Text

Actionscript:

package {
import com.soma.core.wire.Wire;
import com.soma.core.interfaces.IWire;
public class MyWire extends Wire implements IWire {
[Inject]
public var model:MyModel;
override public function initialize():void {
// called when the wire has been registered to the framework
trace(model, " is injected");
}
override public function dispose():void {
// called when the wire has been removed from the framework
}
}
}

Inspirations

Before going further, I have to give some credits.

When I first tried Robotlegs, one part strikes me as it was solving a problem I had for a while: The mediator system: being able to build your application and add mediators regardless of any kind of structure and very easily. This workflow was so nice that it made me rethink a lot of things.

SomaCore has some capabilities that made me build the framework and I wasn't ready to give them up. But I felt that this mediator workflow in SomaCore would just be amazing and a great addition.

I built these tools and frameworks to make my developer life easier, I then share them to other developers. If my work makes them enjoy their coding, that's good enough for me.

So before asking myself too many questions, I reproduced the mediator system in SomaCore. It is now very similar to Robotlegs but it can also be used without enabling injection. That is the first part of the credits: a big one to Robotlegs that has been an amazing inspiration to SomaCore, as big as PureMVC has been for the version 1.

The second credit would go to the library SwiftSuspenders, the same one that Robolegs is using to handle its dependency injection. It is very lightweight and has good performance.

Mediators

Here is how it works, you can map a view to another class (the mediator), and every time this "mapped view" will be added to a display list, the mediator class will be instantiated with a reference to this view. The mediator class will also be destroyed when the view is removed from the display list. Everything is automatic and handled by the framework.

In SomaCore the Mediator class is extending the Wire class which gives access to everything in the framework.

Mapping a view (example in a wire):

Plain Text

Actionscript:

mediator.mapView(MySprite, MySpriteMediator);

The mediator get instantiated when the view is added to the display list

Plain Text

Actionscript:

addChild(new MySprite());

Mediator example:

Plain Text

Actionscript:

package {
import com.soma.core.interfaces.IMediator;
import com.soma.core.mediator.Mediator;
public class MySpriteMediator extends Mediator implements IMediator {
[Inject]
public var view:MySprite;
override public function initialize():void {
// called when the mediator has been created and registered to the framework
trace(view == viewComponent);
}
override public function dispose():void {
// called when the mediator has been destroyed by the framework
}
}
}

From version 1 to version 2

Only minor changes:

1. initialize and dispose methods in wires and models are now public.

Plain Text

Actionscript:

package {
import com.soma.core.interfaces.IModel;
import com.soma.core.model.Model;
public class ModelExample extends Model implements IModel {
override public function initialize():void {
// called when the model has been registered to the framework
}
override public function dispose():void {
// called when the model has been removed from the framework
}
}
}

2. the framework instance property has changed from soma to instance.

Plain Text

Actionscript:

package {
import com.soma.core.wire.Wire;
import com.soma.core.interfaces.IWire;
public class WireExample extends Wire implements IWire {
override protected function initialize():void {
// called when the wire has been registered to the framework
trace("my framework instance:", instance)
}
override protected function dispose():void {
// called when the wire has been removed from the framework
}
}
}

3. a public setup method is available in your framework instance.

Plain Text

Actionscript:

var app:ISoma = new Soma();
app.setup(stage, SomaInjector);

4. an initialize and start protected methods have been added in the Soma instance.

Plain Text

Actionscript:

package {
import com.soma.core.Soma;
import com.soma.core.interfaces.ISoma;
import com.soma.core.di.SomaInjector;
import flash.display.Stage;
public class SomaApplication extends Soma implements ISoma {
public function SomaApplication(stage:Stage) {
super(stage, SomaInjector);
}
override protected function initialize():void {
}
override protected function registerCommands():void {
}
override protected function registerModels():void {
}
override protected function registerViews():void {
}
override protected function registerWires():void {
}
override protected function registerPlugins():void {
}
override protected function start():void {
}
}
}

SomaCore features

Here are some features that might makes you enjoy the framework.

Stage as single event dispatcher

SomaCore is using a single event dispatcher: the stage, and a system of event interception to handles its commands system. As the commands in SomaCore are normal built-in events with the property bubbles set to true, this makes you able to dispatch commands straight from a view removing potential layers (like mediators) to handles communications from the views to the framework.

This also makes you able to communicate between different modules (or swf files) as they all share the same stage.

Seamless commands and events integration

The commands in SomaCore are normal built-in events and the framework has a seamless integration with the flash event system. Seamless meaning that the built-in syntax is in use: dispatchEvent, addEventListener, and so on.

Plain Text

Actionscript:

addCommand(MyEvent.DO_SOMETHING, MyCommand);

Dispatch a command from a framework elements (wires, commands, models, etc) or views:

Plain Text

Actionscript:

dispatchEvent(new MyEvent(MyEvent.DO_SOMETHING));

Monitoring commands from wires, mediators, or models:

Plain Text

Actionscript:

addEventListener(MyEvent.DO_SOMETHING, myEventHandler);

Commands monitoring

This capability is probably one of the most important to me. SomaCore makes you able to listen to commands from any wires and mediators, but also makes you able to stop the execution of any command (if the event is set as cancelable) using event.preventDefault().

Plain Text

Actionscript:

package {
import com.soma.core.wire.Wire;
import com.soma.core.interfaces.IWire;
public class WireExample extends Wire implements IWire {
override public function initialize():void {
// called when the wire has been registered to the framework
addEventListener(MyEvent.DO_SOMETHING, myEventHandler);
}
private function myEventHandler(event:MyEvent):void {
// the command MyEvent.DO_SOMETHING has been dispatched
// I can monitor it here (possible from any wires and mediators)
// for some reasons, I decide to stop the execution of this command:
event.preventDefault();
}
override public function dispose():void {
// called when the wire has been removed from the framework
removeEventListener(MyEvent.DO_SOMETHING, myEventHandler);
}
}
}

Easy way to map a mediator to a view

This is the workflow I reproduced from Robotlegs. It allows you to build you application, let's say... complicated layouts, structure, tons of views, and so on. But at any point, if the framework needs to talk to a specific view, you can easily map a mediator to this view:

Plain Text

Actionscript:

mediator.mapView(MyView, MyViewMediator);

For the other way around: a view needs to talk to the framework, mediators are not necessarily needed as you can dispatch commands straight from views in SomaCore. The commands are just normal events. The only requirement is that the view needs to be on the stage (added to a display list, after a ADDED_TO_STAGE event) in order for the stage to get the command.

Flexibility (injection, not injection, or both)

As the injection is optional in the framework, you are free to code the way you like, in the registry way like PureMVC way or in the injection way like Robotlegs, or even using both ways in the same time.

For some reasons, you might want to avoid injection, describeType, getElementByName, not comfortable yet with the concept, portability, optimal performance for games, etc. This is still possible with SomaCore.

Here are the built-in registry methods without injection:

Plain Text

Actionscript:

addWire(MyWire.NAME, new MyWire());
getWire(MyWire.NAME);
addModel(MyModel.NAME, new MyModel());
getModel(MyModel.NAME);
addView(MY_SPRITE_NAME, new Sprite());
getView(MY_SPRITE_NAME);

With injection, you might do something like:

Plain Text

Actionscript:

injector.mapSingleton(MyModel);
injector.createInstance(MyWire);

Plain Text

Actionscript:

// MyWire injectee class
[Inject]
public var model:MyModel;

You can also use both:

Plain Text

Actionscript:

var wire:MyWire = new MyWire();
injector.mapToInstance(MyWire, wire);
addWire(MyWire.NAME, wire);

Making you able to get the wire back this 2 ways:

Plain Text

Actionscript:

[Inject]
public var wire:MyWire;

Plain Text

Actionscript:

getWire(MyWire.NAME)

Plugins system

An easy way to add plugins to the framework, the SomaDebugger is the first one but I have plans to write others.

Debugger

The SomaDebugger especially built to work with SomaCore (even if it can be used without).

Plain Text

Actionscript:

protected function registerPlugins():void {
createPlugin(SomaDebugger, new SomaDebuggerVO(this, SomaDebugger.NAME_DEFAULT, getCommands(), true, false));
}

Lightweight

SomaCore is lightweight, here are the size compiled of the framework:

9.46 KB (9 693 bytes) - injector not enabled
14.83 KB (15 185 bytes) - injector enabled

Next steps

I'll make new documents for code examples, best practices, and so on to help you get started.
Maybe a javascript version as a developer has made an amazing port of SomaCore.

If you're looking for more information about the dependency injection part before I write documents, check the README file from the injection library: SwiftSuspenders.

Try SomaCore out, it is really easy to get started with. You'll feel at home very quickly with its flexibility and well integrated command system with built-in events.

4 Comments »

Search
Categories
- BaseUI (10)
- experiments (13)
- SomaCore (5)
- SomaUI (17)
- talking (39)
Pages
- About
- Contact
- Downloads
  - BaseUI
  - FPS
  - SomaCore
  - SomaLoader
  - SomaText
  - SomaUI
  - TextGradient
- Forum
- Soma Protest
Twitter
- keep #github gh-pages in sync in the #git master branch as a submodule, great link! http://t.co/DIPrABjV 10:34:51 PM January 25, 2012 from Echofon Reply Retweet Favorite
- sorry I couldn't post it here! Go giant: https://t.co/dxvr0j1d #url #shortener 06:25:51 PM January 20, 2012 from Echofon Reply Retweet Favorite
- Is #Adobe, #Apple, #Microsoft and others supporting #SOPA? check the list at the end of this page if it is any real http://t.co/R7a2bzl0 03:14:50 PM January 19, 2012 from Echofon Reply Retweet Favorite
- I just received that #whatsapp hoax https://t.co/22YESwYx 02:39:28 PM January 19, 2012 from Echofon Reply Retweet Favorite
- Still in a #SOPA action, boycott SOPA products and stop buying products from 800 supporting SOPA companies. https://t.co/RM3grvGz 11:16:48 AM January 17, 2012 from Echofon Reply Retweet Favorite
@soundstep
Archives
- July 2011
- June 2011
- May 2011
- April 2011
- March 2011
- February 2011
- October 2010
- September 2010
- August 2010
- July 2010
- June 2010
- May 2010
- March 2010
- January 2010
- November 2009
- October 2009
- September 2009
- August 2009
- July 2009
- April 2009
- March 2009
- January 2009
- December 2008
- November 2008
- October 2008
- September 2008
- August 2008
- July 2008
- June 2008
- May 2008
- April 2008
Recent Posts
Recent Comments
- Julienne Mozena on SomaTween proxy for Tweener TweenMax and GTween
- auto verzekeren on SomaUI update for Flex SDK 4
- hemgui on BaseUI
- hemgui on BaseUI
- Pierre on SomaUI
Tags

3D Add new tag air as2 as3 BaseUI class css data management experiment flash flex framework html javascript liquid layout liquid UI papervision3D soma SomaCore SomaUI tutorial
Soundstep RSS

Posts Tagged “framework”

SomaAssets demo

SomaCore plugin to load and manage assets: SomaAssets

SomaCore wiki and framework flow

SomaCore tutorial framework instance

SomaCore AS3 MVC Framework v2 release

Information

Don't want to read, just show me some code!

SomaCore is both a registry and dependency injection framework

Enable injection

Inspirations

Mediators

From version 1 to version 2

SomaCore features

Stage as single event dispatcher

Seamless commands and events integration

Commands monitoring

Easy way to map a mediator to a view

Flexibility (injection, not injection, or both)

Plugins system

Debugger

Lightweight

Next steps

Search

Categories

Pages

Twitter

Archives

Recent Posts

Recent Comments

Tags

Soundstep RSS