WIP: workmanager and bound services support

pythonforandroid/bootstraps/common/build/build.py

@@ -462,14 +462,22 @@ def make_package(args):
         foreground = 'foreground' in options
         sticky = 'sticky' in options
 
+        bound = 'bound' in options
+
         service_names.append(name)
-        service_target_path =\
-            'src/main/java/{}/Service{}.java'.format(
-                args.package.replace(".", "/"),
-                name.capitalize()
-            )
+
+        if not bound:
+            service_template_path = 'Service.tmpl.java'
+        else:
+            service_template_path = 'BoundService.tmpl.java'
+
+        service_target_path = 'src/main/java/{}/Service{}.java'.format(
+            args.package.replace(".", "/"),
+            name.capitalize()
+        )
+
         render(
-            'Service.tmpl.java',
+            service_template_path,
             service_target_path,
             name=name,
             entrypoint=entrypoint,
@@ -480,6 +488,24 @@ def make_package(args):
             base_service_class=base_service_class,
         )
 
+    for spec in args.workers:
+        spec = spec.split(':')
+        name = spec[0]
+        entrypoint = spec[1]
+
+        worker_target_path = \
+            'src/main/java/{}/{}Worker.java'.format(
+                args.package.replace(".", "/"),
+                name.capitalize()
+            )
+        render(
+            'Worker.tmpl.java',
+            worker_target_path,
+            name=name,
+            entrypoint=entrypoint,
+            args=args
+        )
+
     # Find the SDK directory and target API
     with open('project.properties', 'r') as fileh:
         target = fileh.read().strip()
@@ -695,6 +721,9 @@ def parse_args_and_make_package(args=None):
     ap.add_argument('--service', dest='services', action='append', default=[],
                     help='Declare a new service entrypoint: '
                          'NAME:PATH_TO_PY[:foreground]')
+    ap.add_argument('--worker', dest='workers', action='append', default=[],
+                    help='Declare a new worker entrypoint: '
+                         'NAME:PATH_TO_PY')
     ap.add_argument('--native-service', dest='native_services', action='append', default=[],
                     help='Declare a new native service: '
                          'package.name.service')

pythonforandroid/bootstraps/common/build/jni/application/src/start.c

@@ -71,7 +71,7 @@ int file_exists(const char *filename) {
 }
 
 /* int main(int argc, char **argv) { */
-int main(int argc, char *argv[]) {
+int main_(int argc, char *argv[], int call_exit) {
 
   char *env_argument = NULL;
   char *env_entrypoint = NULL;
@@ -333,12 +333,14 @@ int main(int argc, char *argv[]) {
 
      https://github.com/kivy/kivy/pull/6107#issue-246120816
    */
-  char terminatecmd[256];
-  snprintf(
-    terminatecmd, sizeof(terminatecmd),
-    "import sys; sys.exit(%d)\n", ret
-  );
-  PyRun_SimpleString(terminatecmd);
+  if (call_exit) {
+    char terminatecmd[256];
+    snprintf(
+      terminatecmd, sizeof(terminatecmd),
+      "import sys; sys.exit(%d)\n", ret
+    );
+    PyRun_SimpleString(terminatecmd);
+  }
 
   /* This should never actually be reached, but we'll leave the clean-up
    * here just to be safe.
@@ -356,7 +358,91 @@ int main(int argc, char *argv[]) {
   return ret;
 }
 
-JNIEXPORT void JNICALL Java_org_kivy_android_PythonService_nativeStart(
+JNIEXPORT int JNICALL Java_org_kivy_android_PythonService_nativeStart(
+    JNIEnv *env,
+    jobject thiz,
+    jstring j_android_private,
+    jstring j_android_argument,
+    jstring j_service_entrypoint,
+    jstring j_python_name,
+    jstring j_python_home,
+    jstring j_python_path,
+    jstring j_arg) {
+  jboolean iscopy;
+  const char *android_private =
+      (*env)->GetStringUTFChars(env, j_android_private, &iscopy);
+  const char *android_argument =
+      (*env)->GetStringUTFChars(env, j_android_argument, &iscopy);
+  const char *service_entrypoint =
+      (*env)->GetStringUTFChars(env, j_service_entrypoint, &iscopy);
+  const char *python_name =
+      (*env)->GetStringUTFChars(env, j_python_name, &iscopy);
+  const char *python_home =
+      (*env)->GetStringUTFChars(env, j_python_home, &iscopy);
+  const char *python_path =
+      (*env)->GetStringUTFChars(env, j_python_path, &iscopy);
+  const char *arg = (*env)->GetStringUTFChars(env, j_arg, &iscopy);
+
+  setenv("ANDROID_PRIVATE", android_private, 1);
+  setenv("ANDROID_ARGUMENT", android_argument, 1);
+  setenv("ANDROID_APP_PATH", android_argument, 1);
+  setenv("ANDROID_ENTRYPOINT", service_entrypoint, 1);
+  setenv("PYTHONOPTIMIZE", "2", 1);
+  setenv("PYTHON_NAME", python_name, 1);
+  setenv("PYTHONHOME", python_home, 1);
+  setenv("PYTHONPATH", python_path, 1);
+  setenv("PYTHON_SERVICE_ARGUMENT", arg, 1);
+  setenv("P4A_BOOTSTRAP", bootstrap_name, 1);
+
+  char *argv[] = {"."};
+  /* ANDROID_ARGUMENT points to service subdir,
+   * so main() will run main.py from this dir
+   */
+  return main_(1, argv, 1);
+}
+
+#if defined(BOOTSTRAP_NAME_SERVICELIBRARY)
+// JNIEXPORT void JNICALL Java_org_kivy_android_PythonWorker_nativeStart(
+//     JNIEnv *env,
+//     jobject thiz,
+//     jstring j_android_private,
+//     jstring j_android_argument,
+//     jstring j_worker_entrypoint,
+//     jstring j_python_name,
+//     jstring j_python_home,
+//     jstring j_python_path) {
+//   jboolean iscopy;
+//   const char *android_private =
+//       (*env)->GetStringUTFChars(env, j_android_private, &iscopy);
+//   const char *android_argument =
+//       (*env)->GetStringUTFChars(env, j_android_argument, &iscopy);
+//   const char *worker_entrypoint =
+//       (*env)->GetStringUTFChars(env, j_worker_entrypoint, &iscopy);
+//   const char *python_name =
+//       (*env)->GetStringUTFChars(env, j_python_name, &iscopy);
+//   const char *python_home =
+//       (*env)->GetStringUTFChars(env, j_python_home, &iscopy);
+//   const char *python_path =
+//       (*env)->GetStringUTFChars(env, j_python_path, &iscopy);
+
+//   setenv("ANDROID_PRIVATE", android_private, 1);
+//   setenv("ANDROID_ARGUMENT", android_argument, 1);
+//   setenv("ANDROID_APP_PATH", android_argument, 1);
+//   setenv("ANDROID_ENTRYPOINT", worker_entrypoint, 1);
+//   setenv("PYTHONOPTIMIZE", "2", 1);
+//   setenv("PYTHON_NAME", python_name, 1);
+//   setenv("PYTHONHOME", python_home, 1);
+//   setenv("PYTHONPATH", python_path, 1);
+//   setenv("P4A_BOOTSTRAP", bootstrap_name, 1);
+
+//   char *argv[] = {"."};
+//   /* ANDROID_ARGUMENT points to service subdir,
+//    * so main() will run main.py from this dir
+//    */
+//   main_(1, argv, 0);
+// }
+
+JNIEXPORT int JNICALL Java_org_kivy_android_PythonWorker_nativeStart(
     JNIEnv *env,
     jobject thiz,
     jstring j_android_private,
@@ -396,9 +482,54 @@ JNIEXPORT void JNICALL Java_org_kivy_android_PythonService_nativeStart(
   /* ANDROID_ARGUMENT points to service subdir,
    * so main() will run main.py from this dir
    */
-  main(1, argv);
+  // main_(1, argv, 1);
+  return main_(1, argv, 0);
 }
 
+JNIEXPORT int JNICALL Java_org_kivy_android_PythonBoundService_nativeStart(
+    JNIEnv *env,
+    jobject thiz,
+    jstring j_android_private,
+    jstring j_android_argument,
+    jstring j_service_entrypoint,
+    jstring j_python_name,
+    jstring j_python_home,
+    jstring j_python_path,
+    jstring j_arg) {
+  jboolean iscopy;
+  const char *android_private =
+      (*env)->GetStringUTFChars(env, j_android_private, &iscopy);
+  const char *android_argument =
+      (*env)->GetStringUTFChars(env, j_android_argument, &iscopy);
+  const char *service_entrypoint =
+      (*env)->GetStringUTFChars(env, j_service_entrypoint, &iscopy);
+  const char *python_name =
+      (*env)->GetStringUTFChars(env, j_python_name, &iscopy);
+  const char *python_home =
+      (*env)->GetStringUTFChars(env, j_python_home, &iscopy);
+  const char *python_path =
+      (*env)->GetStringUTFChars(env, j_python_path, &iscopy);
+  const char *arg = (*env)->GetStringUTFChars(env, j_arg, &iscopy);
+
+  setenv("ANDROID_PRIVATE", android_private, 1);
+  setenv("ANDROID_ARGUMENT", android_argument, 1);
+  setenv("ANDROID_APP_PATH", android_argument, 1);
+  setenv("ANDROID_ENTRYPOINT", service_entrypoint, 1);
+  setenv("PYTHONOPTIMIZE", "2", 1);
+  setenv("PYTHON_NAME", python_name, 1);
+  setenv("PYTHONHOME", python_home, 1);
+  setenv("PYTHONPATH", python_path, 1);
+  setenv("PYTHON_SERVICE_ARGUMENT", arg, 1);
+  setenv("P4A_BOOTSTRAP", bootstrap_name, 1);
+
+  char *argv[] = {"."};
+  /* ANDROID_ARGUMENT points to service subdir,
+   * so main() will run main.py from this dir
+   */
+  return main_(1, argv, 1);
+}
+#endif
+
 #if defined(BOOTSTRAP_NAME_WEBVIEW) || defined(BOOTSTRAP_NAME_SERVICEONLY)
 // Webview and service_only uses some more functions:
 
@@ -419,7 +550,7 @@ void Java_org_kivy_android_PythonActivity_nativeSetenv(
 }
 
 
-void Java_org_kivy_android_PythonActivity_nativeInit(JNIEnv* env, jclass cls, jobject obj)
+int Java_org_kivy_android_PythonActivity_nativeInit(JNIEnv* env, jclass cls, jobject obj)
 {
   /* This nativeInit follows SDL2 */
 
@@ -435,7 +566,7 @@ void Java_org_kivy_android_PythonActivity_nativeInit(JNIEnv* env, jclass cls, jo
   argv[1] = NULL;
   /* status = SDL_main(1, argv); */
 
-  main(1, argv);
+  return main_(1, argv, 1);
 
   /* Do not issue an exit or the whole application will terminate instead of just the SDL thread */
   /* exit(status); */

pythonforandroid/bootstraps/service_library/build/jni/application/src/bootstrap_name.h

@@ -1,5 +1,6 @@
 
 #define BOOTSTRAP_NAME_LIBRARY
+#define BOOTSTRAP_NAME_SERVICELIBRARY
 #define BOOTSTRAP_USES_NO_SDL_HEADERS
 
 const char bootstrap_name[] = "service_library";

pythonforandroid/bootstraps/service_library/build/src/main/java/org/kivy/android/PythonBoundService.java

@@ -0,0 +1,117 @@
+package org.kivy.android;
+
+import android.app.Service;
+import android.content.Context;
+import android.os.Process;
+import android.util.Log;
+
+import java.io.File;
+
+import org.kivy.android.PythonUtil;
+
+
+public abstract class PythonBoundService extends Service implements Runnable {
+    private static final String TAG = "python bound service";
+
+    // Thread for Python code
+    private Thread pythonThread = null;
+
+    // Application root directory
+    private String appRoot;
+
+    // Python environment variables
+    private String androidPrivate;
+    private String androidArgument;
+    private String pythonName;
+    private String pythonHome;
+    private String pythonPath;
+    private String workerEntrypoint;
+
+    // Argument to pass to Python code,
+    private String pythonServiceArgument;
+
+    public void setPythonName(String value) {
+        Log.d(TAG, "setPythonName()");
+
+        pythonName = value;
+    }
+
+    public void setWorkerEntrypoint(String value) {
+        Log.d(TAG, "setWorkerEntrypoint()");
+
+        workerEntrypoint = value;
+    }
+
+    public void startPythonThread() {
+        Log.d(TAG, "startPythonThread()");
+
+        pythonThread = new Thread(this);
+        pythonThread.start();
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+
+        Log.d(TAG, "onCreate()");
+
+        Context context = getApplicationContext();
+        appRoot = PythonUtil.getAppRoot(context);
+
+        androidPrivate = appRoot;
+        androidArgument = appRoot;
+        pythonHome = appRoot;
+        pythonPath = appRoot + ":" + appRoot + "/lib";
+
+        pythonServiceArgument = "";
+
+        File appRootFile = new File(appRoot);
+
+        Log.d(TAG, "unpack Data");
+
+        PythonUtil.unpackData(context, "private", appRootFile, false);
+
+        Log.d(TAG, "data unpacked");
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+
+        Log.d(TAG, "onDestroy()");
+
+        pythonThread = null;
+        Process.killProcess(Process.myPid());
+    }
+
+    @Override
+    public void run() {
+        Log.d(TAG, "run()");
+
+        File appRootFile = new File(appRoot);
+
+        PythonUtil.loadLibraries(
+            appRootFile,
+            new File(getApplicationContext().getApplicationInfo().nativeLibraryDir)
+        );
+
+        Log.d(TAG, "Call native start");
+
+        nativeStart(
+            androidPrivate, androidArgument,
+            workerEntrypoint, pythonName,
+            pythonHome, pythonPath,
+            pythonServiceArgument
+        );
+
+        Log.d(TAG, "Python thread terminating");
+    }
+
+    // Native part
+    public static native void nativeStart(
+        String androidPrivate, String androidArgument,
+        String workerEntrypoint, String pythonName,
+        String pythonHome, String pythonPath,
+        String pythonServiceArgument
+    );
+}