From 84334cf7db68732eb92caf6cf9682c7ef2c426f6 Mon Sep 17 00:00:00 2001
From: Romain Vimont <rom@rom1v.com>
Date: Thu, 18 Nov 2021 21:33:25 +0100
Subject: [PATCH] Use sc_intr in file_handler

Replace manual interruption handling by the recent sc_intr mechanism.
---
 app/src/file_handler.c | 34 +++++++++++++++++-----------------
 app/src/file_handler.h |  4 +++-
 2 files changed, 20 insertions(+), 18 deletions(-)

diff --git a/app/src/file_handler.c b/app/src/file_handler.c
index 73b6a004..d84ae4cb 100644
--- a/app/src/file_handler.c
+++ b/app/src/file_handler.c
@@ -5,6 +5,7 @@
 
 #include "adb.h"
 #include "util/log.h"
+#include "util/process_intr.h"
 
 #define DEFAULT_PUSH_TARGET "/sdcard/Download/"
 
@@ -31,9 +32,17 @@ file_handler_init(struct file_handler *file_handler, const char *serial,
         return false;
     }
 
+    ok = sc_intr_init(&file_handler->intr);
+    if (!ok) {
+        LOGE("Could not create intr");
+        sc_cond_destroy(&file_handler->event_cond);
+        sc_mutex_destroy(&file_handler->mutex);
+    }
+
     file_handler->serial = strdup(serial);
     if (!file_handler->serial) {
         LOGE("Could not strdup serial");
+        sc_intr_destroy(&file_handler->intr);
         sc_cond_destroy(&file_handler->event_cond);
         sc_mutex_destroy(&file_handler->mutex);
         return false;
@@ -43,7 +52,6 @@ file_handler_init(struct file_handler *file_handler, const char *serial,
     file_handler->initialized = false;
 
     file_handler->stopped = false;
-    file_handler->current_process = SC_PROCESS_NONE;
 
     file_handler->push_target = push_target ? push_target : DEFAULT_PUSH_TARGET;
 
@@ -54,6 +62,7 @@ void
 file_handler_destroy(struct file_handler *file_handler) {
     sc_cond_destroy(&file_handler->event_cond);
     sc_mutex_destroy(&file_handler->mutex);
+    sc_intr_destroy(&file_handler->intr);
     free(file_handler->serial);
 
     struct file_handler_request req;
@@ -93,6 +102,7 @@ file_handler_request(struct file_handler *file_handler,
 static int
 run_file_handler(void *data) {
     struct file_handler *file_handler = data;
+    struct sc_intr *intr = &file_handler->intr;
 
     const char *serial = file_handler->serial;
     assert(serial);
@@ -102,7 +112,6 @@ run_file_handler(void *data) {
 
     for (;;) {
         sc_mutex_lock(&file_handler->mutex);
-        file_handler->current_process = SC_PROCESS_NONE;
         while (!file_handler->stopped && cbuf_is_empty(&file_handler->queue)) {
             sc_cond_wait(&file_handler->event_cond, &file_handler->mutex);
         }
@@ -115,6 +124,7 @@ run_file_handler(void *data) {
         bool non_empty = cbuf_take(&file_handler->queue, &req);
         assert(non_empty);
         (void) non_empty;
+        sc_mutex_unlock(&file_handler->mutex);
 
         sc_pid pid;
         if (req.action == ACTION_INSTALL_APK) {
@@ -124,30 +134,24 @@ run_file_handler(void *data) {
             LOGI("Pushing %s...", req.file);
             pid = adb_push(serial, req.file, push_target);
         }
-        file_handler->current_process = pid;
-        sc_mutex_unlock(&file_handler->mutex);
 
         if (req.action == ACTION_INSTALL_APK) {
-            if (sc_process_check_success(pid, "adb install", false)) {
+            if (sc_process_check_success_intr(intr, pid, "adb install",
+                                              false)) {
                 LOGI("%s successfully installed", req.file);
             } else {
                 LOGE("Failed to install %s", req.file);
             }
         } else {
-            if (sc_process_check_success(pid, "adb push", false)) {
+            if (sc_process_check_success_intr(intr, pid, "adb push", false)) {
                 LOGI("%s successfully pushed to %s", req.file, push_target);
             } else {
                 LOGE("Failed to push %s to %s", req.file, push_target);
             }
         }
 
-        sc_mutex_lock(&file_handler->mutex);
         // Close the process (it is necessarily already terminated)
-        // Execute this call with mutex locked to avoid race conditions with
-        // file_handler_stop()
-        sc_process_close(file_handler->current_process);
-        file_handler->current_process = SC_PROCESS_NONE;
-        sc_mutex_unlock(&file_handler->mutex);
+        sc_process_close(pid);
 
         file_handler_request_destroy(&req);
     }
@@ -173,11 +177,7 @@ file_handler_stop(struct file_handler *file_handler) {
     sc_mutex_lock(&file_handler->mutex);
     file_handler->stopped = true;
     sc_cond_signal(&file_handler->event_cond);
-    if (file_handler->current_process != SC_PROCESS_NONE) {
-        if (!sc_process_terminate(file_handler->current_process)) {
-            LOGW("Could not terminate push/install process");
-        }
-    }
+    sc_intr_interrupt(&file_handler->intr);
     sc_mutex_unlock(&file_handler->mutex);
 }
 
diff --git a/app/src/file_handler.h b/app/src/file_handler.h
index e2067533..4c0313cc 100644
--- a/app/src/file_handler.h
+++ b/app/src/file_handler.h
@@ -8,6 +8,7 @@
 #include "adb.h"
 #include "util/cbuf.h"
 #include "util/thread.h"
+#include "util/intr.h"
 
 typedef enum {
     ACTION_INSTALL_APK,
@@ -29,8 +30,9 @@ struct file_handler {
     sc_cond event_cond;
     bool stopped;
     bool initialized;
-    sc_pid current_process;
     struct file_handler_request_queue queue;
+
+    struct sc_intr intr;
 };
 
 bool