migration: Clean up abstractions.

Change-Id: I97e6300b1f41693596124dd437468a1390445121

5 files changed, 195 insertions, 57 deletions

diff --git a/host/migration/src/AdbCommand.java b/host/migration/src/AdbCommand.java
new file mode 100644
index 0000000..54cdb7b
--- /dev/null
+++ b/host/migration/src/AdbCommand.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2015 The CyanogenMod Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Created by adnan on 11/29/15.
+ */
+public class AdbCommand extends Command {
+    private static final int MAX_RETRIES = 20;
+    private static final String[] ADB_REBOOT_BOOTLOADER = new String[] {
+            "adb", "reboot", "bootloader"
+    };
+    private static final String[] ADB_CHECK_BOOT_COMPLETE = new String[] {
+            "adb", "shell", "getprop", "sys.boot_completed"
+    };
+
+    private String[] baseCommand;
+
+    public AdbCommand(int command) {
+        switch (command) {
+            case Types.REBOOT_BOOTLOADER:
+                baseCommand = ADB_REBOOT_BOOTLOADER;
+                break;
+            case Types.CHECK_BOOT_COMPLETE:
+                baseCommand = ADB_CHECK_BOOT_COMPLETE;
+                break;
+            default:
+                throw new UnsupportedOperationException("Unsupported operation " + command);
+        }
+    }
+
+    @Override
+    public void run() {
+        List<String> commandList = new ArrayList<String>(
+                baseCommand.length + 1);
+        commandList.addAll(Arrays.asList(baseCommand));
+        String[] commands = commandList.toArray(new String[commandList.size()]);
+
+        if (MigrationTest.DEBUG) {
+            System.out.println("Using commands: " + Arrays.toString(commands));
+        }
+        try {
+            Process process = Runtime.getRuntime().exec(commands);
+            final InputStream err = process.getErrorStream();
+            // Send error output to stderr.
+            Thread errThread = new Thread() {
+                @Override
+                public void run() {
+                    copy(err, System.err);
+                }
+            };
+            errThread.setDaemon(true);
+            errThread.start();
+
+            BufferedReader in = new BufferedReader(
+                    new InputStreamReader(process.getInputStream()));
+            String rx = in.readLine();
+            if (!baseCommand.equals(ADB_CHECK_BOOT_COMPLETE)) {
+                if (rx != null) {
+                    if (MigrationTest.DEBUG) {
+                        System.out.println("Received response " + rx);
+                    }
+                }
+
+                try {
+                    Thread.sleep(10000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+
+                in.close();
+                err.close();
+                process.destroy();
+            } else {
+                for (int i = 1; i < MAX_RETRIES; i++) {
+                    process = Runtime.getRuntime().exec(commands);
+                    in = new BufferedReader(new InputStreamReader(process.getInputStream()));
+                    if ((rx = in.readLine()) != null) {
+                        if (rx.equals("1")) {
+                            in.close();
+                            process.destroy();
+                            try {
+                                System.out.println("Device up detected...");
+                                Thread.sleep(10000);
+                            } catch (InterruptedException e) {
+                                e.printStackTrace();
+                            }
+                            break;
+                        }
+                    }
+                    try {
+                        System.out.println("Waiting for device to come up...");
+                        Thread.sleep(10000);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                    in.close();
+                    process.destroy();
+                }
+            }
+        } catch (IOException e) {
+            System.err.println("Error ");
+            e.printStackTrace();
+        }
+    }
+
+    public final class Types {
+        public static final int REBOOT_BOOTLOADER = 0;
+        public static final int CHECK_BOOT_COMPLETE = 1;
+    }
+}
diff --git a/host/migration/src/DebuggingCommands.java b/host/migration/src/DebuggingCommands.java
new file mode 100644
index 0000000..a97fca2
--- /dev/null
+++ b/host/migration/src/DebuggingCommands.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2015 The CyanogenMod Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.util.ArrayList;
+
+/**
+ * Created by adnan on 11/29/15.
+ */
+public class DebuggingCommands implements CommandExecutor {
+    private ArrayList<Command> commandHistory = new ArrayList<Command>();
+
+    @Override
+    public void execute() {
+        for (Command commandWithTimeout : commandHistory) {
+            commandWithTimeout.run();
+        }
+    }
+
+    private void addCommand(Command commandWithTimeout) {
+        commandHistory.add(commandWithTimeout);
+    }
+
+    public void addFastboot(int command, String[] arguments) {
+        FastbootCommand fastbootCommand = new FastbootCommand(command, arguments);
+        addCommand(fastbootCommand);
+    }
+
+    public void addAdb(int command) {
+        AdbCommand adbCommand = new AdbCommand(command);
+        addCommand(adbCommand);
+    }
+}
diff --git a/host/migration/src/FastbootCommand.java b/host/migration/src/FastbootCommand.java
index 1132315..6516525 100644
--- a/host/migration/src/FastbootCommand.java
+++ b/host/migration/src/FastbootCommand.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (C) 2015 The CyanogenMod Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
@@ -10,13 +26,6 @@ import java.util.List;
  * Created by adnan on 11/17/15.
  */
 public class FastbootCommand extends Command {
-    private static final int MAX_RETRIES = 20;
-    private static final String[] ADB_REBOOT_BOOTLOADER = new String[] {
-            "adb", "reboot", "bootloader"
-    };
-    private static final String[] ADB_CHECK_BOOT_COMPLETE = new String[] {
-            "adb", "shell", "getprop", "sys.boot_completed"
-    };
     private static final String FASTBOOT_COMMAND = "fastboot";
     private static final String REBOOT = "reboot";
     private static final String DEVICES = "devices";
@@ -29,9 +38,6 @@ public class FastbootCommand extends Command {
 
     public FastbootCommand(int command, String[] args) {
         switch (command) {
-            case Types.ADB_REBOOT_BOOTLOADER:
-                baseCommand = ADB_REBOOT_BOOTLOADER;
-                break;
             case Types.FASTBOOT_FLASH:
                 baseCommand = new String[] { FASTBOOT_COMMAND };
                 baseArg = FLASH;
@@ -102,45 +108,6 @@ public class FastbootCommand extends Command {
             in.close();
             err.close();
             //Gross
-            if (baseArg != null && baseArg.equals(REBOOT)) {
-                List<String> secondCommandList = new ArrayList<String>(
-                        ADB_CHECK_BOOT_COMPLETE.length + 1);
-                secondCommandList.addAll(Arrays.asList(ADB_CHECK_BOOT_COMPLETE));
-                String[] secondCommands = secondCommandList.toArray(
-                        new String[secondCommandList.size()]);
-                if (MigrationTest.DEBUG) {
-                    System.out.println("Using commands: " + Arrays.toString(secondCommands));
-                }
-                Process process2;
-                BufferedReader in2;
-                String line2;
-                for (int i = 1; i < MAX_RETRIES; i++) {
-                    process2 = Runtime.getRuntime().exec(secondCommands);
-                    in2 = new BufferedReader(
-                            new InputStreamReader(process2.getInputStream()));
-                    if ((line2 = in2.readLine()) != null) {
-                        if (line2.equals("1")) {
-                            in2.close();
-                            process2.destroy();
-                            try {
-                                System.out.println("Device up detected...");
-                                Thread.sleep(10000);
-                            } catch (InterruptedException e) {
-                                e.printStackTrace();
-                            }
-                            break;
-                        }
-                    }
-                    try {
-                        System.out.println("Waiting for device to come up...");
-                        Thread.sleep(10000);
-                    } catch (InterruptedException e) {
-                        e.printStackTrace();
-                    }
-                    in2.close();
-                    process2.destroy();
-                }
-            }
             process.destroy();
         } catch (IOException e) {
             System.err.println("Error ");
@@ -149,7 +116,6 @@ public class FastbootCommand extends Command {
     }
 
     public final class Types {
-        public static final int ADB_REBOOT_BOOTLOADER = -1;
         public static final int FASTBOOT_FLASH = 0;
         public static final int FASTBOOT_DEVICES = 1;
         public static final int FASTBOOT_REBOOT = 2;
diff --git a/host/migration/src/MigrationTest.java b/host/migration/src/MigrationTest.java
index 0949d09..3247593 100644
--- a/host/migration/src/MigrationTest.java
+++ b/host/migration/src/MigrationTest.java
@@ -90,14 +90,15 @@ class MigrationTest {
         legacyToCMSettings.execute();
 
         //Force update
-        SettingImageCommands updateRom = new SettingImageCommands(null);
-        updateRom.addFastboot(FastbootCommand.Types.ADB_REBOOT_BOOTLOADER, null);
+        DebuggingCommands updateRom = new DebuggingCommands();
+        updateRom.addAdb(AdbCommand.Types.REBOOT_BOOTLOADER);
         updateRom.addFastboot(FastbootCommand.Types.FASTBOOT_DEVICES, null);
         updateRom.addFastboot(FastbootCommand.Types.FASTBOOT_FLASH,
                 new String[]{"boot", bootImage});
         updateRom.addFastboot(FastbootCommand.Types.FASTBOOT_FLASH,
                 new String[]{"system", systemImage});
         updateRom.addFastboot(FastbootCommand.Types.FASTBOOT_REBOOT, null);
+        updateRom.addAdb(AdbCommand.Types.CHECK_BOOT_COMPLETE);
         updateRom.execute();
 
         //Requery
diff --git a/host/migration/src/SettingImageCommands.java b/host/migration/src/SettingImageCommands.java
index 0598e83..68cae2e 100644
--- a/host/migration/src/SettingImageCommands.java
+++ b/host/migration/src/SettingImageCommands.java
@@ -53,9 +53,4 @@ public class SettingImageCommands implements CommandExecutor {
         ReadCommand readCommand = new ReadCommand(fileName, uri, settings);
         addCommand(readCommand);
     }
-
-    public void addFastboot(int command, String[] arguments) {
-        FastbootCommand fastbootCommand = new FastbootCommand(command, arguments);
-        addCommand(fastbootCommand);
-    }
 }