android: run go backend on a dedicated service

Before this, the Go backend was invoked on Android throught the
`GoViewModel` class. We recently discovered that this solution could
cause timeout errors if the app loose the focus during a polling to the
bb02, e.g. while the user is verifying an address.

The Go backend is now started and executed inside a dedicated
`GoService`, bound to the `MainActivity`.
When the service starts it immediately promotes itself to foreground
process, to mantain a good priority even when the app is out of focus.
In order to go foreground the process needs a dedicated notification,
that is set to a low priority level to be as less intrusive as possible
(basically a text in the taskbar that says that the app is running).

Author: Beerosagos

frontends/android/BitBoxApp/app/src/main/AndroidManifest.xml

@@ -11,6 +11,9 @@
     <uses-feature android:name="android.hardware.camera" android:required="false" />
     <uses-feature android:name="android.hardware.camera.autofocus" android:required="false" />
 
+    <!-- for Go backend service -->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
+
     <!-- to allow external links and mailto -->
     <queries>
         <intent>
@@ -62,5 +65,6 @@
             <meta-data android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED"
                 android:resource="@xml/device_filter" />
         </activity>
+        <service android:name=".GoService" />
     </application>
 </manifest>

frontends/android/BitBoxApp/app/src/main/java/ch/shiftcrypto/bitboxapp/GoService.java

@@ -0,0 +1,104 @@
+package ch.shiftcrypto.bitboxapp;
+
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.Intent;
+import android.graphics.drawable.Icon;
+import android.os.Binder;
+import android.os.Build;
+import android.os.IBinder;
+
+import androidx.core.app.NotificationCompat;
+
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+import goserver.GoAPIInterface;
+import goserver.GoEnvironmentInterface;
+import goserver.Goserver;
+
+public class GoService extends Service {
+    // Binder given to clients
+    private final IBinder binder = new GoServiceBinder();
+
+    private boolean started = false;
+
+    private Lock startedLock = new ReentrantLock();
+
+    private final String channelId = "21";
+
+    private final int notificationId = 8;
+
+    @Override
+    public void onCreate() {
+        Util.log("GoService onCreate()");
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            NotificationChannel channel = new NotificationChannel(
+                    channelId,
+                    "BitBoxApp",
+                    NotificationManager.IMPORTANCE_LOW
+            );
+            channel.setDescription("BitBoxApp service notification channel");
+            NotificationManager manager = getSystemService(NotificationManager.class);
+            manager.createNotificationChannel(channel);
+        }
+        // Create a PendingIntent that starts the main activity of your app
+        Intent notificationIntent = new Intent(getApplicationContext(),MainActivity.class);
+        notificationIntent.setAction(Intent.ACTION_MAIN);
+        notificationIntent.addCategory(Intent.CATEGORY_LAUNCHER);
+        notificationIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+
+        PendingIntent contentIntent = PendingIntent.getActivity(
+                getApplicationContext(),
+                0,
+                notificationIntent,
+                PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE);
+        Notification notification = new NotificationCompat.Builder(this, channelId)
+                .setContentTitle(getString(R.string.app_name))
+                .setContentText("Running in the background to ensure connection stability")
+                .setSmallIcon(R.drawable.ic_notification)
+                .setWhen(System.currentTimeMillis())
+                .setContentIntent(contentIntent)
+                .setAutoCancel(true)
+                .build();
+        startForeground(notificationId,notification);
+
+        // The service goes in foreground to keep working normally even when the app is out of
+        // focus. This is needed to avoid timeouts when the backend is polling the BitBox for e.g.
+        // an address verification.
+        startForeground(notificationId, notification);
+        Util.log("GoService onCreate completed");
+    }
+
+    @Override
+    public void onDestroy() {
+        Util.log("GoService onDestroy()");
+    }
+
+    public void startServer(String filePath, GoEnvironmentInterface goEnvironment, GoAPIInterface goAPI) {
+        Util.log("GoService: Starting server...");
+        startedLock.lock();
+        if (!started) {
+            Goserver.serve(filePath, goEnvironment, goAPI);
+            started = true;
+            Util.log("server started!");
+        } else {
+            Util.log("server already started!");
+        }
+        startedLock.unlock();
+    }
+
+    public class GoServiceBinder extends Binder {
+        GoService getService() {
+            return GoService.this;
+        }
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return binder;
+    }
+}

frontends/android/BitBoxApp/app/src/main/java/ch/shiftcrypto/bitboxapp/GoViewModel.java

@@ -1,30 +1,29 @@
 package ch.shiftcrypto.bitboxapp;
 
-import goserver.GoDeviceInfoInterface;
-import goserver.GoEnvironmentInterface;
-import goserver.GoReadWriteCloserInterface;
-import goserver.GoAPIInterface;
-import goserver.Goserver;
-
-import android.content.Context;
-import android.net.ConnectivityManager;
-import android.net.NetworkCapabilities;
-import android.net.NetworkInfo;
-import android.os.Build;
-import android.os.Message;
-import android.os.Handler;
 import android.app.Application;
+import android.content.Context;
 import android.hardware.usb.UsbConstants;
 import android.hardware.usb.UsbDevice;
 import android.hardware.usb.UsbDeviceConnection;
 import android.hardware.usb.UsbEndpoint;
 import android.hardware.usb.UsbInterface;
 import android.hardware.usb.UsbManager;
+import android.net.ConnectivityManager;
+import android.net.NetworkCapabilities;
+import android.net.NetworkInfo;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Message;
 
 import androidx.lifecycle.AndroidViewModel;
 
 import java.util.Locale;
 
+import goserver.GoAPIInterface;
+import goserver.GoDeviceInfoInterface;
+import goserver.GoEnvironmentInterface;
+import goserver.GoReadWriteCloserInterface;
+
 public class GoViewModel extends AndroidViewModel {
 
     private class GoDeviceInfo implements GoDeviceInfoInterface {
@@ -180,19 +179,24 @@ public void pushNotify(String msg) {
     private GoEnvironment goEnvironment;
     private GoAPI goAPI;
 
+    public GoEnvironment getGoEnvironment() {
+        return goEnvironment;
+    }
+
+    public GoAPI getGoAPI() {
+        return goAPI;
+    }
+
     public GoViewModel(Application app) {
         super(app);
 
         this.goEnvironment = new GoEnvironment();
         this.goAPI = new GoAPI();
-
-        Goserver.serve(app.getApplicationContext().getFilesDir().getAbsolutePath(), this.goEnvironment, this.goAPI);
     }
 
     @Override
     public void onCleared() {
         super.onCleared();
-        Goserver.shutdown();
     }
 
     public void setMessageHandlers(Handler callResponseHandler, Handler pushNotificationHandler) {

frontends/android/BitBoxApp/app/src/main/java/ch/shiftcrypto/bitboxapp/MainActivity.java

@@ -5,15 +5,18 @@
 import android.app.AlertDialog;
 import android.app.PendingIntent;
 import android.content.BroadcastReceiver;
+import android.content.ComponentName;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.IntentFilter;
+import android.content.ServiceConnection;
 import android.content.pm.PackageManager;
 import android.content.res.Configuration;
 import android.hardware.usb.UsbDevice;
 import android.hardware.usb.UsbManager;
 import android.net.Uri;
+import android.os.IBinder;
 import android.os.Process;
 import androidx.appcompat.app.AppCompatActivity;
 import androidx.core.app.ActivityCompat;
@@ -59,6 +62,27 @@ public class MainActivity extends AppCompatActivity {
     // stores the request from onPermissionRequest until the user has granted or denied the permission.
     private PermissionRequest webViewpermissionRequest;
 
+    GoService goService;
+
+    // Connection to bind with GoService
+    private ServiceConnection connection = new ServiceConnection() {
+
+        @Override
+        public void onServiceConnected(ComponentName className,
+                                       IBinder service) {
+            GoService.GoServiceBinder binder = (GoService.GoServiceBinder) service;
+            goService = binder.getService();
+            Util.log("Bind connection completed!");
+            startServer();
+        }
+
+        @Override
+        public void onServiceDisconnected(ComponentName arg0) {
+            goService = null;
+            Util.log("Bind connection unexpectedly closed!");
+        }
+    };
+
     private class JavascriptBridge {
         private Context context;
 
@@ -119,9 +143,15 @@ protected void onCreate(Bundle savedInstanceState) {
         // For onramp iframe'd widgets like MoonPay.
         CookieManager.getInstance().setAcceptThirdPartyCookies(vw, true);
 
-        // GoModel invokes the Go backend. It is in a ViewModel so it only runs once, not every time
-        // onCreate is called (on a configuration change like orientation change)
+        // GoModel manages the Go backend. It is in a ViewModel so it only runs once, not every time
+        // onCreate is called (on a configuration change like orientation change).
         final GoViewModel goViewModel = ViewModelProviders.of(this).get(GoViewModel.class);
+
+        // The backend is run inside GoService, to avoid (as much as possible) latency errors due to
+        // the scheduling when the app is out of focus.
+        Intent intent = new Intent(this, GoService.class);
+        bindService(intent, connection, Context.BIND_AUTO_CREATE);
+
         goViewModel.setMessageHandlers(
                 new Handler() {
                     @Override
@@ -239,6 +269,11 @@ public void onPermissionRequest(PermissionRequest request) {
         this.updateDevice();
     }
 
+    private void startServer() {
+        final GoViewModel gVM = ViewModelProviders.of(this).get(GoViewModel.class);
+        goService.startServer(getApplicationContext().getFilesDir().getAbsolutePath(), gVM.getGoEnvironment(), gVM.getGoAPI());
+    }
+
     private static String readRawText(InputStream inputStream) throws IOException {
         if (inputStream == null) {
             return null;
@@ -371,10 +406,21 @@ protected void onStop() {
         Util.log("lifecycle: onStop");
     }
 
+    @Override
+    protected void onRestart() {
+        // This is here so that if the GoService gets killed while the app is in background it
+        // will be started again.
+        if (goService == null) {
+            Intent intent = new Intent(this, GoService.class);
+            bindService(intent, connection, Context.BIND_AUTO_CREATE);
+        }
+        super.onRestart();
+    }
+
     @Override
     protected void onDestroy() {
-        super.onDestroy();
         Util.log("lifecycle: onDestroy");
+        super.onDestroy();
     }
 
     @Override