storaged: use AIDL to generate storaged binder calls.

Split binder calls into two separate services.

"storaged" service will be used by external clients, e.g. vold.
- Added stub onUserStarted/onUserStopped to prepare for moving
storaged.proto into ce area.

"storaged_pri" private service will be used by storaged cmdline,
e.g. adb shell storaged -u
- Added parcelable UidInfo for private service.
- Change format of perf history to one vector with first 3 elements
showing size of recent/daily/weekly perf history.

Test: adb shell storaged -u -p
Bug: 63740245
Change-Id: Ib0367282a95b6cb0a38f064f0456e849ecccc210
diff --git a/storaged/main.cpp b/storaged/main.cpp
index adc550a..0bc36e5 100644
--- a/storaged/main.cpp
+++ b/storaged/main.cpp
@@ -43,22 +43,23 @@
 #include <storaged_utils.h>
 
 using namespace std;
+using namespace android;
 
-sp<storaged_t> storaged;
+sp<storaged_t> storaged_sp;
 
 // Function of storaged's main thread
 void* storaged_main(void* /* unused */) {
-    storaged = new storaged_t();
+    storaged_sp = new storaged_t();
 
-    storaged->load_proto();
-    storaged->init_battery_service();
-    storaged->report_storage_info();
+    storaged_sp->load_proto();
+    storaged_sp->init_battery_service();
+    storaged_sp->report_storage_info();
 
     LOG_TO(SYSTEM, INFO) << "storaged: Start";
 
     for (;;) {
-        storaged->event_checked();
-        storaged->pause();
+        storaged_sp->event_checked();
+        storaged_sp->pause();
     }
     return NULL;
 }
@@ -82,39 +83,33 @@
     for (;;) {
         int opt_idx = 0;
         static struct option long_options[] = {
-            {"start",       no_argument,        0, 's'},
-            {"kill",        no_argument,        0, 'k'},
-            {"uid",         no_argument,        0, 'u'},
-            {"task",        no_argument,        0, 't'},
-            {"perf",        no_argument,        0, 'p'},
-            {"help",        no_argument,        0, 'h'}
+            {"perf",        no_argument,    nullptr, 'p'},
+            {"start",       no_argument,    nullptr, 's'},
+            {"task",        no_argument,    nullptr, 't'},
+            {"uid",         no_argument,    nullptr, 'u'},
+            {nullptr,       0,              nullptr,  0}
         };
-        opt = getopt_long(argc, argv, ":skhutp", long_options, &opt_idx);
+        opt = getopt_long(argc, argv, ":pstu", long_options, &opt_idx);
         if (opt == -1) {
             break;
         }
 
         switch (opt) {
+        case 'p':
+            flag_dump_perf = true;
+            break;
         case 's':
             flag_main_service = true;
             break;
-        case 'u':
-            flag_dump_uid = true;
-            break;
         case 't':
             flag_dump_task = true;
             break;
-        case 'p':
-            flag_dump_perf = true;
+        case 'u':
+            flag_dump_uid = true;
             break;
-        case 'h':
+        default:
             help_message();
             return 0;
-        case '?':
-        default:
-            fprintf(stderr, "no supported option\n");
-            help_message();
-            return -1;
         }
     }
 
@@ -137,7 +132,12 @@
             return -1;
         }
 
-        defaultServiceManager()->addService(String16("storaged"), new Storaged());
+        if (StoragedService::start() != android::OK ||
+            StoragedPrivateService::start() != android::OK) {
+            PLOG_TO(SYSTEM, ERROR) << "Failed to start storaged service";
+            return -1;
+        }
+
         android::ProcessState::self()->startThreadPool();
         IPCThreadState::self()->joinThreadPool();
         pthread_join(storaged_main_thread, NULL);
@@ -145,31 +145,33 @@
         return 0;
     }
 
-    sp<IStoraged> storaged_service = get_storaged_service();
+    sp<IStoragedPrivate> storaged_service = get_storaged_pri_service();
     if (storaged_service == NULL) {
         fprintf(stderr, "Cannot find storaged service.\nMaybe run storaged --start first?\n");
         return -1;
     }
 
     if (flag_dump_uid || flag_dump_task) {
-        vector<struct uid_info> res = storaged_service->dump_uids(NULL);
-        if (res.size() == 0) {
-            fprintf(stderr, "UID I/O is not readable in this version of kernel.\n");
+        vector<UidInfo> uid_io;
+        binder::Status status = storaged_service->dumpUids(&uid_io);
+        if (!status.isOk() || uid_io.size() == 0) {
+            fprintf(stderr, "UID I/O info is not available.\n");
             return 0;
         }
 
-        sort_running_uids_info(res);
-        log_console_running_uids_info(res, flag_dump_task);
+        sort_running_uids_info(uid_io);
+        log_console_running_uids_info(uid_io, flag_dump_task);
     }
 
     if (flag_dump_perf) {
-        vector<vector<uint32_t>> res = storaged_service->dump_perf_history(NULL);
-        if (res.size() == 0) {
-            fprintf(stderr, "I/O perf history is empty.\n");
+        vector<int> perf_history;
+        binder::Status status = storaged_service->dumpPerfHistory(&perf_history);
+        if (!status.isOk() || perf_history.size() == 0) {
+            fprintf(stderr, "I/O perf history is not available.\n");
             return 0;
         }
 
-        log_console_perf_history(res);
+        log_console_perf_history(perf_history);
     }
 
     return 0;