A different approach to building mobile apps: iOS and Android code sharing

[[120234]]

In the past few years, mobile applications have taken the world by storm, changing the way we use the Internet in all aspects of work and life. Various technologies for creating mobile applications have also emerged, and various development processes have also treated mobile applications as first-class citizens and begun to consider adapting to mobile development processes. Although it feels like they are everywhere, the real era of mobile applications has just begun. We are about to face a new generation of mobile devices, such as wearable devices or various mobile devices that make up the Internet of Things. We will face new user interaction interfaces for displaying data and receiving commands. We also recognize that more and more companies will truly adopt a mobile-first strategy. All of this will have a huge impact on the way we design, develop, and test software in the next few years.

There are thousands of mobile apps for various purposes in the Apple and Android app stores. Apps on iOS devices are usually created using the Objective-C tool library, while apps on Android devices are based on the Java language. In this article we will show you two less common methods of building native apps using Java and Xtend, which can help developers share code on both application platforms, thereby simplifying development work.

Developing native iOS apps using Java and RoboVM

Mobile application developers who target both Android and iOS often face many challenges. When comparing the native application development environments of the two platforms, such as the development tool chains provided by Google and Apple, it is easy to find that there are essential differences between the two. The Android development environment provided by Google is based on the Eclipse integrated development environment and the Java programming language. The iOS development environment provided by Apple is based on the Xcode integrated development environment and the Objective-C programming language.

The differences between these platforms make it impossible to reuse code. And few developers are proficient in both environments. As a result, almost every cross-platform mobile application requires a separate development team and a separate code base for each platform.

RoboVM is a new open source project that aims to solve the above problems without affecting the developer and application user experience. The goal of the RoboVM project is to use Java and other JVM languages ​​​​such as Scala, Clojure, and Kotlin on iOS devices. Unlike other similar tools, RoboVM does not impose any restrictions on the Java platform features used by developers, such as reflection mechanisms or file I/O, and also allows developers to reuse Java's huge third-party library ecosystem. RoboVM is also unique in that developers can access the full native iOS API through a Java to Objective-C bridge. In this way, when developing applications, real native user interaction interfaces can be written in Java and full hardware access rights can be obtained. At the same time, the development tools used are also familiar to Java developers, such as Eclipse and Maven.

With RoboVM, cross-platform development becomes relatively easy; the same group of Java developers will be able to build two versions of a mobile application and a significant portion of the code base can be shared.

How to get started?

RoboVM can be called in a variety of ways, such as command line or using Maven or Gradle. The easiest way to get started should be to use the RoboVM Eclipse plug-in.

Configuration requirements

Before installing the RoboVM Eclipse plug-in, ensure that your system meets the following requirements:

• A Mac computer running Mac OS X 10.9.
• Oracle Java SE 7 JDK.
• Xcode 5.x integrated development environment downloaded from the Mac App Store.

It is important to note that you must use Oracle Java SE 7 JDK to run Eclipse. Eclipse will not run properly on Apple's Java 6 JVM.

Install RoboVM Eclipse plugin

Once your system meets all the prerequisites, installing the plugin is a simple task: Open the Eclipse Marketplace from the Eclipse Help menu, search for RoboVM and click Install Now.

Alternatively, you can use the following update site.

Run a simple iOS app

Next we will create a simple iOS application. First create a new project: File => New => Project....... Select the RoboVM iOS Project wizard from the list.

Enter IOSDemo in the Project Name, Main Class and App name fields, and enter org.robovm.IOSDemo in the App id field. Keep the default values ​​for other fields and click Finish.

Then, create a new class file named IOSDemo, omitting the package name. Copy and paste the following code into the newly created file, replacing the code automatically generated by Eclipse.

 import org.robovm.apple.coregraphics.*;
 import org.robovm.apple.foundation.*;
 import org.robovm.apple.uikit.*; 
 
 public   class IOSDemo extends UIApplicationDelegateAdapter { 
 
 private UIWindow window = null ;
 private   int clickCount = 0 ; 
 
 @Override  
 public   boolean didFinishLaunching(UIApplication application,
            NSDictionary launchOptions) { 
 
 final UIButton button = UIButton.create(UIButtonType.RoundedRect);
        button.setFrame( new CGRect( 115 .0f, 121 .0f, 91 .0f, 37 .0f));
        button.setTitle( "Click me!" , UIControlState.Normal); 
 
        button.addOnTouchUpInsideListener( new UIControl.OnTouchUpInsideListener() {
 @Override  
 public   void onTouchUpInside(UIControl control, UIEvent event) {
                button.setTitle( "Click #" + (++clickCount), UIControlState.Normal); 
 
 }
 }); 
 
            window = new UIWindow(UIScreen.getMainScreen().getBounds());
            window.setBackgroundColor(UIColor.colorLightGray());
            window.addSubview(button);
            window.makeKeyAndVisible(); 
 
 return   true ;
 } 
       
 public   static   void main(String[] args) {
            NSAutoreleasePool pool = new NSAutoreleasePool();
            UIApplication.main(args, null , IOSDemo. class );
 pool.close();
 }
 }

***, right-click the newly created project and select Run As... =>iOS Simulator App (iPhone) to start the application in the iOS simulator. In this way, the application runs on a simulated iPhone.

[[120235]]

If you need to run the application on a real device, you need to use the Run As... =>iOS Device App option. Please note that the device you are using needs to be configured before executing this option. The configuration process is beyond the scope of this article. Please refer to Apple's official documentation for more information.

#p#

Creating an IPA file for app store distribution

If the Distribution Certificate and Provisioning Profile for the App Store are ready, creating an IPA package for submission to the App Store only requires right-clicking the RoboVM iOS project in Eclipse, selecting RoboVM Tools=>Package for App Store/Ad-Hoc distribution… , and filling in the relevant information in the dialog box.

After completing the above operations, a file with the suffix .IPA will be generated in the target folder. Use Application Loader to verify the generated IPA file and submit it to the app store. Use Spotlight to easily locate the Application Loader application.

You can find a lot of resources on the Apple website about how to join the iOS Developer Program and how to create certificates and app description files for App Store distribution.

Underlying implementation mechanism

Bytecode compiler

The core of RoboVM is its precompiler. The precompiler can be called from the command line or from a build tool or IDE such as Maven or Gradle. It translates Java bytecode into machine code for a specific operating system and CPU model. Generally, it translates into machine code for iOS and ARM processors, but RoboVM also supports converting bytecode into machine code for Mac OS X and Linux systems running on x86 CPUs (32-bit).

This pre-compilation method is very different from the working mechanism of traditional JVMs such as Oracle Hotspot. These JVMs usually read Java bytecode at runtime and then execute the virtual machine instructions contained in the bytecode in some way. To speed up this process, JVM uses a technology called just-in-time compilation. In simple terms, this process translates the virtual machine instructions of a method into machine code corresponding to the CPU model used by the current system when the program calls it for the first time.

Due to technical limitations built into iOS by Apple, it is not possible to use any form of just-in-time compilation in iOS applications. The only alternative is to use an interpreter or pre-compilation technology like the one used in RoboVM, which is slow and consumes a lot of power. The pre-compilation process happens when the code is compiled on the developer's machine, and when it is run on an iOS device, the generated machine code can run at full speed, so the speed can be comparable to the code generated by Objective-C compilation, or even faster.

Since the RoboVM precompiler consumes Java bytecode, not Java source code, it can be used, at least in theory, for any JVM language that can be compiled to bytecode. Currently, the JVM languages ​​that the RoboVM precompiler is known to work with are Scala, Clojure, and Kotlin. Another benefit of this approach is that RoboVM can be used on third-party libraries in standard JAR files without any original source code, so that proprietary and closed-source libraries can be used in your application.

Incremental compilation

Even very simple RoboVM applications, such as the IOSDemo application, take a long time to start for the first time. The process of compiling an application by the RoboVM compiler starts with the application's main class. It then compiles all the classes used by the main class, and then compiles all the classes used by the previous class, and so on, until all the classes required by the application are compiled. In this process, standard runtime classes, such as java.lang.Object and java.lang.String, are also included in the scope of compilation. This is a one-time process. RoboVM caches compiled classes and will only recompile a class if a class or a class with which it has a direct dependency has changed.

The benefit of incremental compilation and caching target files is that it can reduce the time spent on compilation. Including only classes that can be reached from the Main class in the generated executable file can reduce the size of the executable file. However, in some cases (such as when loading classes through reflection), the RoboVM compiler cannot decide whether a class should be compiled. However, you can give instructions to the compiler to explicitly include a specific class or all classes that meet a certain condition in the compilation scope.

Android-based runtime library

Any JVM virtual machine needs a runtime library. This library provides standard packages and classes for all Java programs, such as java.lang.Object and java.lang.String. RoboVM's runtime library comes from the Android open source project and has been ported to RoboVM's non-Android-specific packages. This means that if the Java or JVM code only uses classes in the Android standard package, then the code can run normally on RoboVM.

RoboVM Status

RoboVM is still under development, but it is basically usable. Version 1.0 is expected to be released before the end of 2014.

There are already at least 50 RoboVM-based apps in the Apple App Store. A complete list of known apps can be found here.

Currently, about 50% of iOS APIs can be used in iOS applications based on RoboVM. The current status of these bindings can be found on the RoboVM Wiki. As of now, RoboVM can run code written in Scala, Clojure and Kotlin.

The documentation for RoboVM is still being improved. When version 1.0 is released later in 2014, it will be more fully documented.

RoboVM applications are still not debuggable. This issue will also be resolved later this year.

limit

RoboVM can only load precompiled classes into applications. This means that in RoboVM applications, it is not possible to use a custom class loader to dynamically create bytecode and load it into the application at runtime. In other words, RoboVM cannot support technologies that create or modify classes at runtime.

More information

• For more information about the RoboVM project, see the RoboVM website.
• You can download the RoboVM source code from GitHub
• For information on how to configure test devices, refer to Apple's document "Configuring iOS Devices for Development".
• For information on how to submit your app to the App Store, please refer to Apple's App Publishing Guide.

Creating Android Apps with Xtend

About Xtend

Xtend 1 is a statically typed programming language that compiles to readable Java source code. The language itself is a shining example of its kind, especially in terms of readability and strong extensibility, but it also makes Java's interoperability issues obvious. The language promotes a functional programming style and features such as multiple dispatch, extension methods, lambda expressions, and compile-time macros. Unlike other Java alternatives, Xtend does not include a large standard library itself, but only adds some extension methods on top of the standard JDK. Xtend also ensures that Java interoperability issues are avoided and provides strong IDE support.

Why is Java so difficult to use on Android?

Java code tends to be quite verbose, especially on Android. The Android API is low-level and often has poorly defined types (int everywhere). Another annoyance is the ubiquitous use and binding of XML files. Since Java 8 is not yet supported on Android, we also have to carefully read the ubiquitous anonymous classes. And unfortunately, Java cannot trim the code to enhance readability, so we can only clutter the code with redundant symbols, type information, and boilerplate idioms.

Android's JVM language requirements

A replacement for the Java language on Android must be able to ensure that it does not add any runtime system overhead, which excludes all dynamic languages. In addition, any unnecessary indirect type conversions are not desired. For example, only Java and Android types should be used in the code, and there should be no need to convert back and forth due to interoperability issues. This is not only a performance concern, but also annoying when debugging. ***, the Android system limits each application to only 65536 methods. Therefore, when looking for a replacement for Java, it is important not to add a large standard SDK to the application, because this will greatly reduce the number of methods available to developers. For example, using the Groovy SDK will add more than 8,000 methods.

Xtend - The best solution for Android development?

Xtend can be converted into authentic Java source code, and basically only depends on JDK and Android system classes. At runtime, there is no indirect addressing, conversion or any other additional overhead. In other words, Xtend code can run at basically the same speed as Java source code. In addition, Xtend also includes a streamlined runtime library for the Android system, which is only 275kb in size and contains almost everything you need. The Xtend Eclipse plugin is also well integrated with ADT (Android Development Tools), and even provides a corresponding Gradle plugin for the new Android build system3. Let's take a closer look at how to use Xtend to improve typical Android code.

Hello Android!

As usual, let's start with a simple Hello World example program:

 class HelloWorldActivity extends Activity { 
 
 override protected   void onCreate(Bundle savedInstanceState) {
 super .onCreate(savedInstanceState) 
    
      val button = new Button( this )
      button.text = "Say Hello!"    
      button.onClickListener = [
         Toast.makeText(context, "Hello Android from Xtend!" , Toast.LENGTH_LONG).show
 ]
      val layout = new LinearLayout( this )
      layout.gravity = Gravity.CENTER
 layout.addView(button)
 contentView = layout
 }
 }

For Java developers, this example uses a Java-like programming style, so it will look very familiar at first glance. In addition, you may notice that 100% of the APIs used in the example come from Android SDK and JDK.

The main differences are:

• No semicolon (semicolon is optional)
• Accessing object properties using setters and getters
• Default visibility of properties (e.g. classes are public by default)
• Using lambda expressions instead of anonymous classes

There is a lot to explore in depth in terms of language features, but before that, let's take a look at how to integrate the Xtend compiler with the corresponding Android build process.

#p#

Building with Gradle

Xtend has plugins for the three most commonly used build systems: Maven, Gradle, and Ant. Google recently introduced a new Gradle-based build system for Android projects. Next, let's take a look at what needs to be done to build our "Hello World" project using Gradle.

This article assumes that you have installed the latest version of Gradle and Android SDK on your system and set the ANDROID_HOME environment variable correctly. At the same time, you have added the Gradle /bin directory to the PATH environment variable.

Next, you need to add the build script "build.gradle" to the root directory of your Eclipse Android project. The build.gradle file sample is as follows:

 buildscript {
 repositories {
 mavenCentral()
 }
 dependencies {
      classpath 'com.android.tools.build:gradle:0.8.+'  
      classpath 'org.xtend:xtend-gradle-plugin:0.1.+'    
 }
 } 
 
 apply plugin: 'android'   
 apply plugin: 'xtend-android'    
 
 repositories {
 mavenCentral()
 } 
 
 dependencies {
  compile ( 'org.eclipse.xtend:org.eclipse.xtend.lib:2.6.+' )
 } 
 
 android {
 compileSdkVersion 19   
 buildToolsVersion "19.1.0"  
 sourceSets {
 main {
 manifest {
            srcFile 'AndroidManifest.xml'   
 }
 java {
 srcDir 'src'   
 }
 res {
 srcDir 'res'   
 }
 assets {
 srcDir 'assets'   
 }
 resources
 srcDir 'src'   
 }
 aidl
 srcDir 'src'   
 }
 }
 }
 }

Its main job is to import and call the Maven and Xtend build plugins. In addition, we add the runtime library to the project and tell the Android plugin that we are using the Eclipse style project layout. Once the above work is completed, go to the root directory of the project in a command line window and run "gradle build", and Gradle will do all the rest for you.

Xtend in Depth

In addition to syntax sugar, Xtend also comes with many very useful language features, such as operator overloading, template expressions, and switch expressions. And you can also create new features by combining different functions. For example, if you need a dynamic UI, you can't build it with a static XML file, but need to write it declaratively. Xtend provides developers with support for builder syntax. The UI implementation code of the "Hello World" example is as follows:

 import   static extension com.example.helloworld.UiBuilder.* 
 
 class HelloWorldActivity extends Activity { 
 
 override protected   void onCreate(Bundle savedInstanceState) {
 super .onCreate(savedInstanceState) 
 
      contentView = linearLayout [
         gravity = Gravity.CENTER
         addButton( "Say Hello!" ) [
            onClickListener = [
               Toast.makeText(context,
 "Hello Android from Xtend!" ,
                              Toast.LENGTH_LONG).show
 ]
 ]
 ] 
 
 }
 }

The linearLayout(Context ctx, (LinearLayout)=>void initializer) and button(ViewGroup group, String name, (Button)=>void initializer) methods are introduced as extensions to Activity. These two methods take a lambda function as one of their parameters. The parameter passed into the lambda function is called implicit it, and similar to this, implicit it does not need to be explicitly dereferenced. As shown above, the combination of lambda functions, extension methods and implicit it can produce a very beautiful builder syntax. Many other beautiful APIs can also be built through Xtend, allowing code to be written in an easy-to-read declarative way.

Greetings from XML hell!

A large part of the daily work of Android developers is to configure and develop various XML files, which are used as resources for internationalized strings or for declarations of various views. The Android platform recommends the use of XML files because the platform has provided developers with solutions for large devices and SDK fragmentation. However, the application cannot ultimately consist of only static views and data. Developers need to combine all the materials and give them life. On the Android platform, these tasks are completed through the R class. This automatically generated class contains many integer constants corresponding to the various elements declared in the XML file. Suppose the following two elements are declared in a view XML file, and clicking the Button can update the message in the TextView:

 < TextView   android:id = "@+id/message_view"  
 android:layout_weight = "1"  
 android:layout_width = "0dp"  
 android:layout_height = "wrap_content"  
 android:hint = "@string/empty"   >  
 < Button  
 android:layout_width = "wrap_content"  
 android:layout_height = "wrap_content"  
 android:onClick = "sayHello"  
 android:text = "@string/hello_world"   >  
 </ Button >   

The typical Android development method is to get control of TextView through the constants generated in the R class and then implement the onClick callback method "sayHello":

 class HelloWorldActivity extends Activity { 
 
 TextView messageView 
 
 override protected   void onCreate(Bundle savedInstanceState) {
 super .onCreate(savedInstanceState)
 // set the view using the int constant  
      contentView = R.layout.main
 // get a handle on the TextView  
      messageView = findViewById(R.id.message_view) as TextView
 } 
 
 /**
    * Callback automatically called by Android
 */   
   def void sayHello(View v) {
     messageView.text = "Hello Android from Xtend!"   
 }
 }

The above is a typical Android code that contains unsafe type conversions, naming conventions, and various boilerplate files. With Xtend we can do better.

Hello, Xtendroid!

Xtendroid4 is a small project that provides class libraries and so-called active annotations for Android development. Active annotations can be understood as compile-time macros that can participate in the compilation process from Xtend to Java. You can modify the annotated classes at will, generate additional types or use this hook to read and write plain text files.

With just one annotation, we know which view to bind and annotations can also help us generate boilerplate files. In addition, it can also provide type-safe element access methods and callback methods. The following code is an Activity class written with Xtendroid's @AndroidActivity annotation.

 @AndroidActivity (R.layout.main) class HelloWorldActivity { 
 
 /**
 * Type safe callback
 */   
   override void sayHello(View v) {
      messageView.text = "Hello Android from Xtend!"   
 }
 }

Now, the Activity only contains the behaviors we want to add. All other settings are automatically implemented, such as setting up channel bindings, content views, or boilerplate files that extend the Activity. And now everything is type-safe, and the IDE can understand the ins and outs and provide developers with appropriate auto-completion suggestions.

In addition, Xtendroid can also facilitate developers to process JSON objects, resource files or SQLite databases. Moreover, active annotations exist in the form of libraries, so developers can easily build libraries that are more suitable for them by developing or customizing existing libraries.

You can start trying out the above for yourself by downloading Eclipse from 1 below and installing ADT using the update site 5. The Xtendroid project contains many examples similar to the ones shown in this article. *** Have fun with it.

1. Eclipse Xtend
2. Xtend Gradle plugin
3. Android Gradle plugin
4. Xtendroid
5. ADT Update Site

About the Author

[[120236]]

Niklas Therning is the creator and co-founder of the open source RoboVM project - a major contributor to the RoboVM project. He has made it his mission to bring Java to the iOS platform in a sensible way. Prior to starting RoboVM, Niklas co-founded the SpamDrain anti-spam service and worked as a contractor for it, mainly in Java EE and web application development. Niklas holds a Master of Science in Computer Science from Chalmers University of Technology in Gothenburg, Sweden. Follow him on Twitter @robovm.

[[120237]]

Sven Efftinge is a passionate software developer who enjoys kitesurfing, music and good food. He is the project leader for Xtext, a programming language, a domain specific language and a framework for the statically typed programming language Xtend for the JVM. At itemis in Kiel, Sven leads a research department.

In the past few years, mobile applications have taken the world by storm, changing the way we use the Internet in all aspects of work and life. Various technologies for creating mobile applications have also emerged, and various development processes have also treated mobile applications as first-class citizens and begun to consider adapting to mobile development processes. Although it feels like they are everywhere, the real era of mobile applications has just begun. We are about to face a new generation of mobile devices, such as wearable devices or various mobile devices that make up the Internet of Things. We will face new user interaction interfaces for displaying data and receiving commands. We also recognize that more and more companies will truly adopt a mobile-first strategy. All of this will have a huge impact on the way we design, develop, and test software in the next few years.

Original translation: A different approach to creating mobile apps

Unusual Ways to Create a Mobile App