Due to some bugs and questions with the old tutorial, I’m creating this new one, much more simpler and less bugs than the another one. I’ll not post the old link here because everything you need to know you can find right here.

Nowadays, exist few alternatives to create a Framework to iOS, changing the default Xcode Script, which could not be a good choice if you want to publish the APPs constructed with your custom Framework. I’ll treat here about how to construct an Universal Framework to iOS, using the default tools from Xcode.

Let’s start!

Here is a little list of contents to orient your reading:

You can download the project I used in this article:

Download now
Xcode project files to Framework-iOS
403kb

FAQ

top
First off, I want to make sure you understand what this Framework to iOS can do, this can safe your time reading this article:

1. Can I use this Framework as a Bundle to store my files, XIBs, images?
   A: Yes, you can and now it’s very very easy to retrieve your files.
2. Can I use this Framework to import other Frameworks, like import UIKit, CoreGraphics, OpenGL?
   A: No. There is no way to do that. Your code in this custom Framework can import classes from other frameworks normally, but it is just a reference, classes from another framework will not be compiled at this time. So you must import the referenced Framework on the new project as well.
3. Will be my code visible to others?
   A: No. This Framework will export a compiled binary, so anyone can see inside it. You can make the same for some other files, like XIBs.
4. Why I need this?
   A: This is for developers/teams that want to share their codes without shows the entire code (.m/.c/.cpp files). Besides this is for who want to organize compiled code + resources (images, videos, sounds, XIBs, plist, etc) into one single place. And this is also for that teams that want to work together above the same base (framework).

Framework on iOS? Really?

top
Ok buddies, let’s make something clear, many people had said:”iOS doesn’t support custom Frameworks!”, “Custom Framework is not allowed at iOS!”, “Doesn’t exist custom Framework on iOS!” and many other discouraging things like these. Look, I’ve made many frameworks and worked with many others, I don’t believe that is really impossible to use a Framework on iOS. According to my experience and knowledge about Frameworks, it’s absolutely feasible a custom Framework on iOS Devices. If we think more about this issue we can find an elegant solution, right? First, let’s understand what a Framework really is, here is the definition of framework by Apple’s eyes:

A framework is a hierarchical directory that encapsulates shared resources, such as a dynamic shared library, nib files, image files, localized strings, header files, and reference documentation in a single package.

Doesn’t make many sense something with this description not be allowed in iOS, thinking in architecture and structure. Apple also says:

A framework is also a bundle and its contents can be accessed using Core Foundation Bundle Services or the Cocoa NSBundle class. However, unlike most bundles, a framework bundle does not appear in the Finder as an opaque file. A framework bundle is a standard directory that the user can navigate.

Good, now thinking about iOS security, performance and size, the only thing in a Framework definition which doesn’t fit in iOS technology is the “dynamic shared library”. The words “dynamic” and “shared” are not welcome in the iOS architecture. So the Apple allows us to work and distribute something called “Static Library“. I don’t like it! It’s not so easy as a Cocoa Framework, if a developer got your Static Library, he needs to set a header path too, or import the header files… it’s not useful, that’s a shit!

Well, so a Framework concept is absolutely compatible with iOS, except by the “dynamic shared library”, on the other hand Apple says that a “static library” is OK for iOS. So if we replace the “dynamic shared libraries” by a “static library” we could construct a Custom Framework to iOS, right?

Right!!!!

This is exactly what we’ll make in this article, let’s construct a Framework with Static Library, by the way, an Universal Framework.

Understanding Universal, Dynamic and Static concepts

top
Simple answer:

• Universal: Which works perfect on all architectures. iOS devices uses armv6 and armv7, iOS simulator on MacOS X uses i386.
• Dynamic: The compiler doesn’t include the target files directly. The classes/libraries are already pre-compiled (binary format) and lies on the system path. Besides, the dynamic libraries can be shared by many applications. This is exactly what Cocoa Framework is.
• Static: It represents that classes/libraries which is compiled by the compiler at the build phase. These files can’t be shared by other applications and relies on application path.

Simple as that. If you need more informations about Dynamic VS Static libraries, try this Apple’s Documentation.

No more concepts, hands at work!

Constructing a Framework Project

top

1. Create the Project:

top
I want to show you step by step of the entire process, so let’s start with the most basic, create an iOS project. You can choose one application template in Xcode, this is not really important, but remember to choose one template which could test your Framework code before export it.

Create an application project.

2. Framework Classes:

top

Create your framework classes.

Remember to create an “import header” to make everything simpler and organized to the user of your framework. Remember to write this header file with a framework notation, just as shown in the image bellow. Also remember to create your classes taking care to hide the classes which should not be visible to the other developers (users of your framework). We will set the public and private headers soon, but it’s very important to you protect the “core” classes, I mean, that classes which you don’t want to make visible to other developers.

For those private classes, you could import their header inside the “.m” (or .mm, .cpp, etc) file of a public class, by doing this you protect the header of private classes. Well, I know you probably already know that, I’m saying just to reinforce.

Remember that organization is 90% of a good framework, so try follow all the Apple advices to create your classes names, methods, properties, functions, etc.

Creating the Framework

top

3. Create a Framework Target:

top
OK, let’s create a target to compile our framework. Click on the icon of your project in the project navigator at the left and hit the button “Add Target”. A new window will come up. Now is our first trick. Instead to create a “Cocoa Touch Static Library” or a “Cocoa Framework” we will create a “Bundle” target.

A Bundle? Really? Yes! I can explain. A “Cocoa Framework” target can’t be compiled to armv6/armv7 and Xcode doesn’t allow us to use “Static Libraries” in a “Cocoa Framework”, so we can’t use this target. On the other hand, we can’t use “Cocoa Touch Static Library” either, because it doesn’t use the framework structure that we want.

Now, the Bundle target could be the best choice. It can hold any file we want, we can compile source code inside it and… we can turn it into a framework. To say the truth, almost all “Framework & Library” targets could be turned into a framework too, even the “Cocoa Touch Static Library”, throughout this article you probably will figure out how. For now, let’s create a Bundle target.

Create a Bundle target rather than Cocoa Touch Static Library.

4. Bundle Setup:

top
It’s time to make all the necessary changes to the Bundle target. Different than the old tutorial. You don’t need to clean up anything. Just know that everything else will be ignored (linked frameworks .plist files, .pch etc…).

I’m sure you already know this, but just to reinforce, here is the Build Setting screen, you can find it by clicking on the project icon in the left project navigator and then clicking in the “Build Setting” tab.

You must make a special Build Setting to turn a Bundle into a framework.

Here is our second great trick, or should be better to say “tricks”. Let’s change the “Build Setting” following this list:

• Base SDK: Latest iOS (iOS X.X) (in the X.X will appear the number of the lastest iOS SDK installed on your machine).
• Architectures: $(ARCHS_STANDARD_32_BIT) armv6 (it’s very important to be exactly this value including the space before “armv6″) This setting is valid to Xcode 4.2, if you are using an old version, use the “Standard (armv6 armv7)” option. (the values for this property depend on the value of the item bellow, so set that first).
• Build Active Architecture Only: NO (otherwise we can’t compile to armv6 and armv7 at the same time).
• Valid Architecture: $(ARCHS_STANDARD_32_BIT) (it’s very important to be exactly this value). If your Xcode is showing two lines with armv6 and armv7, delete then and insert this value in one single line.
• Dead Code Stripping: NO.
• Link With Standard Libraries: NO.
• Mach-O Type: Relocatable Object File. This is the most important change. Here, we instruct the compiler to treat the Bundle as a relocatable file, by doing this, we can turn it into a framework with the wrapper setting.
• Other Linker Flags: This setting is not mandatory, but if you are planning to use any kind of C++ code (.cpp or .mm) on this framework, Chris Moore (on the comments) advises to use the “-lstdc++” option. In this case could be a good idea to use “-ObjC” too, to avoid conflicts in old compilers.
• Wrapper Extension: framework. Here we change the Bundle to a Framework. To Xcode, frameworks is just a folder with the extension .framework, which has inside one or more compiled binary sources, resources and some folders, a folder, usually called Headers, contains all the public headers.
• Generate Debug Symbols: NO (this is a very important setting, otherwise the framework will not work on other computers/profiles).
• Precompile Prefix Header: NO.
• Prefix Header: “”. (Leave it blank).

IMPORTANT: Since the Xcode 4.x the architectures armv6 has no longer support. So, to create a real Universal Framework we must make a small “hack”:

1. After change the settings above close the Xcode, find the .xcodeproj (the project file) in Finder and then “Show Package Contents”.
2. Open the file “project.pbxproj” into a text editor.
3. Delete all the lines with VALID_ARCHS = “$(ARCHS_STANDARD_32_BIT)”.

5. Adding code and resources to the Bundle (Framework)

top
It’s time to place the content in our framework and define the public headers. To do that, with the Bundle target selected, click on the “Build Phase” tab. At bottom, hit the button “Add Phase” and then “Add Copy Headers“.

Open the recently created “Copy Headers” section and separate your public headers from the private or project headers. The difference here is:

• Public: Headers that other developers must know in order to work with your framework. In the final framework product, these headers will be visible even to Xcode.
• Private: Headers that is not necessary to other developers, but is good for consult or for reference. These headers will not be visible to Xcode, but will be in the framework folder.
• Project: Headers that the other developers nor Xcode have access. In reality these headers will not be placed in the final product, this is just to instruct the compiler to create your custom framework.

Now, open the “Compile Source” section and put there all your .m, .c, .mm, .cpp or any other compilable source file.

If your framework include not compilable files, like images, sounds and other resources, you can place them in the “Copy Bundle Resources” section. Later, when we generate the final framework, all your resources will be placed in a folder called “Resources”, but you can change it. That folder is very important, because it will be part of the path to retrieve your resources from the framework product.

Tip: To add many files at once, click on the “+” button and write the files’ extension on the search field. For example “.m”, “.c”, “.cpp”, “.h”, etc. This can save a lot of time.

This is how your “Build Phase” will looks like:

Define your compilable source and the headers.

Building the Universal Framework

top

6. Creating Universal Target:

top
To join both architectures products into one, we must to use the Lipo Tool. It’s a tool which comes with iOS SDK, just to know, it is in “/Platforms/iPhoneOS.platform/Developer/usr/bin”, its file name is “lipo”. But we don’t need to know this path, Xcode can deal with it to us.

Add a new target, hit the “Add Target” button, just as you did with Bundle Target. At this time a good choice is the “Aggregate” target. It doesn’t create any product directly, its purposes is just to aggregate another targets and/or run some scripts, exactly what we want! To use the Lipo Tool we’ll need to create a “Run Script” at the “Build Phase“.

Use the "Aggregate" target to construct a run script.

7. Lipo Tool Script:

top
This will be our greatest trick. The following script will make everything we need. It will compile the Framework Target to iOS Device and Simulator at once, will merge them with Lipo tool and will organize a good Framework Bundle structure.

Copy and paste this on your “Run Script” phase:

# Sets the target folders and the final framework product.
FMK_NAME=FI
FMK_VERSION=A

# Install dir will be the final output to the framework.
# The following line create it in the root folder of the current project.
INSTALL_DIR=${SRCROOT}/Products/${FMK_NAME}.framework

# Working dir will be deleted after the framework creation.
WRK_DIR=build
DEVICE_DIR=${WRK_DIR}/Release-iphoneos/${FMK_NAME}.framework
SIMULATOR_DIR=${WRK_DIR}/Release-iphonesimulator/${FMK_NAME}.framework

# Building both architectures.
xcodebuild -configuration "Release" -target "${FMK_NAME}" -sdk iphoneos
xcodebuild -configuration "Release" -target "${FMK_NAME}" -sdk iphonesimulator

# Cleaning the oldest.
if [ -d "${INSTALL_DIR}" ]
then
rm -rf "${INSTALL_DIR}"
fi

# Creates and renews the final product folder.
mkdir -p "${INSTALL_DIR}"
mkdir -p "${INSTALL_DIR}/Versions"
mkdir -p "${INSTALL_DIR}/Versions/${FMK_VERSION}"
mkdir -p "${INSTALL_DIR}/Versions/${FMK_VERSION}/Resources"
mkdir -p "${INSTALL_DIR}/Versions/${FMK_VERSION}/Headers"

# Creates the internal links.
# It MUST uses relative path, otherwise will not work when the folder is copied/moved.
ln -s "${FMK_VERSION}" "${INSTALL_DIR}/Versions/Current"
ln -s "Versions/Current/Headers" "${INSTALL_DIR}/Headers"
ln -s "Versions/Current/Resources" "${INSTALL_DIR}/Resources"
ln -s "Versions/Current/${FMK_NAME}" "${INSTALL_DIR}/${FMK_NAME}"

# Copies the headers and resources files to the final product folder.
cp -R "${DEVICE_DIR}/Headers/" "${INSTALL_DIR}/Versions/${FMK_VERSION}/Headers/"
cp -R "${DEVICE_DIR}/" "${INSTALL_DIR}/Versions/${FMK_VERSION}/Resources/"

# Removes the binary and header from the resources folder.
rm -r "${INSTALL_DIR}/Versions/${FMK_VERSION}/Resources/Headers" "${INSTALL_DIR}/Versions/${FMK_VERSION}/Resources/${FMK_NAME}"

# Uses the Lipo Tool to merge both binary files (i386 + armv6/armv7) into one Universal final product.
lipo -create "${DEVICE_DIR}/${FMK_NAME}" "${SIMULATOR_DIR}/${FMK_NAME}" -output "${INSTALL_DIR}/Versions/${FMK_VERSION}/${FMK_NAME}"

rm -r "${WRK_DIR}"

Now build the Aggregate target. Doesn’t matter you build for iOS Device or Simulator, this script will create a working folder, compile the framework target twice in there (device + simulator) and will output a folder called “Products” located in the project root folder. There is your Universal Framework to iOS!

Congratulations!

Importing your Universal Framework

top

8. Importing:

top
To test your Universal Framework, create a new Xcode project, select the Application target and go to “Build Phase” tab. Open the section “Link Binary With Libraries” and hit the “+” to add a new Framework. Click the “Add Other…” button and select your Universal Framework. Remember, you must to select the “.framework” folder. Remember to import your Framework Principal Header as a framework notation. Xcode will use your public headers in the Code Completion.

Let’s understand what happens until here:
When we set the “Mach-O Type” to “Relocatable Object File” the Xcode understand that everything related to that package will be like a “Binary Archive” like a ZIP. But that archive must be compiled again in new projects.

Then, when we create a Framework Bundle structure, Xcode understand that everything inside it is organized in folders like “Headers” and . But, as any other external bundle, to retrieve the resources you must load the external bundle. To iOS this could be an annoying step, however our Framework structure can help. Just Click and Drag on your Framework icon from “Project Navigator” to the “Copy Bundle Resources“. By doing this all the resources in your Framework will be copied to your Application Main Bundle.

Now, to retrieve the resources, make use of the main bundle, just as you are used to:

[[NSBundle mainBundle] pathForResource:@"FI.framework/Resources/FileName"
                                ofType:@"fileExtension"];

Conclusion

top
Well done, my friends! As we are used, let’s make a final review and take care with some possible problems.

• In a common Xcode project, create a Bundle target.
• Make the necessary setup, place your sources, headers and resources in it.
• Create an Aggreate target and place a Run Script in it.

One last advice: Take care with your classes structure. If you set, for example, the ClassB.h as a Project or Private header, but in your code you import it into a Public header, this will cause conflicts.

And one last tip: Notice in the sample project I removed the scheme for the “Bundle Target”. We don’t need that scheme any more, because the new script will manage the compilation to us.

That’s all, buddies.
Enjoy your Framework to iOS!

Thanks for reading,
See you soon!

After long months, just waiting for a single day, was a long wait, I know, but today the things will change a little bit. Today is THAT day.

After working through the nights, polishing every piece of code, thinking and rethinking routines… finally IT is here!

I’m very very happy to announce that NinevehGL is HERE!

Ladies and Gentlemen

With a great pleasure, let me introduce you the NinevehGL!

Keep it Simple

You know me, I’m so bored with many web sites, softwares, 3D engines and technologies that make our life a hell with their docs (or the absence of docs), poor tutorials, complex setups, complex API or even worst… they are paid! God Dammit!!!

• So, let’s try something different, something simple! Starting with the web site: nineveh.gl, just it, simple and easy.
• What about tutorials or docs? Very simple: http://nineveh.gl/docs/tutorials/, video tutorials!
• Long time to learn? Maybe… what do you think about just 30 min? 10 videos, 3 min each one. Sounds good?

Awesome features

There are many cool features in NinevehGL. But I think 3 are the “Killer Features”:

• OpenGL ES 2.0 (Programmable Pipeline): It uses the newest OpenGL ES version. More power, faster, lighter, better and shaders! With NinevehGL you can use all the power of the shaders and programmable pipeline.
• Import directly from 3D softwares! NinevehGL doesn’t need plugins or special 3D formats to import your files! Make use of Wavefront OBJ files or COLLADA files (all 3D softwares export one of them). NinevehGL is ready to import them.
• Made with pure Objective-C (Obj-C)! Yes, as an iOS developer, when I use OpenGL I expect to see Obj-C code, not C++ or C. NinevehGL is purely made with the native iOS language. Classes and routines follow all the Apple/Cocoa Touch guidelines.

Well, another great thing about NinevehGL is that it’s FREE! A 3D engine for iOS totally FREE!

This is a short post just to tell you about this great news. I hope you like it.

See you, guys!

I felt a good impulse to write a little article about this theme, because there are few poor informations about it around the web. In many cases, are wrong or incomplete informations. So if you want to write a framework to iPhone and distribute it, you are in the right place!

I’ll treat here about how to construct an Universal Framework to iOS, what are the necessary configurations and everything else related to. We’ll focus on Xcode 4, but this is also valid to Xcode 3.x.

Let’s start!

–WARNING–

This content is outdated! There is a new version of this article (2.0) teaching how to create an Universal Framework to iOS, much simpler and reliable:
http://db-in.com/blog/2011/07/universal-framework-iphone-ios-2-0/

Here is a little list of contents to orient your reading:

You can download the project I used in this article:

Download now
Xcode project files to Framework-iOS
403kb

Framework on iOS? Really?

top
Ok buddies, let’s make something clear, many people had said:”iOS doesn’t support custom Frameworks!”, “Custom Framework is not allowed at iOS!”, “Doesn’t exist custom Framework on iOS!” and many other discouraging things like these. Look, I’ve made many frameworks and worked with many others, I don’t believe that is really impossible to use a Framework on iOS. According to my experience and knowledge about Frameworks, it’s absolutely feasible a custom Framework on iOS Devices. If we think more about the issue we can find an elegant solution, right? First, let’s understand what a Framework really is, here is the definition of framework by Apple’s eyes:

A framework is a hierarchical directory that encapsulates shared resources, such as a dynamic shared library, nib files, image files, localized strings, header files, and reference documentation in a single package.

Doesn’t make many sense something with this description not be allowed in iOS, thinking in architecture and structure. Apple also says:

A framework is also a bundle and its contents can be accessed using Core Foundation Bundle Services or the Cocoa NSBundle class. However, unlike most bundles, a framework bundle does not appear in the Finder as an opaque file. A framework bundle is a standard directory that the user can navigate.

Good, now thinking about iOS security, performance and size, the only thing in a Framework definition which doesn’t fit in iOS technology is the “dynamic shared library”. The words “dynamic” and “shared” are not welcome in the iOS architecture. So the Apple allows us to work and distribute something called “Static Library“. I don’t like it! It’s not so easy as a Cocoa Framework, if a developer got your Static Library, he needs to set a header path too, or import the header files… it’s not useful, that’s a shit!

Well, so a Framework concept is absolutely compatible with iOS, except by the “dynamic shared library”, on the other hand Apple says that a “static library” is OK for iOS. So if we replace the “dynamic shared libraries” by a “static library” we could construct a Custom Framework to iOS, right?

Right!!!!

This is exactly what we’ll make in this article, let’s construct a Framework with Static Library, by the way, an Universal Framework.

Understanding Universal, Dynamic and Static concepts

top
Simple answer:

• Universal: Which works perfect on all architectures. iOS devices uses armv6 and armv7, iOS simulator on MacOS X uses i386.
• Dynamic: The compiler doesn’t include the target files directly. The classes/libraries are already pre-compiled (binary format) and lies on the system path. Besides, the dynamic libraries can be shared by many applications. This is exactly what Cocoa Framework is.
• Static: It represents that classes/libraries which is compiled by the compiler at the build phase. These files can’t be shared by other applications and relies on application path.

Simple as that. If you need more informations about Dynamic VS Static libraries, try this Apple’s Documentation.

No more concepts, hands at work!

Constructing a Framework Project

top

1. Create the Project:

top
I want to show you step by step of the entire process, so let’s start with the most basic, create an iOS project. You can choose one application template in Xcode, this is not really so important, but remember to choose one template which could test your Framework code before export it.

Create an application project.

2. Framework Classes:

top

Create your framework classes.

Remember to create an import header to make everything more simple and organized to the user of your framework. Remember to write this header file with a framework notation, just as shown in the image bellow. Also remember to create your classes taking care to hide the classes which should not be visible to the other developers (users of your framework). We will set the public and private headers soon, but it’s very important to you protect the “core” classes, I mean, that classes which you don’t want to make visible to other developers.

For those private classes, you could import their header inside the “.m” (or .mm, .cpp, etc) file of a public class, by doing this you protect the header of private classes. Well, I know you probably already know that, I’m saying just to reinforce.

After you have all the classes (and also other files, like images, sounds, etc.), you are ready to compile a custom framework. In the next step, we’ll create a target to compile our framework, this will be our first big trick!

Create your framework header with framework notation.

Compiling a Framework

top

3. Create a Framework Target:

top
OK, let’s create a target to compile our framework. Click on the icon of your project in the project navigator at the left and hit the button “Add Target”. A new window will come up. Now is our first trick. Instead to create a “Cocoa Touch Static Library” or a “Cocoa Framework” we will create a “Bundle” target.

A Bundle? Really? Yes! I can explain. A “Cocoa Framework” target can’t be compiled to armv6/armv7 and Xcode doesn’t allow us to use “Static Libraries” in a “Cocoa Framework”, so we can’t use this target. On the other hand, we can’t use “Cocoa Touch Static Library” either, because it doesn’t use the framework structure that we want.

Now, the Bundle target could be the best choice. It can hold any file we want, we can compile source code inside it and… we can turn it into a framework. To say the truth, almost all “Framework & Library” targets could be turned into a framework too, even the “Cocoa Touch Static Library”, throughout this article you probably will figure out why. For now, let’s create a Bundle target.

Create a Bundle target rather than Cocoa Touch Static Library.

4. Bundle Setup:

top
It’s time to make all the necessary changes to the Bundle target. First of all, make sure you have cleaned up all the default files from the Bundle target. Remove the linked frameworks (you can find it clicking in the “Build Phase” tab and then they are in the section “Link Binary With Libraries“) and delete the Preference List file (.plist), the pre-compiled headers (.pch) and the language files.

I’m sure you already know this, but just to reinforce, here is the Build Setting screen, you can find it by clicking on the project icon in the left project navigator and then clicking in the “Build Setting” tab.

You must make a special Build Setting to turn a Bundle into a framework.

Here is our second great trick, or should be better to say “tricks”. Let’s change the “Build Setting” following this list:

• Architectures: Standard (armv6 armv7) (the values for this property depend on the value of the item bellow).
• Base SDK: Latest iOS (iOS X.X) (in the X.X will appear the number of the lastest iOS SDK installed on your machine).
• Build Active Architecture Only: NO (this is a very important set, if it’s YES then we can’t compile to armv6 and armv7 at the same time).
• Supported Platforms: iphonesimulator iphoneos.
• Valid Architecture: $(ARCHS_STANDARD_32_BIT) (it’s very important to be exactly this value, seems there is a bug in Xcode 4, once you set i386 as supported platforms to iOS, it can’t be removed anymore and it could generate errors in your project. So, to avoid any architectures error, use this value).
• Installation Directory: [optional change] I like to set this to $(BUILT_PRODUCTS_DIR), but this is not really relevant to our purposes here. You can set it to a path of your choice.
• Mac OS X Deployment Target: Compiler Default.
• Dead Code Stripping: NO.
• Link With Standard Libraries: NO.
• Mach-O Type: Relocatable Object File. This is the most important change. Here, we instruct the compiler to treat the Bundle as a relocatable file, by doing this, we can turn it into a framework with the wrapper setting.
• Other Linker Flags: [optional change] -ObjC, could be good make sure the compiler understands what’s the language it is compiling for, this can reduce the warnings at the compilation.
• Info.plist File: empty, remove any value from this field.
• Wrapper Extension: framework. Here we change the Bundle to a Framework. To Xcode, frameworks is just a folder with the extension .framework, which has inside one or more compiled binary sources, resources and some folders, a folder, usually called Headers, contains all the public headers.
• Precompile Prefix Header: NO.
• Prefix Header: empty, remove any value from this field.
• Generate Debug Symbols: NO (this is a very important setting, otherwise your framework will not work on another computer/profile).

5. Adding code and resources to the Bundle (Framework)

top
It’s time to place the content in our framework and define the public headers. To do that, with the Bundle target selected, click on the “Build Phase” tab. At bottom, hit the button “Add Phase” and then “Add Copy Headers“.

Open the recently created “Copy Headers” section and separate your public headers from the private or project headers. The difference here is:

• Public: Headers that other developers must know in order to work with your framework. In the final framework product, these headers will be visible even to Xcode.
• Private: Headers that is not necessary to other developers, but is good for consult or for reference. These headers will not be visible to Xcode, but will be in the framework folder.
• Project: Headers that the other developers nor Xcode have access. In reality these headers will not be placed in the final product, this is just to instruct the compiler to create your custom framework.

Now, open the “Compile Source” section and put there all your .m, .c, .mm, .cpp or any other compilable source file. If your framework include not compilable files, like images, sounds and other resources, you can place them in the “Copy Bundle Resources” section, in the example of this article, I used no resources. This is how your “Build Phase” will looks like:

Define your compilable source and the headers.

6. Schemes Setup

top
This is an important change to compile our framework. You don’t need to compile it in the Debug modes, we just need the Release mode, because if you have any Macro in your code which works only in Debug mode, like DEBUG macro, it will assume the configuration of the product that the other developers will make. So to us now, only the Release is important.

You can change it accessing the menu Product > Manage Schemes… or by the schemes short cut: the drop list in front at the Build/Run bottom in the top left corner of the Xcode window.

At this point could be a good idea to delete all the current schemes and then press the button “AutoCreate Schemes Now“. The important is select your framework target and hit the button “Edit” at the bottom. In the next window, change the “Build Configuration” from Debug to Release. Change to Release in all the situations: Run, Test, Profile, Analyze and Archive. By doing this, we ensure that our framework target will always compile the Release version.

Build the custom framework only to Release.

7. Building the Framework

top
OK, here is the annoying step of this process. Until now, I don’t figure out a more easy an elegant way to do this. You must to compile this target twice: one to iOS Device (this will compile for the architectures armv6/arvm7) and to iOS Simulator (can be iPhone or iPad with any SDK, doesn’t matter, the simulator always will compile for the architecture i386).

I’ve tried another way, like create an “integrator” and I placed two targets to its “Target Dependencies”, but trust me, it’s worst, because you need to change 2 targets instead 1 in cases when you change the framework content. Besides, the dependencies will assume the architectures of the “integrator”, so you need to compile twice too. Anyway… the best solution I found until now is use only 1 target and build it twice. If you find a better one, please tell me.

Compile the framework target twice: iOS Device and Simulator.

After the compile complete, you can see in the “Products” folder in the Project Navigator at the left, that your framework product now is active. Right click on it and hit “Show in Finder“. Take a look at this product, its is your iOS Framework! Great!

But we’re not done yet. You can test this product in other applications if you want, but it will only work to one architecture. We must to create an Universal version of this product. If you look around your framework product in the Finder, you’ll see that it is in a folder called “Release-iphoneos” (if you didn’t change the destination folder in the Build Settings). And if you have compiled to Simulator too, you’ll see another folder called “Release-iphonesimulator” which contains the same framework product, but this version is for architecture i386.

So, let’s join both products into one.

Building the Universal Framework

top

8. Creating Universal Target:

top
To join both architectures products into one, we must to use the Lipo Tool. It’s a tool which comes with iOS SDK, just to know, it is in “/Platforms/iPhoneOS.platform/Developer/usr/bin”, its file name is “lipo”. But we don’t need to know this path, Xcode can deal with it to us.

To use the Lipo Tool we’ll need to create a “Run Script” at the “Build Phase“, you can create it in your previously Bundle Target, but my advice is to create another target. I say to create another target to avoid compiling errors. This script will need to use “Release-iphoneos” and “Release-iphonesimulator” folders, so if the folders or products inside them not exist yet, the compiler will generate errors.

Let’s add a new target, hit the “Add Target” button, just as you did with Bundle Target. At this time a good choice is the “Aggregate” target. It doesn’t create any product directly, its purposes is just to aggregate another targets and run some scripts, exactly what we want!

Use the "Aggregate" target to construct a run script.

9. Lipo Tool Script:

top
We are almost there, now it’s time to create the Run Script to use the Lipo Tool. Well, you probably will need to make some changes in the code bellow to fit it to your framework name or folders (if you set different folders to build for). Here is the script to use:

.
if [ "${ACTION}" = "build" ]
then
# Set the target folders and the final framework product.
    INSTALL_DIR=${SYMROOT}/FI.framework
    DEVICE_DIR=${SYMROOT}/Release-iphoneos
    SIMULATOR_DIR=${SYMROOT}/Release-iphonesimulator

# Create and renews the final product folder.
    mkdir -p "${INSTALL_DIR}"
    rm -rf "${INSTALL_DIR}"
    rm -rf "${INSTALL_DIR}/FI"

# Copy the header files to the final product folder.
    ditto "${DEVICE_DIR}/FI.framework/Headers" "${INSTALL_DIR}/Headers"

# Use the Lipo Tool to merge both binary files (i386 + armv6/armv7) into one Universal final product.
    lipo -create "${DEVICE_DIR}/FI.framework/FI" "${SIMULATOR_DIR}/FI.framework/FI" -output "${INSTALL_DIR}/FI"
fi
.

Lipo script to join products for architectures i386 and armv6/armv7.

Now build the Aggregate target. At this time doesn’t matter if you build for iOS Device or Simulator, because all that it will make is run the script, nothing more. The above script creates the final Universal Framework at the ${SYMROOT} path, this is the same path of your Bundle target. So you can right click on the Framework product in the “Products” again and hit “Show in Finder”. Move to the level with “Release-iphoneos” and “Release-iphonesimulator” folders. Now, there is a new folder with the “.framework” extension, it’s your Universal Framework to iOS!

Congratulations!

Testing your Universal Framework

top

10. Testing:

top
To test your Universal Framework could be a good idea take it from that folder and place it in another one more easy to find, like the Desktop or ~/Library/Frameworks. Well, to avoid take it from that folder every time, you can change the Run Script above. Just change the “INSTALL_DIR” variable and set a path of your choice, make sure you choose a path with the write permissions. A good choice could be use the Xcode variable ${SRCROOT} which represents your project folder root, so you can set ${SRCROOT}/Products or something like that.

Anyway, with your Universal Framework in an “user friendly path”, create a new Xcode project, select the Application target and go to “Build Phase” tab. Open the section “Link Binary With Libraries” and hit the “+” to add a new Framework. Click the “Add Other…” button and select your Universal Framework. Remember, you must to select the “.framework” folder.

After the importing, Xcode will know everything about your custom framework. So try to write some code using your framework classes. Remember to import your Framework Principal Header as a framework notation. Xcode will use your public headers in the Code Completion.

Xcode knows your public headers and can use them in the Code Completion.

I like to use the Xcode Midnight Color Theme, so the classes of the project are green and the framework classes are blue. I love blue classes!

Conclusion

top
Well done, my friends! As we are used, let’s make a final review and take care with some possible problems.

• In a common Xcode project, create a Bundle target.
• Make the necessary setup, place your sources, headers and resources in it and finally change the its Schemes configuration.
• Compile to iOS Device (armv6/armv7) and to Simulator (i386).
• Create an Aggreate target and place a Run Script in it.
• Enjoy your real Universal Framework to iOS!

To finish I want to talk about some issues that I had:

• Take special care with the architectures. Don’t write the i386 directly in the Valid Architectures setting, always use the $(ARCHS_STANDARD_32_BIT). Plus, always set the Build Active Architecture Only to NO.
• Take care with your classes structure. If you set, for example, the ClassB.h as a Project or Private header, but in your code you import it into a Public header, this will cause conflicts.
• Take care with the Install Directory and Skip Install settings. They can generate warning if the folders permissions or paths are not right set.
• Finally, take a special care with the Lipo Tool script. It could generate warnings and/or errors if the paths was not found or the folder permissions was not right set.

This is all, buddy.
As I told you, the annoying thing is that you need build 3 times to generate a new Universal Framework: 2 x Bundle target (one to iOS Device and other to the Simulator) and 1x to the Aggregate target (which will run a script). But by my experience, this is not to much, you will create the final product only few times. At the great majority, you will test your Framework classes directly with the Application target in your Framework Xcode Project.

Enjoy your real Framework to iOS!

Thanks for reading,
See you soon!

Today I want to talk about the NinevehGL. Talk more about the features and about what it can offer to us. NinevehGL is almost done, I want to be as fast as possible, but I don’t want to launch it without everything seems great: the documentation, the tutorials, the official website and obviously, the NinevehGL itself.

Soon I’ll start posting videos and many divulgations about it, but right now in this article let’s see some images taken directly from the NinevehGL running.

Let’s start!

At a glance

The NinevehGL is a 3D engine fully made with the most pure Objective-C, right on top of Cocoa Touch Framework. So at the first moment, the NinevehGL is a 3D engine only for iOS. I intend to port NinevehGL to MacOSX (desktops with Obj-C) and also for ActionScript 3.0, using the new great API code named Molehill. ActionScript is my old programming language, today I don’t hold much lover for it, but I know that there are many people that still loving Flash. Another important step is to port NinevehGL to JavaScript to work with WebGL. But at the beginning, NinevehGL will work only with OpenGL ES 2.x for iOS.

Now the most important question: “Why NinevehGL instead of PowerVR, Oolong, SIO2, Torque, Ogre, UDK, Unity, Wolfenstein, Shiva, Galaxy, or any other? Why should I choose NinevehGL instead any other 3D engine?”.

I always tried to convince everyone to buy what I was selling, trying to convince everybody from my point of view. But not this time, I don’t want to sell anything, I don’t want to convince you. If you are using some other engine and glad with that, just continue with it, you don’t have to change. Also, if you are a great OpenGL programmer and have your very own model and structure, continue with it, don’t change anything. Because, again, I don’t want to convince anyone at this time. Just as OpenGL, I’ll focus on the most important thing to me: development!

I took everything that I’ve seen of worst in other engines and I’ve tried to make it better in NinevehGL. I took all my frustations with the actual engines, all my luggage as developer, all my knowledge about 3D world and put all of them in the NinevehGL. So, if you are like me and you have some insatisfaction with the other engines, for you, NinevehGL could really nice for you! I know I’m telling this every time, but I love this concept:”Keep it simple!” This is the NinevehGL’s main principle, everything was made to be simple. There are no commands that need more than one single line of code. If you want to make one thing, you need one line, nothing else.

Now I’ll describe in details the most important features of NinevehGL. Remember, I don’t want to convince you of anything. I’m sure you are an advanced programmer and can form your own opinion about what’s coming next. If you like it, great! If don’t, it’s great as well! Just tell me why and I’ll try to make better.

Here is a features’ list.

Importing 3D files

This is the most problematic topic to me considering other engines. As OpenGL doesn’t import 3D files directly, you must use an engine that imports a file good for you or use one of the files accepted by that engine, like POD to PowerVR engine.

This is the first problem that NinevehGL works to solve, it can import the two most popular 3D file formats: COLLADA and WaveFront OBJ. You know what a mess the 3D imports with 3D softwares are. Each software has its own file format and implements its importing routines at its own way. So it’s not hard to export an OBJ from 3DS Max and when you try to import in Maya, BOOM, error! To tell the truth, the incompatibility with the files when exporting from a 3D software to another is common.

The NinevehGL has a full importing routine. What that means? If your OBJ file has informations about the specular, the bump map, the reflection map or anything supported by OBJ file, NinevehGL will import and parse everything for you with no losses. The same is true for COLLADA files.

NinevehGL supports OBJ and DAE files.

Caching 3D files

This is the greatest feature in my opinion. NinevehGL works with a third kind of file, the NGL binary file. It’s a binary file containing a full 3D model with all informations necessary to NinevehGL and also OpenGL. This file is loaded through streaming, so it’s extremely fast. There are no 3D softwares that can export it, it’s exclusive from NinevehGL. So how you can use it? There are two ways: First, you can convert your OBJ or COLLADA file on-line! Yes, you read it right, on-line convertion! No plugins, no installations, no complex things, you can generate NGL file on-line! Just access the NinevehGL website, choose the files on your machine and hit the button!

The other way, is the most fascinating one. NGL file is generated automatically by NinevehGL at the first time you load a new file from OBJ or COLLADA. This file will be stored locally in the device under the folder /Library/NinevehGL. What is great here, is that this folder is fully backed up by iTunes. So imagine this:

1. You make an APP, which loads OBJ and COLLADA files.
2. An user make the download of your APP from the APP Store.
3. The user runs your APP at the first time, the NinevehGL loads around 20 3D file in 12 secs, let’s suppose.
4. The next times that this user runs your APP, the loading time will be 0.12 secs, for example.

What happened???
It’s great! At the second run, the NinevehGL automatically identified that those 20 3D files were already parsed before, so it will use the cached NGL binary files instead the original ones!

But this feature doesn’t stop here! Remember, NinevehGL was made to make everything be simple! So, let’s suppose your application loads the 3D files through the internet connection instead loading it locally. No problems! NinevehGL compares the modification date of the files and choose the most recent. Imagine this:

1. Your APP loads the 3D files from the internet, because you want to make updates without submeting a new APP to APP Store.
2. An User downloads your APP. First run, 20 3D files in 12 secs.
3. In the next times, NinevehGL will use NGL binary files, loading them in 0.12 secs.
4. You make an update and upload some new 3D files.
5. All the users that have your APP will receive the update, with 10 new 3D files replacing the old ones, so NinevehGL will parse the new downloaded files in 10 secs and it’ll generate new NGL binary files.
6. In the next runs of your application, NinevehGL will use the new generated NGL files and the loads will happen in 0.08 secs.

I cry of happiness every time I explain this routine. It’s amazing, wonderful, outstanding, great, it’s… it’s… “magical”! Well, this is just my opinion about it. But I’m sure you can imagine how great would be to the final user: “At the first run, a loading of few seconds, next times, no loading? Where is the loading of this APP?”. The loading happens in a snap.

NinevehGL automatically saves NGL binary files locally.

The last thing I want to say about this feature is the optimization. Again, the NinevehGL was made to be EXTREMELY FAST! So, if you load a NGL binary file directly, it will not create a cache file to it, because it is already optimized, it’ll just create cache from non optimized files (OBJ and COLLADA). Now you know how to convert your 3D models to NGL binary file, you can convert them on-line, at the official NinevehGL website, or can just run your application in the simulator and take the binary file generated at the first run and find the file at /Library/NinevehGL!

In order to avoid confusion, it’s important to say that NinevehGL will not be responsible to manage the internet connection for the file downloading. So you can’t inform an URL to load a 3D file. What the NinevehGL will make is manage the files locally.

Custom Shaders

The NinevehGL was made to work with OpenGL programmable pipeline. So obviously it’ll create its own shaders, based on the materials (loaded from 3D files or materials created directly in the code). Well, the most fun part of the programmable pipeline is exactly the shaders, so will NinevehGL block us of using our own shaders? Of course NOT! NinevehGL is absolutely user friendly, it’s flexible!

The other engines working with programmable pipeline are used to give to us only two choices. Working only with your very own shaders or working only with their shaders! Well, this is not a choice, but rather it’s a dilema! But, the NinevehGL offers another way, a third way: “all of above”! Yes, your read it right, NinevehGL has an API Shader capable to integrate two or more shaders into only one program. WOW, what that means?

That means you can create your own shaders, just as you are used to, implementing your own lights effects, materials or anything else you want. Then you pass your shaders to the NinevehGL and it’ll integrate your custom shaders with the shaders generated by the NinevehGL materials. No conflicts, everything works fine together!

This works for Vertex Shader and/or Fragment Shader. An important thing to say is that there are no special constraints, you can even use a shader that you already have, with many variables inside, many functions and the main function. The NinevehGL Shader API will interpretate the code inside the shaders and will fuse all together.

NinevehGL can merge your custom shader with its own shaders.

Calculating Normals and Tangent Space

This is the robust side of NinevehGL. It’s very fast even in the hard processing scopes, like calculations of normals and tangent space for imported models. Normals and tangent space are very important to generate real time lights, reflections, bump effects and many other things. NinevehGL automatically calculates the normals and generates the tangent space for each mesh that needs it.

NinevehGL automatically generates normals and tangent space, if needed.

NinevehGL can automatically generate some effects, like specular lights, ambient light, emissive light, bump map, reflections and other ones specified by NinevehGL materials. NinevehGL doesn’t impose any limitations to you, it just works around the limits of the OpenGL. So, in the iOS, for example, you can work with very high mesh models. Obviously this is not a common situation, but sometimes it could be better to see high mesh models on the screen. Even to these high meshes, NinevehGL will continue to produce the normals, tangent space, specular lights, bump maps, reflections and everything else you need.

NinevehGL also works with very high mesh models.

Now I want to show you some other features that are also great, but I’ll not talk in deep here.

Optimizing Textures

Just to keep it fresh on our minds, NinevehGL was made to operate in the maximum performance. So even the loaded textures will be optimized. If you choose to work with an opaque OpenGL Layer (the default), the textures could be optimized to the format RGB_5_6_5, which is the best choice without alpha channel. If you choose to work with transparent layer, the textures could be optimized to the format RGBA_4_4_4_4.

The optimization process will happens automatically and you don’t need to worry about it. Even to PVRTC compressed texture format, these optimization could happen, if needed to. The textures, as any other external file, can be loaded from any path locally and the NinevehGL is ready to manage the local paths to you.

Plus, just as the 3D files, textures has a kind of “cache”, that means if you load an image more than one time, the NinevehGL will manage the load locally and will not spend more memory with the same cached image. This is a very important optimization, mostly in cases when a 3D file use the same image for many things, like to the ambient, diffuse and specular maps.

Many other things

There are in NinevehGL many other important features, but I’ll just point it because other engines also have these features, so it’s not that exclusive. Like:

• Cameras with projections (perspective and orthographic).
• Customizations of OpenGL behaviors, like the render buffers.
• Simple API to make 3D transformations (like obj.rotateX += 1.0).
• Always use OpenGL optimization features, as Buffer Objects, array of structures, optimized texture formats, etc.

One great thing to talk a little bit more is about the auto-corrections. It’s very common that the 3D modelers create their models with different scales, I mean, a 3D file which contains a spoon could has the range of vertices going through -1000.0 to 1000.0 and other file which contains a house with the range of -0.5 to 0.7, for example. By placing both files in a 3D softwares you probably will see a house at the side of the empire state in format of a spoon.

For a 3D softwares this is not a big deal, because there are an infinity work space and you can simply reorganize your objects visually. But for a programming language, this is a problem and gets even bigger if the object is so big or so far that you can’t even see it on the screen.

The NinevehGL auto-correction can solve this problem for you, because it can normalize the vertices positions to fit on the screen (or in a specific range you want). By doing so you can control the size of your models without having to export it again from the 3D software. So in the case of the house and the spoon you could set the auto-correction to fit the house at the range -10.0 to 10.0 and the spoon to -0.1 and 0.1, simple as that (one line of code).

Outside the Scope

What you should not expect from NinevehGL? Here is a list:

• The NinevehGL is not a game engine, it’s a 3D engine.
• So you shouldn’t expect physics controllers or sound controllers. You should construct this kind of stuff by yourself.
• No animation, YET! Animations is very important in the 3D world, but the first version of NinevehGL will not come with this feature. (Animations = Character Rigging + Bones)
• No collisions, YET! There are two techniques to deal with collision, bounding box and bounding mesh. In this version, NinevehGL will not implement any of those.

Obviously any item in this list can change, because the NinevehGL is flexible. Consider the above list as an “out of scope” list only for the first version of the NinevehGL.

Conclusion

I’m sure you have now a solid opinion about NinevehGL, good or not, so let me know what you think, post a comment bellow, send me an email, tweet me… anything.

Again, I don’t want to make promisses, but I really want to see this engine released soon. So I’m sure it will come in the first half of this year (2011). I’m just finishing some details now and organizing everything for the first release.

Thanks for reading,

And see you very soon!

NinevehGL will come in the first half of 2011.

Hello everyone!

Welcome to this article!

Today I want to show you something called Nineveh Responder engine, or just NResponder.
And to do so, I will cover just four points, nothing more:

• Nineveh What?: What is this? What is it for?
• NResponder’s features: What news does it bring?
• NResponder usage: How to use it?
• REAL WORLD example: NResponder in action!

OK, so let’s start!

Here are the source files of NResponder and the project files used in this tutorial:

Nineveh What?

Do you remember of the city Nineveh? OK, nothing like that.

Nineveh is a new Framework to AS3 under construction. The point here is not to talk about this Framework, but just is important to say that NResponder is one of the engines and APIs of the Nineveh Framework. Something new about this framework is that it has engines and APIs independents, like NResponder, and these engines and APIs can work fine outside the framework.

OK, but what the kind of engine is NResponder?

An Event Engine!

For years I’ve used the Event Engine of default Flash framework called EventDispatcher. Oh God!

How boring it was! You know:

• Create some kind of instance or inherit from EventDispatcher class.
• Add listeners into it.
• Create a VERY LIMITED AND STRICT event-class inherited from Event class (in majority of cases). And you need to use just event-class AS PARAMETER when dispatching.
• Create a new instance of that custom event-class.
• Dispatch your custom Event using the above instance of EventDispatcher (well, I mean, if you have some instance at the time of dispatch).
• Wait for Capture phase, Target Phase, Bubbling Phase.

Ooooh…  just STOP!!!

If you are boring with all of that, like me, NResponder is for you!
If you are completely new to Events in Flash, NResponder is for you as well!
And if you are new just delete the points that I just spoke above.

NResponder is much much faster than native Event Engine of Flash.
You don’t need to create any instance, if you don’t want to.
You can manage and control events of your entire application.

Imagine this scene:
You start you application, place 3 buttons on the stage, and load an external SWF to play a video. When you press one button, the video playing in the other SWF needs to be stopped, because another SWF will be loaded above it.

Well…  with EventDispatcher you should have a big path to follow until finally catch it up.
But with NResponder, all that you need, is just 2 lines of code!
One in the Button class and another one in the video player! Just as simple as that!
Well, this is just the natural behavior of NResponder, I haven’t even talked about features yet.

You can use NResponder for everything related to events or fire actions, mouse and keyboard and touch interactions, etc.
As stated in the title of this article, you can completely say “Good Bye” to EventDispatcher.

OK, now you know what NResponder is.
If you want, you can see the project page on Google: http://code.google.com/p/nineveh-responder/

Check the blog page here: http://db-in.com/blog/nineveh-framework/nresponder/

You can download the NResponder here: http://nineveh-responder.googlecode.com/files/Nineveh-Responder.zip

Obviously you can check the project page on Google to see the Documentation, check the SVN, learn with the Wiki and so forth, but here I will teach you step by step guide in a tutorial to use the great power of NResponder.

Now let’s dig further.

NResponder’s features

To talk about the features of NResponder I want to give you a little comparison.

In the following table you can see the native Envent Engine (or API) compared to the features of NResponder.

Feature	Event API (Adobe® Flash®)	Signals (Robert Penner)	NResponder (Diney Bomfim)
Used without instance
Used with instance
Specify number of dispatch arguments
Dynamic dispatch arguments
Change dispatch arguments in Run-Time
Remove all		limited to instance
Specify a delay time
Set the number of replies		Just 1
Ordenate
Can associate with a target		only NativeSignal
Can pause without remove
Can stop propagation
Change attributes in Run-Time
Garbage Collect	only weak references

I will focus on the most important and more usable features:

Static and instantiated mode

With NResponder you can choose the best way to work. Use it as a static class, without creating any constant or variable, or use it as an instance, a more object oriented approach.

An important thing to say is that the instantiated mode offers you more control over the event, like pausing it without remove it.

Custom number of arguments and changes

This is really one of my favorite features. As you know, in the native Flash’s Event Engine the dispatcher MUST and NEED to inform ONE, and just one, Event instance. And the call back functions need to expect that kind of event.

So, for example, what you have is:

dispatcherInstance.addEventListener("aCustomEvent", callBackFunction);
dispatcherInstance.dispatchEvent(new MyCustomEvent("aCustomEvent"));
...
private function callBackFunction(event:MyCustomEvent):void
{
...
}

This is boring!!!

If you want to pass some kind of data to your callBackFunction() you need to put new variables to your MyCustomEvent class!

Just forget it!!!

With NResponder you can pass how many parameters you want and can have a call back function like this:

private function callBackFunction(aNumber:Number,
                                  aString:String,
                                  customObject:ACustomObject):void
{
...
}

This give you so much more flexibility to work!

Because you can make your call back functions more readable and more reusable.

Number of replies

This is one of my favorite too.

With this feature you can simple set the number of times that a specific event (or Action, in NResponder language) will happen! How many you want, just 5, or until 21, anything!
One very common and useful usage of this is for view classes.
As you know, when you start a view class and it is not on the stage yet, its property of “stage” is null. So widely accepted technique among developers is the use of the following:

public function Main()
{
    if (this.stage)
    {
        init(null);
    }
    else
    {
        this.addEventListener(Event.ADDED_TO_STAGE, init);
    }
}

public function init()
{
    if (this.hasEventListener(Event.ADDED_TO_STAGE))
    {
        this.removeEventListener(Event.ADDED_TO_STAGE, init);
    }
}

You need to add and remove, make checks to hasEventListeners, to use this routine just ONCE!
It’s sucks!!!
With NResponder all that you need is set the number of replies, in this case 1, and stay focused on your code! Because NResponder will be responsible to clean up the mess later, delete what needs to, frees the memory and go on.

Delay time

This can be very helpful in some situations.
The delay time specify the time, in seconds, that will be the minimum to wait between two consecutive dispatches.
For example, you have a button in your game that the user needs to press continuously. But you want a little interval of time between two clicks, like 0.5 secs. With NResponder all that you need to do is to set one property and everything will be controlled by the NResponder engine.

Combined removes

With the native Event Engine if you set a lot of listeners and later you need to remove them, you’ll have to do so one by one.

With NResponder you can make combined removes, like remove all listeners of a target, remove all listeners of a specific call back function, remove all listeners of a specif type (Action), like Mouse.CLICK, or even make combination like remove all listeners of a specific target with a specific call back function.
Don’t worry if this don’t make sense to you now, when I show you the examples, everything will become clearer.

OK, these are the most important features of NResponder.

I’ll not mention the features that have correlated in native Event Engine, like order or stop propagations, because I suppose that you already know it from EventDispatcher.

One more thing…

Something that you may be thinking now is: “OK, you’ve talked about mouse events, keyboard, touches… and said that I can say Goog Bye to native Event Engine… but are not mouse, keyboard and touches native events?”.
Yeah!
You are right!
With NResponder you don’t need any instance of EventDispatcher in your application, you don’t need to use the processing core of native Event Engine.
But if you want to, NResponder gives you a way to use the native system under the NResponder engine system.
Obviously to work with mouse events, keyboard, touches, etc, NResponder need to use a little portion of the native Event Engine, because it’s the only way to catch this kind of event in Flash.
But again, NResponder can do this so much better than using the native EventDispatcher process.

NResponder usage

Hands to work!

For now we’ll just create a project that prints (trace) some responses on the screen. So you’ll need an IDE to compile and debug the code, like Flash Professional, Flash Builder, Flash Develop, FDT, etc.

OK, now let’s code!

Static or instantiated mode

The first important step is to import the NResponder to your classes. Some IDEs do this automatically for you (Flash Builder, FDT, Flash Develop,…) when you are typing. NResponder package is inside the “appkit” (a SubFramework of Nineveh Framework) and inside the package “responders”. This path is just a convention of Nineveh Framework. Of course, you will need to import this package in all classes that you want to use NResponder.

package
{
    import flash.display.MovieClip;
   
    import appkit.responders.NResponder;

    public class Main
    {
        public function Main():void
        {
        }
    }
}

Now, about the static and instantiated mode. Every time you add a new NResponder (register an event, add a call back function, register a listener, whatever, is the same thing for NResponder), the NResponder will create a little instance of Responder, this instance will go to the core of NResponder and will be the responsible to execute the commands in the engine’s core. This is a behavior, NResponder will always do this. The cool thing here is that you can get a copy of this instance when you add a new. And you have some flexible ways to do so:
IMPORTANT: The following code is not real, is just to illustrate the both modes. In the next section (Creating a NResponder) you’ll see a real code.

package
{
    import flash.display.MovieClip;
   
    import appkit.responders.NResponder;

    public class Main
    {
        public function Main():void
        {
            // This is the static mode
            NResponder.add();
           
            // This is the instantiated mode.
            var responder:NResponder;
            responder = new NResponder();
            // Or even
            responder = NResponder.add();
        }
    }
}

You could asking: “wait, why the ‘new’ create an instance and the static call return an instance too?”

Well, you’ll understand soon, the “new” constructor is generic, and the static “adds” (in plural) have some shortcuts to you. As I’ve mentioned earlier, the NResponder can work with native events in Flash, so the different “adds” help you to create it. Although the “new” constructor make it, you’ll need to write more parameters to it.

Reasons why:
The static and instantiated mode doesn’t have any impact in performance of memory of your application. The unique reason to use instantiated is if you need to change some behaviors of NResponder after creating it. Like pausing it without deleting, for example. But if you don’t need further changes, don’t worry with any instance.

Creating a NResponder

Now let’s see how to set a call back function to an event in Flash, or more directly, how to create a NResponder. Here you’ll define your listener, will specify the Action (same as Type in EventDispatcher’s language) and all kind of things that NResponder will make for you.
IMPORTANT: It’s here, in this section that you can say “Good bye” to EventDispatcher!

OK, the first thing that I want to show is how you normally do with EventDispatcher. When you want to use a custom event you do something like this:

var myDispatcher:EventDispatcher;
myDispatcher.addEventListener('myCustomEventType',
                              callBackFunction, false, 0, true);
...
myDispatcher.dispatchEvent(new CustomEvent('myCustomEventType'));

This sucks!

Because the only way for you to dispatch your CustomEvent is using the “myDispatcher” instance! And look at this line of addEventListener, it is so big, completely unnecessary.
Now to do the same thing with NResponder all that you need is:

NResponder.add('myCustomEventType', callBackFunction);
...
NResponder.dispatch('myCustomEventType');

We’ll talk about “dispatch” later, but for now, as you can see, you don’t need to worry with additional parameters like use capture, use weak references, because NResponder doesn’t need these kind of things to work with NResponder. Here is a little difference between the EventDispatcher and NResponder. The ‘myCustomEventType’ is the type of event to EventDispatcher, but NResponder has called it “Action”. So henceforth let’s call “Action” everything that means “Event Type” for EventDispatcher.

And as I’ve mentioned earlier, you can get a reference to the instance returned by the “add” method:

var myReponder:NResponder = NResponder.add('myCustomEventType',
                                           callBackFunction);

Remember that this instance doesn’t change anything, it’s just for you get more control over the NResponder instance.
OK, now let’s take a look at the NResponder working with native Event API. The method to create it is very similar. If you want to set a click in a button, for example, using the native Event API you probably make something like that:

// probably inherited from MovieClip or Sprite.
var myButton:CustomButton;
myButton.addEventListener(MouseEvent.CLICK,
                          clickFunction, false, 0, true);

OK, now let’s translate this to NResponder’s language:

// probably inherited from MovieClip or Sprite.
var myButton:CustomButton;
NResponder.addNative(myButton, MouseEvent.CLICK, clickFunction);

Just simple as that. Using the method “addNative” is very similar to “add”, with only one difference: the first parameter is the target of the native Event.

Some people may get confused at this point. But all that you need to remember is to ask “Who is responsible for dispatching this native event? Who is inherited from EventDispatcher class?”, so you take this object and pass it on the first parameter to “addNative” method.
Like this:

You can use NResponder to all kind of native events. The benefits is that it will work faster, more cleaner and you can use all the features of the NResponder. The following topics will explain about it.

Well, as you’ve noticed, as a Good Practice in programming to avoid misspelling, is advisable to you store your custom Actions in a class with “public static constants”, like this:

public static const CUSTOM_ACTION:String = 'myCustomAction';
...
NResponder.add(CUSTOM_ACTION, callBackFunction);

This is just a tip, although in this article to simplify the purposes I’ll use literal strings to illustrate the examples.

Dispatch and arguments

After creating a NResponder with the “adds” methods (add() and addNative()) you can dispatch these responders from anywhere in your application, even in different SWF files (loaded files in the same application). All that you need is to inform the “Action” you want to dispatch and the parameters that you want, if needed.
Like this:

// This will dispatch "myAction" with no arguments.
// So the callBack function doesn't need to expect any parameter.

NResponder.dispatch('myAction');

// This will dispatch "anotherAction"
// with the arguments 35 (Number) and "aString" (String)
// So the callBack function should expect
// these parameter (Number and String in this order).

NResponder.dispatch('anotherAction', [35.5, 'aString']);

The dispatch() method is simple, it will dispatch the specified Action to the whole application.

OK, so you could ask “If NResponder will dispatch an Action for anyone that has been registered in NResponder, what will it make with buttons, for example? Will it dispatch a click to all? How will it set what button to dispatch for?”.
Good Point!
The answer is: using the Target parameter!

Do you remember in addNative() that you need to specify the Target as the first parameter? It’s now that it makes the difference. If you specify a target when creating a NResponder, that target will work like a lock and this NResponder will only respond when it’s target is specified. Well, this might be a little confusing by now, but just think that NResponderCore will care about this for you. If you are using a native event, like MouseEvents, KeyboardEvents or any other, this will happens automatically during the dispatch. Just don’t worry about it.
If you want, you can specify a target without using the native events. You may use this to take the benefits of this “lock” that target provides. But this is a more advanced topic and I don’t want to confuse you with this here. If you want to know more about this just check this Wiki of the project:

http://code.google.com/p/nineveh-responder/wiki/DispatchAdvanced

Let’s move.

Number of replies

As I’ve told you, this is one of the most interesting features to me. This lets you specify how many times you want a NResponder performs and after the very last one, it will automatically be removed and cleaned. All that you need is specify a number after the listener parameter in the “adds” methods.
Like this:

NResponder.add('myCustomEventType', callBackFunction, 5);
NResponder.addNative(myButton, MouseEvent.CLICK, clickButton, 2);
NResponder.addNative(this, Event.ADDED_TO_STAGE, init, 1);

The code above means that:

• “myCustomEventType” will only response 5 times
• The CLICK on “myButton” will happens just 2 times
• The “init” listener will happens just once when the target “this” be placed on the stage.

You can specify how many times you want. Obviously you can’t specify negative number of times. And just for convention, the 0 (default) number means that NResponder will be performed infinitely.

Delay time

The delay time is the minimum time necessary between two consecutive dispatches.
Imagine that you have a button in your game and you don’t want the user start to click on it without stopping. You want the at least the user to wait 2.5 sec until he makes a new click. Well, all that you need is specify the next parameter after the number of replies in the “adds” methods.

NResponder.addNative(myButton, MouseEvent.CLICK, clickButton, 0, 2.5);

This means that the “clickButton” listener just will happens again if the next click occurs after 2.5 sec. If the user make a click during the delay of 2.5 sec that click will be ignored. The 0 (default) means “no delay”.

Has and remove

Just like the EventDispatcher class, NResponder provide a way for you to check what is registered inside the NResponderCore and a way to remove it. The advantage here is that you can combine and make multiple tasks at once. Let’s start with a simple case, you want to know your application has any registered Action of “myAction”, so:

NResponder.has('myAction');

So simple!

This will return “true” if you have at least one registered NResponder with “myAction”. Now, imagine that you want to know if it has an “myAction” Action linked with a specific call back function.

NResponder.has('myAction', myFunction);

This will return “true” if you have at least one registered NResponder with “myAction” as Action and “myFunction” as Listener. And at last, you can check if this is true for a specific target.

NResponder.has('myAction', myFunction, myTarget);

This will return “true” if you have at least one registered NResponder with “myAction” as Action and “myFunction” as Listener and “myTarget” as Target. The funny thing here, is that you can combine those 3 parameters, leading to the following:

NResponder.has('myAction', null, myTarget);
NResponder.has(null, myFunction, myTarget);
NResponder.has(null, myFunction, null);
NResponder.has(null, null, myTarget);

The four line above means:

1. Has at least one registered NResponder with “myAction” as Action and “myTarget” as Target?
2. Has at least one registered NResponder with “myTarget” responding to “myFunction”?
3. Has at least one registered NResponder responding to “myFunction”, independently of Actions and Target?
4. Has at least one registered NResponder with “myTarget” as target, regardless of Listeners and Actions?

The null means that you want to ignore that parameter and focus on the others. These combination can be very helpful in the case that you don’t have more access to one or two of those parameters. The most helpful of the combination feature is in remove method. You can remove a lot of NResponders with just one line of code. The remove() method works exactly as has() method:

NResponder.remove(null, null, myTarget);

The line above means that you’ll remove all the NResponder of a specific Target (“myTarget”). Now think of a button. You can register a NResponder to the “Mouse Over” action, another one to the “Mouse Out”, another to “Mouse Down”, one to “Mouse Up” and another one “Mouse Move”. Well, 5 NResponders. And after all, when you don’t want this button anymore, you can remove all these NResponder in just one line, like this:

NResponder.addNative(myButton, MouseEvent.MOUSE_OVER, overList);
NResponder.addNative(myButton, MouseEvent.MOUSE_OUT, outList);
NResponder.addNative(myButton, MouseEvent.MOUSE_DOWN, startDragList);
NResponder.addNative(myButton, MouseEvent.MOUSE_UP, stopDragList);
NResponder.addNative(myButton, MouseEvent.MOUSE_MOVE, draggingList);
...
NResponder.remove(null, null, myButton);

Remember that NResponderCore is responsible for all cleaning, and it will know exactly how to clean everything with just one line of remove() method.

Benefits of instantiated mode

With instantiated mode you can change the order of dispatches of the same Actions, you can perform the call back function directly, you can check some attributes of that instance of NResponder, change the values of delay, number of replies and so on. I’ll not talk about all of these benefits, you can find information about they at the Wiki of Project page and at docs:

http://code.google.com/p/nineveh-responder/w/list

http://db-in.com/frameworks/nineveh/doc/

But I do want to talk here about a benefit called “paused”. This property is a boolean in which “true” indicates paused. As the name suggests, you can pause the NResponder without removing it. This can be very helpful if you want to interrupt a NResponder just for a while.

For example, imagine that in your application you have a 3D interface that reacts to mouse position. But if the user hits the space bar it will appear a pop-up and for the time the user stay on this pop-up you want your 3D interface to stop to reacting to mouse position. Well, all that you need is use NResponder in instantiated mode and pause it when you need.
Like this:

var myResponder:NResponder = NResponder.addNative(my3DInterface, MouseEvent.MOUSE_MOVE, interactFunction);
...
// When start the pop-up, use this to pause this NResponder.
myResponder.paused = true;
...
// When close the pop-up, use this to reactivate this NResponder again.
myResponder.paused = false;

Obviously you can remove and add the NResponder again using the static mode, but at this way you save CPU and memory, because pausing is much much faster than adding and removing.

Here I’ve presented to you some features, the most important and most used, of the NResponder Engine. Remember to check the project page to see everything about NResponder. For now, this is all that we need to say “Good Bye to EventDispatcher”. With just these features you can do almost everything with NResponder.

Now let’s move to some real world example!

REAL WORLD example

Finally let’s see a real example of NResponder working.

At a glance

In this example we will create a very simple shoot game’s routine. To show you how the features and benefits of NResponder can change how you think about your work, let’s refine a little this shoot game. Imagine that the gun in this game is an old single-action revolver, so at every shoot the hammer of this revolver needs to be pulled again and this action may take about 1.5 sec. And more, the gun just has 6 bullets, after 6 shots the user must reload the gun.
First let’s imagine what we need to construct this with the native Event API, how many Booleans, timers, a lot of “if then else”, and variables we need to use to achieve this behavior. I’ll show a possible way to do this, but in the middle, before the code start to get more complex, with a lot of annoying things, we’ll change and use the NResponder.

Now, about the project files, is important to say that I’ve placed some two-handed comments. You know, that kind of comment block that you can toggle on/off between two codes. Like this:

/*
...
/*/
The code here is activated.
//*/

---------

//*
The code here is activated.
/*/
...
//*/

So in the project files I let this kind of comment for you see the difference between the native Event API and NResponder. You can easily toggle between both adding a “/” at the first line of the comment block.

Oh right, let’s start!

Constructing with native Event API

At this point I’m sure you already look at the project files. So I’ll just describe what you’ve found in FLA file:

Nothing new here, just a stage with 3 MovieClips: the shot area, the reload button and the bullets. Inside the bullets MovieClip we have a MovieClip for each bullet. All of these have instance names that we’ll use in the main class later. As you can see, in the library we export a view called VShootAnimation. It is just a view class to control the animation of the shoot using a texture atlas (poof.png).

Now I’ll start with the NResponderExample just using the native Event API.

/**
 * NResponderExample class
 *
 * @version NResponderExample v1.0
 * @author Diney Bomfim
 */
package
{
    import flash.display.MovieClip;
    import flash.events.Event;
    import flash.events.MouseEvent;
   
    /**
     * Simple shoot game to illustrate the usage of NResponder.
     */
    public dynamic class NResponderExample extends MovieClip
    {
       
    //**************************************************
    //  Protected / Private Properties
    //**************************************************
       
        private var shoots:int;
       
    //**************************************************
    //  Initialization
    //**************************************************
       
        /**
         * The initialization of NResponderExample class.
         */
        public function NResponderExample():void
        {
            if (stage)
            {
                init(null);
            }
            else
            {
                addEventListener(Event.ADDED_TO_STAGE, init, false, 0, true);
            }
        }
       
    //**********************************************************************************************************
    //
    //  Protected / Private Methods
    //
    //**********************************************************************************************************
       
        /**
         * Initiate the View of the application.
         *
         * @param    e
         */
        private function init(e:Event):void
        {
            // Remove the listener
            removeEventListener(Event.ADDED_TO_STAGE, init);
           
            // Definitions
            doReload(null);
           
            // Listeners
            this.btReload.addEventListener(MouseEvent.MOUSE_DOWN, doReload, false, 0, true);
        }
       
        /**
         * Make a Shoot on the valid stage area.
         *
         * @param    e
         */
        private function doShoot(e:MouseEvent):void
        {
            trace('a Shoot');
           
            var shootAnim:VShootAnimation = new VShootAnimation();
            shootAnim.x = stage.mouseX;
            shootAnim.y = stage.mouseY;
           
            addChild(shootAnim);
           
            this.mcBullets['mcBullet' + shoots].visible = false;
           
            ++shoots;
        }
       
        /**
         * Reload the gun.
         *
         * @param    e
         */
        private function doReload(e:MouseEvent):void
        {
            shoots = 1;
           
            for (var i:int = 1; i <= 6; i++)
            {
                this.mcBullets['mcBullet' + i].visible = true;
            }
           
            // Listeners
            this.mcShootArea.addEventListener(MouseEvent.MOUSE_DOWN, doShoot, false, 0, true);
        }
    }
}

Well, the above class will be our main class of the FLA file.

• First in the constructor of the class (NResponderExample()), just to follow a best practice we put Event.ADDED_TO_STAGE to guarantee that no errors will happens if this file is loaded by another SWF file.
• In the init() method we remove the previously Event.ADDED_TO_STAGE, make the first reload to the gun and add the listener of the reload button.
• In the doReload() method we make all the bullets inside the mcBullets visible again and add the listener that will make the shoots.
• In the doShoot() method we place our VShootAnimation view class in the mouse screen position and remove one bullet from the screen.

At this point the code remains simple. You could test and see what happens.
But our somewhat refined behavior is not implemented yet. The bullets doesn't has a delay to simulate the old revolver, the shoots doesn't stop after the sixth and we have a bug in the line this.mcBullets['mcBullet' + shoots].visible = false; when the shoots doesn't stop after the sixth.

Well, try to think what should be necessary to implement our behavior.
Take some minutes if necessary looking at this code and try to implement this behavior.
Remember all the problems above.
To do this we would probably place a lot of "if then else" in our code, create timer checks, Booleans, oh god... really boring!

But let's STOP here and migrate all our events to NResponder Engine.

Solving the problems with NResponder

Now it's the BIG POINT of this article. It's right now! It's right here!
It's here that the magic happens with NResponder!
Believe it or not, but to solve ALL these problems, to implement our behavior to the above code, ALL that we need is to REPLACE 3 LINES of the code and may even EXCLUDE ONE!!!

Just it, nothing more!

/**
 * NResponderExample class
 *
 * @version NResponderExample v1.0
 * @author Diney Bomfim
 */
package
{
    import flash.display.MovieClip;
    import flash.events.Event;
    import flash.events.MouseEvent;
   
    import appkit.responders.NResponder;
   
    /**
     * Simple shoot game to illustrate the usage of NResponder.
     */
    public dynamic class NResponderExample extends MovieClip
    {
       
    //**************************************************
    //  Protected / Private Properties
    //**************************************************
       
        private var shoots:int;
       
    //**************************************************
    //  Initialization
    //**************************************************
       
        /**
         * The initialization of NResponderExample class.
         */
        public function NResponderExample():void
        {
            if (stage)
            {
                init(null);
            }
            else
            {
                /*
                addEventListener(Event.ADDED_TO_STAGE, init, false, 0, true);
                /*/
                NResponder.addNative(this, Event.ADDED_TO_STAGE, init, 1);
                //*/
            }
        }
       
    //**********************************************************************************************************
    //
    //  Protected / Private Methods
    //
    //**********************************************************************************************************
       
        /**
         * Initiate the View of the application.
         *
         * @param    e
         */
        private function init(e:Event):void
        {
            // Remove the listener
            //removeEventListener(Event.ADDED_TO_STAGE, init); // Don't need this any more.
           
            // Definitions
            doReload(null);
           
            // Listeners
            /*
            this.btReload.addEventListener(MouseEvent.MOUSE_DOWN, doReload, false, 0, true);
            /*/
            NResponder.addNative(this.btReload, MouseEvent.MOUSE_DOWN, doReload);
            //*/
        }
       
        /**
         * Make a Shoot on the valid stage area.
         *
         * @param    e
         */
        private function doShoot(e:MouseEvent):void
        {
            trace('a Shoot');
           
            var shootAnim:VShootAnimation = new VShootAnimation();
            shootAnim.x = stage.mouseX;
            shootAnim.y = stage.mouseY;
           
            addChild(shootAnim);
           
            this.mcBullets['mcBullet' + shoots].visible = false;
           
            ++shoots;
        }
       
        /**
         * Reload the gun.
         *
         * @param    e
         */
        private function doReload(e:MouseEvent):void
        {
            shoots = 1;
           
            for (var i:int = 1; i <= 6; i++)
            {
                this.mcBullets['mcBullet' + i].visible = true;
            }
           
            // Listeners
            /*
            this.mcShootArea.addEventListener(MouseEvent.MOUSE_DOWN, doShoot, false, 0, true);
            /*/
            NResponder.addNative(this.mcShootArea, MouseEvent.MOUSE_DOWN, doShoot, 6, 1.5);
            //*/
        }
    }
}

As you can see, first using the feature of "number of replies" we make our Event.ADDED_TO_STAGE listener run once and automatically be excluded.

With the same feature we make our gun dispatch just 6 times and stop.
And using the delay behavior we make our gun wait 1.5 sec between two consecutive shoots.
Well, literally, you can say "Good Bye" to EventDispatcher in your application!

Conclusion

Well, obviously that I've shown a specific example where the NResponder fits perfectly and you can think that this is just an isolated example. Just remember all the features and facilities that I've told you here, remember to check the project page and the docs to know all the power of NResponder.

But if you still have doubts about how helpful and powerful NResponder can be, I just want you to remember two things, just two little things:

• NResponder is completely independent, can dispatch from everywhere to everywhere and can carry everything with it.
• With NResponder we can realize new things, new horizons that we didn't realize before. Perhaps, before it, we've just followed another ways.

Finally, hope I've helped you and hope you try NResponder, test it, try to replace it in your own code, make some performance tests, in another words, ENJOY!
Again I'll place here the links about NResponder and if you have any doubt about NResponder, just email me!

Project page: http://code.google.com/p/nineveh-responder/

Blog page: http://db-in.com/blog/nineveh-framework/nresponder/

Download the NResponder: http://nineveh-responder.googlecode.com/files/Nineveh-Responder.zip

Thanks for everyone that read this article.

See you later!

Official code page:
http://code.google.com/p/nineveh-responder/

NResponder is a new way to work with events in ActionScript 3.0 globally. You can cross events between different classes or even in different SWF files. With NResponder you add so much more flexibility to your application because you can changes the parameters “on the fly” in Run-Time. NResponder is inspired on Objective-C approach and is very oriented to performance and memory. You don’t need to create any instance if you don’t want.

For example, you can do:

// Instead this
myObject.addEventListener('anEventType', initialize, false, 0, true);

// Use this
NResponder.add('anEventType', initialize);

FEATURES
Bellow some characteristics of NResponder:

• Work in static or instantiated mode;
• Can specify the number of arguments to dispatch;
• Can change these arguments “on the fly” (in Run-Time);
• Can remove all NResponders;
• Can specify the number of replies;
• Can ordinate the replies;
• Can associate each listener with one target;
• Can have a delay to the next dispatch;
• Can pause or resume the replies;
• Can change all this attributes “on the fly” (in Run-Time);
• Can join to native Event API of Adobe® Flash® and continue to use all this features;
• Can instantiate and control each NResponder without change the others.

LEARN TO USE IT
The NResponder engine is full documented and you can check all the docs here:
http://db-in.com/frameworks/nineveh/doc

Below you can watch videos tutorials with the features and real world examples of the usage of NResponder.

Youtube 5 chapters:

Download
You can make the download of sources here:
http://nineveh-responder.googlecode.com/files/Nineveh-Responder.zip

Or visit the official code page of the NResponder:
http://code.google.com/p/nineveh-responder/

Here is the blog page:
http://db-in.com/blog/nineveh-framework/nresponder/

Remember to give me a feedback if you use it.

See you in the next post.