Simplify Android Development Using manifoldJS With Crosswalk

With version 0.3.0 of manifoldJS, you can now choose to build your Android apps with Crosswalk instead of the traditional Android webview. It's quite simple to implement as well.

If you're not familiar, manifoldJS is a new open-source framework that can take a website and create an app for Windows, iOS, Android, Chrome, and Firefox, simplifying the creation of hosted apps across platforms. It debuted at the Microsoft Build 2015 conference in April. manifoldJS runs as a command line tool through Node.js, or you can use the web-based tool.

In this tutorial, I'll show you the simple steps to get it up and running so that you can try it yourself. First, make sure you have manifoldJS installed and running.

Step 1

Install Node.js from nodejs.org.

Step 2

Open your favorite command prompt (Terminal on Mac or Linux) and type:

1	npm install manifoldjs -g

Now, you simply add the Crosswalk flag to your launch parameters, and watch what happens next:

1	manifoldjs http://www.thishereweb.com –p Android –c

And…BOOM! You’ve just built a hosted web app with Crosswalk.

A Practical Example of Crosswalk

With Crosswalk, you can be confident that the newest HTML5 features, such as WebGL, IndexedDB, Web Sockets, and CSS3, are there for your app. For example, here's the output from a WebGL application that uses the default webview and was generated by manifoldJS with the following command:

1	manifoldjs http://get.webgl.org/

And here is the same application with Crosswalk enabled. It was generated after adding the -c (or –-crosswalk) flag to the previous command:

1	manifoldjs http://get.webgl.org/ --crosswalk

Or:

1	manifoldjs http://get.webgl.org/ -c

With Crosswalk, you can be sure that all your users get the intended experience.

What Is Crosswalk?

Crosswalk is a web runtime environment engineered by the Crosswalk Project. Crosswalk has taken the open-source Chromium and Blink engines, and compiled them into a modern, up-to-date runtime environment. You can think of Crosswalk as a powerful webview. In fact, when the Crosswalk flag is set, we use it in place of the traditional Android webview.

Why Is Crosswalk Important?

Crosswalk support brings two main advantages. First, it’s an "updated" web runtime environment. That might not be much of an advantage for Android users on a recent version of the Android OS, but for users on older versions of the OS, it's an immense improvement. The Crosswalk webview will give you access to all the latest HTML5 features and performance gains over the traditional webview.

Secondly, Crosswalk provides a consistent runtime environment. With all the different versions of Android in use today, you have that many different versions of the Android webview, so you’re forced to write to the lowest common denominator. Using Crosswalk removes that hindrance. Additionally, the runtime only changes when you update it in your app, not with the OS. We know that many enterprise users rely on this type of consistency for their applications.

Why Would I Not Use Crosswalk?

I can only think of one reason why you wouldn’t want to use Crosswalk: application size. The average .apk file (an application file for Android) that we produce is just a few megabytes. Adding Crosswalk to the app adds an additional 20MB, close to 60MB once installed on the device. You need to decide whether the resource cost is worth it.

Bundling the runtime with the application is the simplest approach for distribution purposes, but Crosswalk applications can also share a single runtime library (in "shared mode") to lighten the load. A package which enables shared mode is part of the Crosswalk for Android distribution. However, you would have to distribute this shared runtime package yourself. Visit the Crosswalk wiki for more details.

Keep in mind that the nature of a hosted web app is that you make your app updates on your webserver. So in most cases, the cost of the added package size will be felt with the initial download, not with every update like a regular native app.

Advertisement

Go Team Crosswalk

We’re excited to be supporting the Crosswalk web runtime environment. It’s filling a gap in the Android system that makes development simpler and more reliable. Give it a try with your next manifoldJS app and see what you think. For more information on Crosswalk, visit the Crosswalk Project website. To start building store apps from your website, go to the manifoldJS website and get started.

More Hands-On With JavaScript

This article is part of the web development series from Microsoft tech evangelists on practical JavaScript learning, open-source projects, and interoperability best practices, including Microsoft Edge browser and the new EdgeHTML rendering engine. 

We encourage you to test across browsers and devices including Microsoft Edge—the default browser for Windows 10—with free tools on dev.modern.IE:

• Scan your site for out-of-date libraries, layout issues, and accessibility.
• Use virtual machines for Mac, Linux, and Windows.
• Remotely test for Microsoft Edge on your own device.
• Coding Lab on GitHub: Cross-browser testing and best practices.

In-depth tech learning on Microsoft Edge and the Web Platform from our engineers and evangelists:

• Microsoft Edge Web Summit 2015 (what to expect with the new browser, new supported web platform standards, and guest speakers from the JavaScript community)
• Woah, I can test Edge & IE on a Mac & Linux! (from Rey Bango)
• Advancing JavaScript Without Breaking the Web (from Christian Heilmann)
• The Edge Rendering Engine That Makes the Web Just Work (from Jacob Rossi)
• Unleash 3D Rendering With WebGL (from David Catuhe, including the Vorlon.JS and BabylonJS projects)
• Hosted Web Apps and Web Platform Innovations (from Kevin Hill and Kiril Seksenov, including the manifoldJS project)

More free cross-platform tools and resources for the Web Platform:

• Visual Studio Code for Linux, OS X, and Windows
• Code with Node.js and free trial on Azure

Android ListAdapter example

If you want to use a ListView, you will have to supply it with a ListAdapter to allow it to display any content. A few simple implementations of that adapter are already available in the SDK:

• ArrayAdapter<T> (for displaying an array of objects, using toString() to display them)
• SimpleAdapter (for displaying a list of Maps)
• SimpleCursorAdapter (for displaying rows fetched from a database table using a Cursor)

These implementations are perfect for displaying very simple lists. But if your list is just a little more complicated than that, you will need to write your own custom ListAdapter implementation. In most cases it's useful to subclass ArrayAdapter which already takes care of managing a list of objects. Now you only have to tell it how to render each object in the list. Do this by overriding thegetView(int, View, ViewGroup) method of the ArrayAdapter class.

Example of a ListView containing Youtube search results in the form of images and text

The images need to be on-the-fly downloaded from the internet. Let's create a class which represents items in the list:

1. public class ImageAndText {
2.     private String imageUrl;
3.     private String text;
5.     public ImageAndText(String imageUrl, String text) {
6.         this.imageUrl = imageUrl;
7.         this.text = text;
8.     }
9.     public String getImageUrl() {
10.         return imageUrl;
11.     }
12.     public String getText() {
13.         return text;
14.     }
15. }

Now, let's create an implementation of a ListAdapter that is able to display a list of these ImageAndTexts.

1. public class ImageAndTextListAdapter extends ArrayAdapter<ImageAndText> {
3.     public ImageAndTextListAdapter(Activity activity, List<ImageAndText> imageAndTexts) {
4.         super(activity, 0, imageAndTexts);
5.     }
7.     @Override
8.     public View getView(int position, View convertView, ViewGroup parent) {
9.         Activity activity = (Activity) getContext();
10.         LayoutInflater inflater = activity.getLayoutInflater();
12.         // Inflate the views from XML
13.         View rowView = inflater.inflate(R.layout.image_and_text_row, null);
14.         ImageAndText imageAndText = getItem(position);
16.         // Load the image and set it on the ImageView
17.         ImageView imageView = (ImageView) rowView.findViewById(R.id.image);
18.         imageView.setImageDrawable(loadImageFromUrl(imageAndText.getImageUrl()));
20.         // Set the text on the TextView
21.         TextView textView = (TextView) rowView.findViewById(R.id.text);
22.         textView.setText(imageAndText.getText());
24.         return rowView;
25.     }
27.     public static Drawable loadImageFromUrl(String url) {
28.         InputStream inputStream;
29.         try {
30.             inputStream = new URL(url).openStream();
31.         } catch (IOException e) {
32.             throw new RuntimeException(e);
33.         }
34.         return Drawable.createFromStream(inputStream, "src");
35.     }
36. }

The views are inflated from an XML file called "image_and_text_row.xml":

1. <?xml version="1.0" encoding="utf-8"?>
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3.              android:orientation="horizontal"
4.              android:layout_width="fill_parent"
5.              android:layout_height="wrap_content">
7.         <ImageView android:id="@+id/image"
8.                   android:layout_width="wrap_content"
9.                   android:layout_height="wrap_content"
10.                   android:src="@drawable/default_image"/>
12.         <TextView android:id="@+id/text"
13.                  android:layout_width="wrap_content"
14.                  android:layout_height="wrap_content"/>
16. </LinearLayout>

This ListAdapter implementation renders the Image And Texts in the ListView like you would expect. The only thing is that this only works for a very small list which doesn't require scrolling to see all items. If the list of ImageAndTexts gets bigger you will notice that scrolling isn't as smooth as it should be (in fact, it's far off!).

Using ViewFlipper in Android App

Suppose you want to display a news bar in your activity. this news bar displays a single news item at a time then flips and shows next item and so on, then your choice would be Android's ViewFlipper.

ViewFlipper inherits from frame layout, so it displays a single view at a time.
consider this layout:

1. <?xml version="1.0" encoding="utf-8"?>
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3.    android:orientation="vertical"
4.    android:layout_width="fill_parent"
5.    android:layout_height="fill_parent"
6.    >
7. <TextView
8.    android:layout_width="fill_parent"
9.    android:layout_height="wrap_content"
10.    android:text="@string/hello"/>
12.     <Button
13.    android:layout_width="wrap_content"
14.    android:layout_height="wrap_content"
15.    android:text="Flip"
16.    android:id="@+id/btn"
17.    android:onClick="ClickHandler"/>
18.     <ViewFlipper
19.    android:layout_width="fill_parent"
20.    android:layout_height="fill_parent"
21.    android:id="@+id/flip">
22.     <TextView
23.    android:layout_width="fill_parent"
24.    android:layout_height="wrap_content"
25.    android:text="Item1"/>
26.     <TextView
27.    android:layout_width="fill_parent"
28.    android:layout_height="wrap_content"
29.    android:text="Item2"/>
31.     <TextView
32.    android:layout_width="fill_parent"
33.    android:layout_height="wrap_content"
34.    android:text="Item3"/>
35.     </ViewFlipper>
36. </LinearLayout>

Just a ViewFlipper container that contains three text views

Now we want to flip the views when the button is clicked.

1. public void onCreate(Bundle savedInstanceState) {
2.     super.onCreate(savedInstanceState);
3.     setContentView(R.layout.main);
4.     btn=(Button)findViewById(R.id.btn);
5.     flip=(ViewFlipper)findViewById(R.id.flip);
6. }
8. public void ClickHandler(View v)
9. {
10.     flip.showNext();
11. }

If we want to flip in reverese direction we could use flip.showPrevious() instead. If you want to flip to a specific view do the following: flip.setDisplayedChild(indexOfView) replace indexOfView with the integer representing the index of the view you want to switch to.

We can add animations to the child views when they appear or disappear:

1. public void onCreate(Bundle savedInstanceState) {
2.     super.onCreate(savedInstanceState);
3.     setContentView(R.layout.main);
5.     btn=(Button)findViewById(R.id.btn);
7.     flip=(ViewFlipper)findViewById(R.id.flip);
8.     //when a view is displayed
9.     flip.setInAnimation(this,android.R.anim.fade_in);
10.     //when a view disappears
11.     flip.setOutAnimation(this, android.R.anim.fade_out);
12. }

We can also set the ViewFlipper to flip views automatically when the button is clicked:

1. public void ClickHandler(View v)
2. {
3.     //specify flipping interval
4.     flip.setFlipInterval(1000);
5.     flip.startFlipping();
6. }

We can stop the flipping by calling flip.stopFlipping(); method or we can set the flipper to flip autommatically when the activity starts by changing our code.

1. public void onCreate(Bundle savedInstanceState) {
2.     super.onCreate(savedInstanceState);
3.     setContentView(R.layout.main);
5.     btn=(Button)findViewById(R.id.btn);
6.     flip=(ViewFlipper)findViewById(R.id.flip);
7.     flip.setInAnimation(this,android.R.anim.fade_in);
8.     flip.setOutAnimation(this, android.R.anim.fade_out);
9.     flip.setFlipInterval(1000);
10.     flip.setAutoStart(true);    
11. }

More about this control you can read by this url: http://developer.android.com/reference/android/widget/ViewFlipper.html