How We R on Android

The year 2014 frequently was termed the “year of wearable devices”, but besides being able to access e-mail, play games or listen to music, we have yet to see real productivity (including IDEs like RStudio, editors like Emacs or tools like LaTeX and Sweave) on wearable devices like smartphones or even tablets. Although we could not agree more with Bjarne Stroustrup (see the first minute of his YouTube video listed in the Resources for this article), early attempts to bring more productivity to wearables, such as the Ubuntu Edge campaign, so far have failed. We have no doubt that the development of productivity tools for wearable devices will come, but the hype hasn't provided a working solution so far. With that in mind, this article addresses the following question: “How can one run R on Android devices in a productive way?”

For our tests we used the Google Nexus 5 smartphone (released November 2013) with these specs: quad-core 2.3GHz CPU (Snapdragon 800, 32-bit, ARM-based); 32GB memory; 2GB RAM; and Android 5.1.1 (Lollipop). During our testing phase, we also considered Android 4.4 (Kitkat) and Android 5.0 (Lollipop). Note that in practice, people usually would rather work with R on a tablet (or at least a phablet) than on a smartphone. Our choice of such a small device (with a 5" display) is purely to demonstrate the concept and its potential (and because we already owned this device).

The choice of Android as an operating system is natural for these three reasons:

Other approaches for running R on Android (not discussed in this article) are used by the R Console Free and GNURoot apps (available at the Google Play Store). The former allows only limited R functionality under Android; the latter follows a similar paradigm as presented here, but provides only console access to R (one of the more obvious limitations). In particular, both methods do not provide GUI access to R (so no graphics).

Our understanding of productivity goes beyond the functionality of these apps. We aim not only at running a full version of R on Android (including graphics or multicore computing), but also at tools that are naturally required to be productive with R—for example, a full version of an editor like Emacs (including ESS), LaTeX and Sweave (for writing articles or working on presentations during flights). For RStudio users, see the Tips and Tricks section at the end of this article.

We also want to consider some selected auxiliary tools from the Linux world. Note that for some of these tools (like Emacs), specific Android apps are available (such as the Emacs app), but they often are in early stages of development and have frequent crashes (not offering the functionality we need), or they are not well maintained, which leads to bugs we don't want to cope with (we've pointed out several to the respective app developers with minor success in solving them).

Also, none of these apps work or communicate with each other (as they are mainly black boxes), and for a fully functioning “R app”, Android is missing compilers, a shell and an X Window System (among other tools).

Our approach may be a bit more daunting to install, rather than using a simple thin client and connecting to an R server to address the above questions, but this is what we consider to be part of productivity (one advantage is not being limited to Internet access).

The goal is to install a Linux operating system on Android and then install the required productivity tools (including R) under this Linux OS. We then can run an SSH or VNC server on it and connect to it via a terminal or graphically, respectively. Here are the steps:

1) Prepare the Android device. This might be the technically most difficult step, and it is partly device-dependent. In particular, it involves unlocking the device's bootloader (required for rooting the device—that is, gaining root/superuser access to the device) and rooting the device (which is required by the Linux Deploy app to install a Linux OS under Android).

2) Installing and accessing the Linux OS. The main idea here is that the Linux OS will be installed in a so-called change-root (chroot) environment on Android 5.1.1—that is, in a directory tree in which a running program cannot name or access files outside the tree. The Linux OS installed this way allows for root access (and therefore to install the required productivity tools), but sees only this local environment and does not interfere with the Android OS.

3) Installing and using R and related productivity tools. Here we show how you can install R and tools like Emacs (version 24) with Emacs Speaks Statistics (ESS) and the LaTeX system TeX Live (2015) with AUCTeX. We also show how you even can do multicore computations, and we provide some tips and tricks addressing productivity when working with Android.

For this article, we assume you have a laptop computer running an Android Software Development Kit (SDK). We used a MacBook Pro (2015) running OS X Yosemite 10.10.5 and Android Studio as the SDK. During our testing phase with Android 4.4 and 5.0, we used a Lenovo X1 Carbon (2013), which ran Ubuntu 14.10 (the corresponding Android SDK was installed via sudo apt-get install android-tools-adb android-tools-fastboot). Installing these tools is straightforward. We also wanted to use the adb and fastboot tools from the OS X terminal. An easy way to accomplish this is via bash <(curl https://raw.githubusercontent.com/corbindavenport/nexus-tools/master/install.sh).

In short, rooting describes the process of gaining root or superuser access to an Android device, and it's required in order to interact with Android more deeply. Specifically, it's necessary for installing a Linux OS on the device using an app like Linux Deploy (described below). Because rooting typically completely wipes the device, do a complete backup first (rooting also may brick the device, rendering it useless, although this risk nowadays is considered comparably small for newer devices). As a last resort if the rooting procedure fails, you typically can try to flash a factory image (see Resources). A factory image for the Google Nexus 5 is available at https://developers.google.com/android/nexus/images#hammerhead.

The rooting procedure depends on the Android device under consideration (there are many good on-line resources for this). It also may depend on the version number of Android. For example, for a Google Nexus 5 running Android 4.4 and 5.0, we followed the instructions given in the Unlocking the Bootloader and Rooting sidebar. However, Android 5.1.1 requires a different approach (see Resources).

1) Make sure that your device's battery status is at least 80% and that developer mode is enabled (go to Settings→About phone and then tap the build number until developer mode is enabled).

2) Connect the Android device to the laptop via a (micro) USB cable.

3) Download UPDATE-SuperSU-v2.46.zip from www.devfiles.co/download/dr7ZBy0w/UPDATE-SuperSU-v2.46.zip.

4) Use the Android File Transfer app to copy the .zip file to the phone's root directory (the folder shown by default when Android File Transfer is opened; in the Android filesystem, this corresponds to /sdcard or /storage/emulated/0).

5) Download www.devfiles.co/download/iLJJIo60/recovery-clockwork-touch-6.0.4.5-hammerhead.img and put this file in the ~/Library/Android/sdk/platform-tools folder on the laptop.

6) Boot into fastboot mode—typically by shutting down the phone, then pressing and holding both volume keys and the power key.

7) Execute in a shell on the laptop:

cd ~/Library/Android/sdk/platform-tools
fastboot flash recovery recovery-clockwork-touch-6.0.4.5-hammerhead.img

8) Use the volume keys to select “Recovery Mode” on the Google Nexus 5, then press the Power key to enter this mode.

9) From the menu that appears, select “install zip” (via the volume keys), and press the Power key to do so. Select “choose zip from /sdcard”.

10) Use the volume keys to select the .zip file. Choose “yes” to install it, then wait until you see “Install from sdcard complete”.

11) Choose “Go back” from the menu and “reboot system now”, then “Yes - Fix root (/system/xbin/su)”. After this process finishes, you can unplug the phone.

12) Install the Super Su app and reboot the device. Then, install the Root Checker app, open it and grant superuser access. The app then indicates whether rooting the device was successful.

Once the device has been rooted successfully, you can continue installing auxiliary apps and setting up the device.

At this point, you can set up the Android device as desired. For the purposes of this article, we recommend installing the following apps from the Google Play Store:

The goal now is to install a Linux OS (in this case Ubuntu 15.04; during our testing phase, we also considered Debian Testing) in a chroot environment on Android 5.1.1, together with various productivity tools, such as Emacs (version 24) with ESS and TeX Live with AUCTeX. The Linux Deploy app provides a relatively straightforward approach for installing Linux on Android (described below), and updates to Android 5.0 and 5.1.1 also were provided in a reasonable amount of time (and the developer replied to questions).

1) Start Linux Deploy and press the arrow button pointing downward to specify the properties the Linux OS should have.

2) Choose the following:

Now choose “Install” to install the Linux OS (hereby grant root/superuser rights to Linux Deploy via the Super Su app when prompted).

3) Choose “START” from the main menu of Linux Deploy to start the Linux OS (Figure 1). There is also an “Autostart” option available from the settings so that the Linux OS starts once Android is booted.

Figure 1. Running Ubuntu 15.04 via Linux Deploy on a Google Nexus 5 Android Smartphone

Figure 2. Installing Productivity and Auxiliary Tools via apt-get over SSH with JuiceSSH

Starting the Linux OS starts an SSH server (port 22) and a VNC server (port 5900), which allow you to access the Linux OS from Android via the terminal and a GUI, respectively. The following steps detail how to set up an SSH connection via JuiceSSH and then how to set up a VNC connection via VNC Viewer:

1) Open JuiceSSH, navigate to Settings, and set “Popup keyboard position” to “Disabled”.

2) Go back to the main menu, then to “Connections”, and add a new connection. Choose:

3) Go to the “Connections” main menu and choose “Ubuntu” to start the SSH connection to the running Linux OS. When asked for a password, use “changeme”, which is the default for Linux Deploy. You should now be connected to the Linux OS via SSH. Use the Linux passwd command to change the login password.

As mentioned earlier, to get GUI access, including graphics for R, you need to establish a VNC connection. Using VNC Viewer, follow these steps:

1) Open VNC Viewer, press the + and enter:

Then press the check mark to save the connection details.

2) In the main menu, press “Ubuntu” and put in the password “changeme”.

Installing Emacs, ESS, LaTeX and R:

Now you can interact with the Linux OS installed under Android and install software on it. First copy the setup files and folders (for example, .emacs, .emacs.d, .gitconfig, .Renviron, .Rprofile and .ssh) from the laptop to the Linux OS as follows. (See also the Tips and Tricks section. Additionally, you can append personal settings from .bashrc to the .bashrc already available in ~ in the Linux OS.)

1) Open “Android File Transfer” and copy the files to the phone's root directory (the folder shown by default when Android File Transfer is opened). They then appear in /storage/emulated/0 on the Android device and under /mnt/0 from within the Linux OS.

2) From the latter folder, copy (via sudo cp -r) all the files to the home directory ~.

Next, install some basic Linux tools in the terminal via JuiceSSH (note: this may take several hours; see Figure 2 for a screenshot during the installation):

sudo apt-get update
sudo apt-get install a2ps auctex chromium-browser cmake curl 
 ↪emacs24 git htop
sudo apt-get install make okular pdftk preview-latex subversion 
 ↪texinfo unzip wget

Now, you can install ESS, LaTeX and base R via sudo apt-get install ess latex r-base if available on ARM architecture. The drawback is that software like LaTeX typically comes in older versions, so we recommend installing the latest versions from source (see the detailed instructions in the sidebar).

After this installation, restart Linux Deploy (otherwise R is not found from within JuiceSSH or VNC Viewer). Figure 3 shows a screenshot taken during the R installation process (during make), and Figure 4 shows R running over SSH via JuiceSSH.

Figure 3. Installation of R during make

Figure 4. R Running over SSH via JuiceSSH

For installing R packages in a version-independent library, put R_LIBS_SITE=/usr/local/R/library in .Renviron, and make sure the /usr/local/R/library folder exists. You then simply can install most packages via install.packages() or other common methods. We installed a large number of packages (170) on the Linux OS, without problems; see Figures 5 and 6.

Figure 5. R Running via Emacs (and ESS) over VNC via VNC Viewer

Figure 6. A Snapshot of the Installation Process of Various R Packages

As a proof of concept and for roughly comparing runtimes with the laptop, we briefly ran two R example scripts on the Google Nexus 5 smartphone. The first is a shorter and slightly adapted version from the vignette of the R package “parallel”:

require(parallel)
require(boot)
require(microbenchmark)

## Setup
dat <- cd4
B <- 1000 # bootstrap replications
mle <- list(mean=colMeans(dat), var=var(dat))
dat.rng <- function(data, mle) MASS::mvrnorm(nrow(data), mle$m, mle$v)
bstr <- function(...) boot(dat, statistic=corr, R=B, sim="parametric",
                           ran.gen=dat.rng, mle=mle)

## Non-parallel version
N <- 100 # number of repetitions
set.seed(271)
mc <- 2 # number of cores
(mbm.nonpara <- microbenchmark(res.nonpara <- do.call(c, 
 ↪lapply(seq_len(mc), bstr)), times=N))

## Multicore version
set.seed(271)
(mbm.mc <- microbenchmark(res.mc <- do.call(c, mclapply(seq_len(mc), 
 ↪bstr)), times=N)) # ms

As a second example, we ran a slightly adapted version of “demo(VaRsuperadd)” from the R package “simsalapar”:

require(simsalapar)
require(copula)

## Setup
n.obs <- 1e4 # sample size
n.alpha <- 128 # number of quantiles
varList <- # list of variables
    varlist(
        n = list(value = n.obs), # sample sizes
        d = list(type="grid", value = c(4, 20, 100)), # dimensions
        family = list(type="grid", expr = quote(C), # copula families 
 ↪(t=t_4)
                      value = c("normal", "t", "Clayton", "Gumbel")),
        tau = list(type="grid", value = c(0.2, 0.5, 0.8)), 
 ↪# Kendall's tau
        qmargin = list(type="inner", expr = quote(F[j]), # margins
                      value = c(norm = qnorm,
                                t4   = function(p) qt(p, df=4),
                                Par2 = function(p) (1-p)^(-1/2))), 
 ↪# Pareto(2)
        alpha = list(type="inner", value = 0:n.alpha/n.alpha)) 
 ↪# VaR confidence levels

## Function to Compute F_{X_1+..+X_d}(d*F_1^-(\alpha))
doOne <- function(n, d, family, tau, qmargin, alpha)
{
    cop <- switch(family,
                "normal" =
                  ellipCopula("normal", 
 ↪param=iTau(ellipCopula("normal"), tau=tau),
                              dim=d),
                "t" =
                  ellipCopula("t", param=iTau(ellipCopula("t"), 
 ↪tau=tau), dim=d),
                "Clayton" =
                  onacopulaL("Clayton", 
 ↪list(th=iTau(archmCopula("clayton"), tau),
                                             seq_len(d))),
                "Gumbel" =
                  onacopulaL("Gumbel", 
 ↪list(th=iTau(archmCopula("gumbel"), tau),
                                            seq_len(d))),
                stop("unsupported 'family'"))
    U <- rCopula(n, copula=cop) # sample from the copula

    ## compute F_{X_1+..+X_d}(d*F_1^-(\alpha)) for all confidence 
 ↪levels alpha
    ## => VaR_alpha superadditive <=> F_{X_1+..+X_d}(d*F_1^-(\alpha)) - 
 ↪alpha < 0
    t(sapply(qmargin, function(FUN) 
 ↪ecdf(rowSums(FUN(U)))(d*FUN(alpha)) - alpha))
}

## Run
(dc <- parallel::detectCores())
(nc <- if(dc <= 2) 1 else 2)
system.time(res <- doMclapply(varList, cores=nc, doOne=doOne))

## Results
val  <- getArray(res) # array of values
err  <- getArray(res, "error") # array of error indicators
warn <- getArray(res, "warning") # array of warning indicators
time <- getArray(res, "time") # array of user times in ms

## Warnings, errors, run time
if(any(err > 0))
ftable(100* err, col.vars="tau") # percentage of errors
if(any(warn > 0))
ftable(100*warn, col.vars="tau") # percentage of warnings
ftable(time, row.vars=c("family", "d"), col.vars="tau") # run time

## Plot of VaR estimates (for t_4 margins)
m <- "t4"
dimnames(val)[["tau"]] <- paste0("tau==", dimnames(val)[["tau"]])
mayplot(val[qmargin=m,,,,], varList, row.vars="family", col.vars="tau",
        xvar="alpha", ylim="local")

The latter example concerns a standard problem in Quantitative Risk Management and involves simulating high-dimensional multivariate random vectors from various distributions, approximating the distribution function of the sum of their components and deciding, for a range of quantiles, whether the risk measure Value-at-Risk is subadditive (see the article by M. Hofert and M. Mächler, “Parallel and other simulations in R made easy: An end-to-end study”, Journal of Statistical Software, 69(4), 2016 for more details).

Figure 7 shows the example while being run on two of the four cores of the smartphone (see the htop output) and the graphical output of the result (Figure 8). This example was run exactly as on the laptop, by opening Emacs and executing the code line by line as one would do with most R scripts; in particular, we did not have to change our workflow to run this code on Android as we essentially run it on a Linux OS.

Figure 7. R Code Running on Two Cores of a Google Nexus 5 Android Smartphone over a VNC Connection via VNC Viewer

Figure 8. The Graphical Output of the Result from Figure 7

Table 1 shows the runtimes of the examples on the Google Nexus 5 smartphone and a MacBook Pro (2015) in a single-core and a multi-core setup. Runtime for Example 1 is measured by microbenchmark. Runtime for Example 2 is by system.time() in the form (user, system, elapsed).

Clearly, this provides only a limited insight as to R's performance on a mobile device, but there are a few things to note:

The approach described above to run R on Android seems easier than it is. In fact, we had to do the installation procedure described here a couple times to overcome various challenges. Considering some of these issues, here are some tips and tricks:

This article presents an approach for running a full version of R and related productivity software on Android devices within a Linux OS in a chroot environment. SSH or GUI access (via VNC) allow you to connect to the Linux OS and run R and related productivity tools (even on multiple cores).

Some advantages of this approach:

Although no real show-stoppers, there are some drawbacks we should mention as well:

Overall, we were pleasantly surprised by how “far” mobile productivity (including R) already is, and we hope that the quirks will be solved in the near future. Projects like Remix Mini (https://www.kickstarter.com/projects/1123481999/remix-mini-the-worlds-first-true-android-pc) even aim at bringing this experience (and the related “less is more” paradigm) to the desktop (still in a portable way). For future research, a glance toward Mac OS/iOS certainly would be interesting. Besides available thin clients, the current state of the art on mobile iDevices is unclear to us. A rather old post (www.r-bloggers.com/running-r-on-an-iphoneipad-with-rstudio) briefly addresses some issues (such as jailbreaking and performance), but that might not apply to newer Apple devices anymore.