Discover all the functionalities of NeoMAD 4.3.1

A single API whatever the device

With the Generic API supplied by NeoMAD, a single code is all you need to develop your native mobile applications thanks to our cross-platform approach. Whether for the business code, lifecycle management or user interface, you’ll only need to use a single API for all the equipment you want to address.

NeoMAD’s generic API covers the following functions:

Lifecycle

  • Stack of screens management
  • Application status management (start, stop, pause, restart)
  • Event bus for reactive applications

User interface

  • A single API to describe IHM for all devices
  • Layout mechanism to allow IHM to adapt on all devices
  • Possibility of overriding graphic components

Connectivity

  • HTTP and HTTPS connections
  • Synchronous and asynchronous requests management
  • Listener for handling download and upload requests progression

Settings

  • Connectivity statuses access
  • Device's states access (screen size, keyboard type, phone state...)
  • Preference manager

Multimedia

  • Audio and video players
  • Camera access for taking pictures or recording videos
  • Media gallery access
  • QRCode

Sensors

  • Accelerometer data access
  • Gyroscope data access
  • Magnetometer data access

File system

  • Device filesystem access
  • Data storage in files
  • XML and JSON parsers
  • Storage in SQLite database

Mapping

  • Geolocation data access
  • Native mapping systems access
  • Route computation

OpenGL

  • OpenGL ES 1.0
  • OpenGL ES 1.1
  • OpenGL ES 2.0 (coming soon)

Notifications

  • Push notification management through a single API for all devices
  • Local notifications, reminders and alarms management
  • Toast management
  • Tiles management (Windows 8 and Windows Phone)

Internationalisation

  • Creation of multilingual binaries to manage localisation and internationalisation

Connected devices

  • Support for iBeacon technology (coming soon)
  • Support for NFC trough native libraries

Describe your user interfaces in Java or xml

NeoMAD has an advanced layout mechanism to define optimised user interfaces for each platform and format.

Choose the solution which suits you best to describe your user interfaces. NeoMAD enables you to simply separate the UI from the business code by describing your interfaces in seperate xml files.

xml_ui java_ui

NeoMAD integrates perfectly in the Eclipse IDE

In order to start using NeoMAD as quickly as possible, we’ll provide you with a ready to use version of NeoMAD, pre-packaged with Eclipse. You can also keep your existing work environment by separately downloading NeoMAD and its plugin for Eclipse.

The NeoMAD plugin for Eclipse also provides a debug function for Java platforms. Place your break points directly in your NeoMAD code and pilot Android, Java ME and BlackBerry debuggers from Eclipse. You can also debug for other platforms by generating native projects and opening them in their respective editors.

eclipse_debug_view

If you’re used to another development environment: NeoMAD is also a command line tool and therefore easily integrates with other market IDE’s.

Extend NeoMAD functionalities

NeoMAD proposes an advanced mechanism to extend its functionalities. You can embed native code in your projects, Java for Android, BlackBerryOS and Java ME, C# for Windows Phone, Windows 8 and Objective-C for iOS; this embed code will be processed by the NeoMAD compilation chain.

Thanks to this mechanism, you can access functionalities specific to each platform, embed code which has already been written for a particular target and even access components which are not yet available in NeoMAD.

The following example illustrates this functionality.



    package com.neomades.specific;

    public class BrowserTask {
        public void openURL(String url) {
        }
    }

Specific code signature declaration

In order to be able to natively access the different components of each target and enable the NeoMAD compilation chain to recover native code written sources, all you need to do is declare a particular class in the project and define the methods to be subsequently implemented.

NeoMAD provides an assistant enabling the corresponding empty implementations to be automatically generated.

The example provided here enables a url to be loaded in the native browser of each target. This function is already available in NeoMAD and is therefore provided here for demonstration purposes only.


C# implementation

The following code corresponds to the implementation of the openURL() method for Windows Phone and Windows 8 targets.

                                
    using Microsoft.Phone.Tasks;
    using System;
    using System.Text;
    using java.lang;

    namespace com.neomades.specific {

      public class BrowserTask {

        public void openURL(String url) {
          WebBrowserTask task = new WebBrowserTask();
          task.Uri = new Uri(url);
          task.Show();
        }
      }
    }
                            

Objective-C implementation

The following code corresponds to the implementation of the openURL() method for iOS targets.

                                
    #import 

    @implementation com_neomades_specific_BrowserTask

    - (void) openURL___java_lang_String:(java_lang_String*)url {
        [[UIApplication sharedApplication] openURL:[[NSURL alloc] initWithString:url]];
    }

    @end
                            

Java implementation

The following code corresponds to the implementation of the openURL() method for Android targets.

                                
    package com.neomades.specific;

    import com.neomades.app.Application;

    import android.content.Intent;
    import android.net.Uri;

    public class BrowserTask {

        public void openURL(String url) {
            Intent browserIntent = new Intent(Intent.ACTION_DEFAULT, Uri.parse(url));
            browserIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            Application.getCurrent().startActivity(browserIntent);
        }

    }
                            

A powerful conditioning and cloning mechanism

Each NeoMAD project is described by a particular xml file: the URS. This URS file enables the application’s settings to be defined (name, author, version number, resources, permissions, etc).

Each NeoMAD project also has a constants file (Constants.java), enabling the behaviour of your project to be modified at compilation or execution time.

Combining these two files provides great flexibility, thus enabling different binaries to be created from a single project (cloning).

The following case, which you will find in the example provided with NeoMAD, illustrates this conditioning mechanism.


Project description URS file

In this example, we define an application whose name and login will be defined at binary compilation time.

                                
<?xml version="1.0"?>
<urs xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:noNamespaceSchemaLocation="http://www.neomades.com/XSD/0.0.0/urs.xsd">
	<parameters>
		<mainclassname>HelloWorld</mainclassname>
		<applicationname>${APP_NAME}</applicationname>
		<vendor>Neomades</vendor>
		<description>HelloClonedWord application example.</description>
		<packagename>com.neomades.helloworld</packagename>
		<applicationidentifier>com.neomades.${APP_ID}</applicationidentifier>

        <version>1.0.0</version>

		<srcpath>src</srcpath>
		<outputpath>out</outputpath>
	</parameters>

    <strings path="res/strings.csv" />
</urs>

                            

Constants.java file

In this constants file, we declare variables which will be interpreted at binary compilation time according to the compilation settings.
In this case, these variables enable our application’s background colour, name and login to be modified.

All you need to do is specify the correct compilation settings to create 3 different binaries from a single project.

                                
package com.neomades.helloworld;

import com.neomades.mad.TargetInfo;

public class Constants implements TargetInfo {

	/*************************************************************************/
	/**           Let's define some resources for our application            */
	/*************************************************************************/

	/* Application background color **/
	public static int MAIN_SCREEN_BACKGROUND_COLOR;

	/* Application identifier **/
	public static String APP_ID;

	/* Application name **/
	public static String APP_NAME;

	/*************************************************************************/
	/**    Let's compute the resource's values given command line defines    */
	/*************************************************************************/

	/* When specified with -d option, sets the application "red" or "green
	 * Default is "blue" **/
	public static boolean RED = false;
	public static boolean GREEN = false;

	/* The static block allows us to compute values of static variables **/
	static{
		if (GREEN){
			MAIN_SCREEN_BACKGROUND_COLOR = 0x3c7b5c;
			RES_FOLDER = "green";
			APP_ID = "hellogreenworld";
			APP_NAME = "HelloGreenWorld";
		}
		else if (RED){
			MAIN_SCREEN_BACKGROUND_COLOR = 0xb90000;
			RES_FOLDER = "red";
			APP_ID = "helloredworld";
			APP_NAME = "HelloRedWorld";
		}
		else{
			MAIN_SCREEN_BACKGROUND_COLOR = 0x146da7;
			RES_FOLDER = "blue";
			APP_ID = "helloblueworld";
			APP_NAME = "HelloBlueWorld";
		}
	}

	/*************************************************************************/
}