Merge lp:~humpolec-team/humpolec/UbuntuInstaller-ota into lp:humpolec

[Rex Tsai]

Support Ubuntu Touch upgrade.

* Find update_command in /cache/recovery, if update_command comes from /cache, it's upgradeable.
* Added Upgradeable checking script, check if upgrade image available in /cache
* Use INSTALLED_VERSION as DOWNLOADED_VERSION for system upgrade, since we don't know what's the version in /cache.
* New Intent Servcie for checking upgrade.
* make doInstallUbuntu works with images file stored in /cache.
* clean up UpdateComamnd function.
* only using executeSUCommands for shell access.

[Yuan-Chen Cheng (ycheng-twn)]

line 35: why not move BUSYBOX=busybox up and
        cd `${BUSYBOX} dirname $1`

line 104: what's "user's data" did you mean ?
        user data that android create, user data that ubuntu user create or ?

line 335: will it better to name something like IS_UBUNTU_UPGRADABLE
        instead of UPGRADE_UBUNTU

line 425: can you add comment on the logic ? like
        As working dir in /data, blalal
        As working dir in /cache, blalal

line 1140: please also add comment like line 425. (or refer to it)

line 1082, "getApplication()." can be removed.

line 1034: UbuntuInstallService.isUpgradeable
        check command file against /cache works in this case, but it
        does not necessary means upgradable (it might means some
        error on internal status keeping) since normal install
        could have command file in /cache if the apk is installed
        in ROM.

        should we rename this function to something else ?

Maybe we should stop adding new code and try to document the state machine.
Maybe more re-factor then.

review: Needs Fixing

[lp:~humpolec-team/humpolec/UbuntuInstaller-ota]

40. By Rex Tsai on 2013-12-26

use for busybox.

41. By Rex Tsai on 2013-12-26

Removed confusing comment on Ubuntu user data.

42. By Rex Tsai on 2013-12-26

s/UPGRADE_UBUNTU/IS_UBUNTU_UPGRADABLE/

43. By Rex Tsai on 2013-12-26

Comment on updates command checking.

44. By Rex Tsai on 2013-12-26

Add comment on findUpgradeable()

45. By Rex Tsai on 2013-12-26

s/findUpgradeable/findInstallCommand/

[Rex Tsai (chihchun)]

Changes for meet YC's requests.

* 2f4e386 - s/findUpgradeable/findInstallCommand/
* 6b5b8b9 - Add comment on findUpgradeable()
* 64ca88b - Comment on updates command checking.
* 686a879 - s/UPGRADE_UBUNTU/IS_UBUNTU_UPGRADABLE/
* 2d031a6 - Removed confusing comment on Ubuntu user data.
* 33e8eea - use ${BUSYBOX} for busybox.

[Yuan-Chen Cheng (ycheng-twn)]

+1

I still don't like the function name isUpgradeable, but it's too personal and the code is good enough for now.

review: Approve

[Rex Tsai (chihchun)]

I think we can integrate both checkifReadyToInstall and isUpgradeable into one function.
But need to clean up how we manage Shared Preferences data.

I will do merge first.

=== modified file 'AndroidManifest.xml'
--- AndroidManifest.xml	2013-12-21 16:59:18 +0000
+++ AndroidManifest.xml	2013-12-26 07:18:46 +0000
@@ -62,6 +62,7 @@
                 <action android:name="com.canonical.ubuntuinstaller.UbuntuInstallService.GET_SERVICE_STATE" />
                 <action android:name="com.canonical.ubuntuinstaller.UbuntuInstallService.GET_PROGRESS_STATUS" />
                 <action android:name="com.canonical.ubuntuinstaller.UbuntuInstallService.REBOOT_UBUNTU" />
+                <action android:name="com.canonical.ubuntuinstaller.UbuntuInstallService.IS_UBUNTU_UPGRADABLE" />
             </intent-filter>
         </service>
     </application>

=== modified file 'assets/system-image-upgrader'
--- assets/system-image-upgrader	2013-12-20 03:39:53 +0000
+++ assets/system-image-upgrader	2013-12-26 07:18:46 +0000
@@ -1,25 +1,30 @@
-#!/sbin/sh
+#!/system/bin/sh
+# Copyright (C) 2013 Canonical Ltd.
 
-export PATH=$PATH:${PWD}
-UPDATE_FOLDER=${PWD}
-PRIVATE_DIR=$2
-BUSYBOX=busybox
-TAR=u_tar
-set -e
+# $0 [ubuntu command file] [app/private folder]
 
 if [ ! -e "$1" ]; then
     echo "Command file doesn't exist: $1"
     exit 1
 fi
-mv $1 $1.applying
+
 COMMAND_FILE=$1.applying
-
 REMOVE_LIST="$COMMAND_FILE"
-
+UPDATE_FOLDER=${PWD}
+PRIVATE_DIR=$2
+BUSYBOX=busybox
+TAR=u_tar
 TMP=/cache/tmp
+export PATH=${PWD}:${PRIVATE_DIR}:$PATH
 
+set -e
 echo "Starting image upgrader: $(date)"
 
+# switch to the update command folder, which has the images
+cd `$BUSYBOX dirname $1`
+mv $1 $1.applying
+
+
 # Functions
 verify_signature() {
     return 0
@@ -143,7 +148,7 @@
 
 # Process the command file
 FULL_IMAGE=0
-echo "Processing the command file"
+echo "Processing the command file $COMMAND_FILE"
 while read line
 do
     set -- $line

=== added file 'assets/upgrade-checker'
--- assets/upgrade-checker	1970-01-01 00:00:00 +0000
+++ assets/upgrade-checker	2013-12-26 07:18:46 +0000
@@ -0,0 +1,16 @@
+#!/system/bin/sh
+# Copyright (C) 2013 Canonical Ltd.
+#
+# Check if ubuntu_command exist
+# print the path and exit 0 if found.
+
+FILES=$@
+
+for file in $FILES ; do 
+    if [[ -f $file ]] ; then
+        echo $file
+        exit 1
+    fi
+done
+
+exit 0

=== modified file 'src/com/canonical/ubuntu/installer/InstallActivity.java'
--- src/com/canonical/ubuntu/installer/InstallActivity.java	2013-12-25 06:09:49 +0000
+++ src/com/canonical/ubuntu/installer/InstallActivity.java	2013-12-26 07:18:46 +0000
@@ -114,14 +114,14 @@
         }
         mObserversRegistered = false;
     }
-    
+
     @Override
     public boolean onCreateOptionsMenu(Menu menu) {
         // Inflate the menu; this adds items to the action bar if it is present.
         getMenuInflater().inflate(R.menu.installer_menu, menu);
         return true;
     }
-    
+
     @Override
     public boolean onOptionsItemSelected(MenuItem item) {
         switch (item.getItemId()) {
@@ -183,11 +183,13 @@
     }
 
     private void checkIfUbuntuIsInstalled() {
-        // check is there is Ubuntu installed
-        if (UbuntuInstallService.isUbuntuInstalled(this.getApplicationContext())) {
-            // go to launch screen, and kill this activity.
-            LaunchActivity.startFrom(this);
-            finish();
+        // check is there is Ubuntu installed or is upgradeable
+        if (UbuntuInstallService.isUbuntuInstalled(getApplicationContext())) {
+            if(!UbuntuInstallService.isUpgradeable(getApplicationContext())) {
+                Log.d(TAG, "go to launch screen, and kill Install activity");
+                LaunchActivity.startFrom(this);
+                finish();
+            }
         }
     }
 
@@ -262,7 +264,7 @@
         // reset progress bar
         mProgressBar.setProgress(0);
     }
-    
+
     TextPickerDialog.OnChannelPicktListener mInstallDialogListener 
                                 = new TextPickerDialog.OnChannelPicktListener() {
         public void onChannelPicked(Context context, String channel, boolean bootstrap, boolean latest) {
@@ -292,38 +294,38 @@
     
     private void downloadVersion(final Context context, final String channel, final boolean bootstrap) {
         final ProgressDialog progress = ProgressDialog.show(this, 
-        "Fetching versions", 
-        "Checking list of availanble versions for choosen channel", true);
+                "Fetching versions", 
+                "Checking list of availanble versions for choosen channel", true);
         new Thread(new Runnable() {
             @Override
             public void run() {
                 String jsonStr = Utils.httpDownload(UbuntuInstallService.BASE_URL 
-                + mAvailableChannels.get(channel));
+                        + mAvailableChannels.get(channel));
                 // TODO: handle malformed JSON
                 final List<Image> releases = JsonChannelParser.getAvailableReleases(jsonStr, ReleaseType.FULL);
-                
+
                 runOnUiThread(new Runnable() {
-            @Override
+                    @Override
                     public void run() {
                         progress.dismiss();
                         // if there are available releases, show number picker
                         if (releases.size() != 0 && releases.get(0).files.length != 0) {
-                        int[] values = new int[releases.size()];
-                        for (int i = 0 ; i < values.length ; ++i) {
-                        values[i] = releases.get(i).version;
-                        }
-                        new NumberPickerDialog(context, 
-                        R.string.version_picker_dialog_title,
-                        R.string.action_install,
-                        R.string.cancel,
-                        values,
-                        0, 
-                        new NumberPickerDialog.OnNumberPicktListener() {
-        @Override
-        public void onNumberSelected(Context context, int value) {
-        startDownload(channel, bootstrap, value);
-        }
-        }).show();;
+                            int[] values = new int[releases.size()];
+                            for (int i = 0 ; i < values.length ; ++i) {
+                                values[i] = releases.get(i).version;
+                            }
+                            new NumberPickerDialog(context, 
+                                    R.string.version_picker_dialog_title,
+                                    R.string.action_install,
+                                    R.string.cancel,
+                                    values,
+                                    0, 
+                                    new NumberPickerDialog.OnNumberPicktListener() {
+                                @Override
+                                public void onNumberSelected(Context context, int value) {
+                                    startDownload(channel, bootstrap, value);
+                                }
+                            }).show();;
                         }                        
                     }
                 });
@@ -359,7 +361,7 @@
                             mProgressText.setText("");
                         }
                     }
-                        break;
+                    break;
                     case FETCHING_CHANNELS:
                         mInstallButton.setText(Html.fromHtml(getResources().getString(R.string.install_button_label_fetching)));
                         mInstallButton.setEnabled(false);
@@ -406,7 +408,7 @@
                 int progress = intent.getIntExtra(UbuntuInstallService.PROGRESS_EXTRA_INT, -1);
                 if (progress != -1) {
                     mProgressBar.setProgress(progress);
-                    Log.v(TAG, "Progress:" + progress);
+                    Log.d(TAG, "Progress: " + progress);
                 }
                 if (p != null  && !p.equals("")) {
                     // update terminal with progress text
@@ -440,7 +442,7 @@
                     }
                     updateUiElements();
                 }
-                
+
             // Handle download result
             } else if(action.equals(UbuntuInstallService.DOWNLOAD_RESULT)) {
                 int r = intent.getIntExtra(UbuntuInstallService.DOWNLOAD_RESULT_EXTRA_INT, -1);

=== modified file 'src/com/canonical/ubuntu/installer/LaunchActivity.java'
--- src/com/canonical/ubuntu/installer/LaunchActivity.java	2013-12-19 09:36:28 +0000
+++ src/com/canonical/ubuntu/installer/LaunchActivity.java	2013-12-26 07:18:46 +0000
@@ -8,6 +8,7 @@
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.os.Bundle;
+import android.util.Log;
 import android.view.Menu;
 import android.view.MenuItem;
 import android.view.View;
@@ -16,7 +17,6 @@
 
 import com.canonical.ubuntu.widget.UbuntuButton;
 
-
 public class LaunchActivity extends Activity {
     private static final String TAG = "UbuntuLaunchActivity";
     private UbuntuButton mRebootButton;
@@ -28,7 +28,7 @@
     private TextView mTextDescriptionLabel;
     private TextView mTextDescription;
     private VersionInfo mUbuntuVersion;
-    
+
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
@@ -48,8 +48,11 @@
         mTextTitle.setText(R.string.launch_title);
         mRebootButton.setText(R.string.reboot_button_label);
         fillInstalledVersionInfo();
+
+        // check the upgradeable image.
+        startService(new Intent(UbuntuInstallService.IS_UBUNTU_UPGRADABLE));
     }
-        
+
     @Override
     public void onResume() {
         super.onResume();
@@ -62,7 +65,7 @@
         filter.addAction(UbuntuInstallService.VERSION_UPDATE);
         registerReceiver(mServiceObserver, filter);
     }
-    
+
     @Override
     public void onPause() {
         super.onPause();
@@ -113,7 +116,19 @@
         }
         return super.onOptionsItemSelected(item);
     }
-    
+
+    /**
+     * Create a dialog for confirmation.
+     * @param title
+     * @param positiveButton
+     * @param negativeButton
+     * @param action
+     * @param toastText
+     * @param choiceItemsArray
+     * @param defaultChoiceValues
+     * @param choiceClickListener
+     * @return AlertDialog
+     */
     private AlertDialog createConfirmationDialog(final int title, 
                                          final int positiveButton, 
                                          final int negativeButton, 
@@ -151,7 +166,10 @@
         mTextVersionLabel.setText(R.string.label_version);
         mTextDescriptionLabel.setText(R.string.label_description);
     }
-    
+
+    /**
+     * Get installed version to check Ubuntu is installed
+     */
     private void ensureUbuntuIsInstalled() {
         VersionInfo v = UbuntuInstallService.getInstalledVersion(this.getApplicationContext());
         if (v == null) {
@@ -177,6 +195,11 @@
             String action = intent.getAction();
             if (action.equals(UbuntuInstallService.VERSION_UPDATE)) {
                 ensureUbuntuIsInstalled();
+                if(UbuntuInstallService.isUpgradeable(getApplicationContext())) {
+                    Log.d(TAG, "Found upgradeable file, kill LaunchActivity");
+                    InstallActivity.startFrom(context);
+                    finish();
+                }
             }
         }
     };

=== modified file 'src/com/canonical/ubuntu/installer/UbuntuInstallService.java'
--- src/com/canonical/ubuntu/installer/UbuntuInstallService.java	2013-12-24 09:14:25 +0000
+++ src/com/canonical/ubuntu/installer/UbuntuInstallService.java	2013-12-26 07:18:46 +0000
@@ -9,6 +9,7 @@
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLConnection;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -90,6 +91,7 @@
     public static final String INSTALL_UBUNTU = "com.canonical.ubuntuinstaller.UbuntuInstallService.INSTALL_UBUNTU";
     public static final String CANCEL_INSTALL = "com.canonical.ubuntuinstaller.UbuntuInstallService.CANCEL_INSTALL";
     public static final String UNINSTALL_UBUNTU = "com.canonical.ubuntuinstaller.UbuntuInstallService.UINSTALL_UBUNTU";
+    public static final String IS_UBUNTU_UPGRADABLE = "com.canonical.ubuntuinstaller.UbuntuInstallService.IS_UBUNTU_UPGRADABLE";
     public static final String UNINSTALL_UBUNTU_EXTRA_REMOVE_USER_DATA = "user_data";
     public static final String CHECK_FOR_UPDATE = "com.canonical.ubuntuinstaller.UbuntuInstallService.CHECK_FOR_UPDATE";
     public static final String DELETE_UBUNTU_USER_DATA = "com.canonical.ubuntuinstaller.UbuntuInstallService.DELETE_USER_DATA";
@@ -151,6 +153,7 @@
     private static final String TAR = "u_tar";
     private static final String ANDROID_LOOP_MOUNT = "aloopmount";
     private static final String ANDROID_BOOTMGR = "bootmgr";
+    private static final String UPGRADECHECKER = "upgrade-checker";
     private static final String UPDATE_SCRIPT = "system-image-upgrader";
     private static final String ARCHIVE_MASTER = "archive-master.tar.xz";
     private static final String ARCHIVE_MASTER_ASC = "archive-master.tar.xz.asc";
@@ -179,6 +182,7 @@
     private static final int PROGRESS_MKSWAP_ADJUSTMENT = 17; // equivalent of time tar --checkpoint=200
     private PowerManager mPowerManager;
     private PowerManager.WakeLock mWakeLock;
+    // FIXME make workPath in Cache a private function
     private boolean workPathInCache = false;
     private String mRootOfWorkPath;
     private boolean mIsCanceled;
@@ -210,7 +214,16 @@
         }
 
         public ESumNotMatchException(String string) {
-            // TODO Auto-generated constructor stub
+            super(string);
+        }
+    };
+
+    class EShellExecException extends Exception {
+        public EShellExecException(){
+            super();
+        }
+
+        public EShellExecException(String string) {
             super(string);
         }
     };
@@ -218,7 +231,7 @@
     public UbuntuInstallService() {
         super(TAG);
     }
-    
+
     @Override
     public void onCreate() {
         super.onCreate();
@@ -231,7 +244,7 @@
             mRootOfWorkPath = "/cache";
             workPathInCache = true;
         } else {
-            mRootOfWorkPath = getFilesDir().toString(); //  "/data/data/com.canonical.ubuntuinstaller/files";
+            mRootOfWorkPath = getFilesDir().toString(); //  "/data/data/com.canonical.ubuntu.installer/files";
             workPathInCache = false;
         }
         mInstallerState = InstallerState.READY;
@@ -281,6 +294,12 @@
         } else if (action.equals(INSTALL_UBUNTU)) {
             updateInstallerState(InstallerState.INSTALLING);
             result = doInstallUbuntu(intent);
+        } else if (action.equals(IS_UBUNTU_UPGRADABLE)) {
+            // check if the upgradeable images available.
+            if(findInstallCommand()) {
+                Log.d(TAG, "There is a upgradeable file. send VERSION_UPDATE");
+                result = new Intent(VERSION_UPDATE);
+            }
         } else if (action.equals(CANCEL_INSTALL)) {
             // install should be already cancelled, try to delete it now
             updateInstallerState(InstallerState.UNINSTALLING);
@@ -309,7 +328,7 @@
 
     private Intent doGetChannelList(Intent intent) {
         Intent result = new Intent(AVAILABLE_CHANNELS);
-        // 
+
         HashMap<String, String> channels= new HashMap<String, String>();
         boolean includeHidden = getSharedPreferences( SHARED_PREF, Context.MODE_PRIVATE).getBoolean(PREF_KEY_DEVELOPER, false);
         String deviceModel = Build.DEVICE.toLowerCase(Locale.US);
@@ -365,149 +384,74 @@
     }
 
     private Intent doInstallUbuntu(Intent intent) {
-        Log.w(TAG, "doInstallUbuntu");        
+        Log.w(TAG, "doInstallUbuntu");
         Intent result = new Intent(INSTALL_RESULT);
+
         // get update command file
-        SharedPreferences pref = getSharedPreferences( SHARED_PREF, Context.MODE_PRIVATE);
-        String updateCommand = pref.getString(PREF_KEY_UPDATE_COMMAND,"");
+        String updateCommand = getUpdateCommand();
+
+        // 1. check if update command exist.
+        // 2. However, if the udpate command is in "/cache",
+        // the app can not access to /cache sometimes.
+        if (updateCommand.equals("") ||
+                (!new File(updateCommand).exists() &&
+                 !updateCommand.startsWith("/cache"))) {
+            return handleInstallFail(result, -1, "Missing update command");
+        }
+
+        SharedPreferences pref = getSharedPreferences(SHARED_PREF, Context.MODE_PRIVATE);
         mTotalSize = pref.getInt(PREF_KEY_ESTIMATED_CHECKPOINTS, 0);
         mLastSignalledProgress = 0;
-        if (updateCommand.equals("") || ! new File(updateCommand).exists()) {
-            return handleInstallFail(result, -1, "Missing update command");
-        }
-        mWakeLock = mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "ubuntu-installing");
-        try {
-            File rootFolder = new File(mRootOfWorkPath);
-            File supportingFiles = new File(rootFolder, RELEASE_FOLDER);
-            broadcastProgress(0, "Extracting supporting files");
-            try {
-                Utils.extractExecutableAsset(this, BUSYBOX, supportingFiles.toString(), true);
-                Utils.extractExecutableAsset(this, ANDROID_BOOTMGR, supportingFiles.toString(), true);
-                Utils.extractExecutableAsset(this, GPG, supportingFiles.toString(), true);
-                Utils.extractExecutableAsset(this, TAR, supportingFiles.toString(), true);
-                Utils.extractExecutableAsset(this, UPDATE_SCRIPT, supportingFiles.toString(), true);
-                Utils.extractExecutableAsset(this, ANDROID_LOOP_MOUNT, supportingFiles.toString(), true);
-                Utils.extractExecutableAsset(this, ARCHIVE_MASTER, supportingFiles.toString(), false);
-                Utils.extractExecutableAsset(this, ARCHIVE_MASTER_ASC, supportingFiles.toString(), false);
-                Utils.extractExecutableAsset(this, U_REBOOT_APP, supportingFiles.toString(), false);
-                Utils.extractExecutableAsset(this, U_REBOOT_APP_ASC, supportingFiles.toString(), false);
-            } catch (IOException e) {
-                e.printStackTrace();
-                return handleInstallFail(result, -1, "Failed to extract supporting assets");
-            }
-            // get superuser and run update script
-            broadcastProgress(-1, "Starting update script");
-            try {
-                Process process = Runtime.getRuntime().exec("su", null, supportingFiles);
-                DataOutputStream os = new DataOutputStream(process.getOutputStream());
-                // debug purpose.
-                // os.writeBytes("set -x\n");
-                // make sure we are in work folder
-                os.writeBytes(String.format("cd %s\n", supportingFiles.getAbsolutePath()));
-                os.writeBytes("echo \"SU granted\"\n");
-                // run system-image-upgrader.
-                os.writeBytes(String.format("sh %s %s %s\n",
-                        UPDATE_SCRIPT,
-                        updateCommand,
-                        getFilesDir().getAbsolutePath()
-                        ));
-                os.writeBytes(String.format("cd %s\n", supportingFiles.getAbsolutePath()));
-                // backup original recovery.
-                if(!new File(getFilesDir().toString(), ANDROID_REOCVERY_IMG).exists()) {
-                    os.writeBytes(String.format("./%s -b %s %s/%s\n",
-                            ANDROID_BOOTMGR,
-                            Utils.getRecoveryPartitionPath(),
-                            getFilesDir().getAbsolutePath(),
-                            ANDROID_REOCVERY_IMG
-                            ));
-                }
-                os.writeBytes(String.format("cd %s\n", supportingFiles.getAbsolutePath()));
-                // overwrite the recovery partition.
-                os.writeBytes(String.format("./%s -b %s/%s %s\n",
+
+        List<String> shellcmds = new ArrayList<String>();
+        {
+            shellcmds.add("echo Installing\n");
+            // run system-image-upgrader.
+            shellcmds.add(String.format("%s %s %s\n",
+                    UPDATE_SCRIPT,
+                    updateCommand,
+                    getFilesDir().getAbsolutePath()
+                    ));
+            // Only backup original recovery, when there is no backuped file.
+            if(!new File(getFilesDir().toString(), ANDROID_REOCVERY_IMG).exists()) {
+                shellcmds.add(String.format("%s -b %s %s/%s\n",
                         ANDROID_BOOTMGR,
+                        Utils.getRecoveryPartitionPath(),
                         getFilesDir().getAbsolutePath(),
-                        UBUNTU_BOOT_IMG,
-                        Utils.getRecoveryPartitionPath()
+                        ANDROID_REOCVERY_IMG
                         ));
-
-                // close terminal
-                os.writeBytes("exit\n");
-                os.flush();
-                InputStream is = process.getInputStream();
-                InputStream es = process.getErrorStream();
-                int read = 0;
-                byte[] buff = new byte[4096];
-                boolean running = true;
-                boolean scriptExecuted = false;
-                do {
-                    while( is.available() > 0) {
-                        read = is.read(buff);
-                        if ( read <= 0 ) {
-                            break;
-                        }
-                        scriptExecuted = true;
-                        String seg = new String(buff,0,read);
-                        Log.d(TAG, "Script Output: " + seg);
-                        broadcastProgress(-1, seg);
-                    }
-                    while( es.available() > 0) {
-                        read = es.read(buff);
-                        if ( read <= 0 ) {
-                            break;
-                        }
-                        scriptExecuted = true;
-                        String seg = new String(buff,0,read);
-                        if (seg.startsWith("SWAP-file-missing")) {
-                            // this is signal that we will also install swap, adjust progress estimates
-                            mTotalSize += PROGRESS_MKSWAP_ADJUSTMENT + PROGRESS_SWAP_CREATION_ADJUSTMENT;
-                        } else {
-                            mProgress++;
-                            if ( mLastSignalledProgress < (mProgress * 100 / mTotalSize)) {
-                                // update and signal new progress
-                                mLastSignalledProgress = (int) (mProgress * 100 / mTotalSize);
-                                broadcastProgress(mLastSignalledProgress, null);
-                            }
-                        }
-                        Log.d(TAG, "Stderr Output: " + seg);
-                    }                    
-                    try {
-                        int ret = process.exitValue();
-                        Log.v(TAG, "Worker thread exited with: " + ret);
-                          // if script was not executed, then user did not granted SU permissions
-                        if (ret == 255 || !scriptExecuted ) {
-                            return handleInstallFail(result, -1, "Failed to get SU permissions");
-                        } else if (ret != 0) {
-                            return handleInstallFail(result, -1, "Instalation failed");
-                        }
-                        running =false;
-                    } catch (IllegalThreadStateException e) {
-                        // still running, wait a bit
-                        try { Thread.sleep(200); } catch(Exception ex) {}
-                    }
-                } while (running);
-            } catch (IOException e) {
-                e.printStackTrace();
-                Log.w(TAG, "Update failed");
-                return handleInstallFail(result, -1, "Install failed");
-            }
-        } finally {
-            if (mWakeLock != null && mWakeLock.isHeld()) {
-                mWakeLock.release();
-            }
-        }
-        SharedPreferences.Editor editor = pref.edit();
-        editor.putString(PREF_KEY_UPDATE_COMMAND, "");
+            }
+            // overwrite the recovery partition.
+            shellcmds.add(String.format("%s -b %s/%s %s\n",
+                    ANDROID_BOOTMGR,
+                    getFilesDir().getAbsolutePath(),
+                    UBUNTU_BOOT_IMG,
+                    Utils.getRecoveryPartitionPath()
+                    ));
+            shellcmds.add("exit");
+        }
+
+        broadcastProgress(-1, "Starting update script - " + updateCommand);
+        try {
+            int ret = executeSUCommands(shellcmds.toArray(new String[shellcmds.size()]));
+            result.putExtra(INSTALL_RESULT_EXTRA_INT, ret);
+        } catch (EShellExecException e) {
+            return handleInstallFail(result, -1, e.getMessage());
+        }
+
+        // we done.
+        cleanUpdateCommand();
         VersionInfo v = new VersionInfo(pref, PREF_KEY_DOWNLOADED_VERSION);
-        v.storeVersion(editor, PREF_KEY_INSTALLED_VERSION);
+        v.storeVersion(pref.edit(), PREF_KEY_INSTALLED_VERSION);
         mProgress = 100;
-        result.putExtra(INSTALL_RESULT_EXTRA_INT, 0);
         return result;
     }
-    
+
     private Intent handleInstallFail(Intent i, int res, String failReason) {
         i.putExtra(INSTALL_RESULT_EXTRA_INT, -1);
-        i.putExtra(INSTALL_RESULT_EXTRA_STR, "Missing update command");
-        doUninstallUbuntu(i);
+        i.putExtra(INSTALL_RESULT_EXTRA_STR, failReason);
+        // we don't want to unstainll if we failed to install a update.
+        // doUninstallUbuntu(i);
         return i;
     }
 
@@ -516,9 +460,11 @@
         File updateCommand = new File(workingFolder, UPDATE_COMMAND);
         Intent result = new Intent(VERSION_UPDATE);
         boolean removeUserData = intent.getBooleanExtra(UNINSTALL_UBUNTU_EXTRA_REMOVE_USER_DATA, false);
+        Log.d(TAG, "doUninstallUbuntu");
 
         String format_cmd = null;
         if (removeUserData) {
+            Log.d(TAG, "removing user data.");
             format_cmd = String.format("echo \"%s %s\n %s %s\" > %s\n",
                                     COMMAND_FORMAT, PARTITION_DATA,
                                     COMMAND_UMOUNT, PARTITION_SYSTEM,
@@ -532,41 +478,53 @@
         // 1. force unmount
         // 2. restore android recovery partition, and deleted it.
         // 3. delete system.img and SWAP.img.
-        int r = executeSUCommands(result, "result", new String[]{
-                format_cmd,
-                ("sh " + UPDATE_SCRIPT 
-                        + " " + updateCommand.getAbsolutePath() 
-                        + " " + getFilesDir().toString() + "\n"),
-                 String.format("./%s -b %s/%s %s\n",
-                         ANDROID_BOOTMGR,
-                         getFilesDir().toString(),
-                         ANDROID_REOCVERY_IMG,
-                          Utils.getRecoveryPartitionPath()),
-                 (String.format("rm -f %s/%s\n", getFilesDir().toString(), ANDROID_REOCVERY_IMG)),
-                 ("rm -rf /data/system.img\n"),
-                 ("rm -rf /data/SWAP.img\n"),
-        } );
-        if (r == 0) {
-            // delete installed version in preferences
-            SharedPreferences pref = getSharedPreferences( SHARED_PREF, Context.MODE_PRIVATE);
-            SharedPreferences.Editor editor = pref.edit();
-            editor.putString(PREF_KEY_UPDATE_COMMAND, "");
-            VersionInfo.storeEmptyVersion(editor, PREF_KEY_INSTALLED_VERSION);
-            editor.commit();
+        try {
+            int r = executeSUCommands(
+                    new String[]{
+                        ("echo Uninstalling\n"),
+                        format_cmd,
+                        ("sh " + UPDATE_SCRIPT 
+                            + " " + updateCommand.getAbsolutePath() 
+                            + " " + getFilesDir().toString() + "\n"),
+                            String.format("%s -b %s/%s %s || true\n",
+                                    ANDROID_BOOTMGR,
+                                    getFilesDir().toString(),
+                                    ANDROID_REOCVERY_IMG,
+                                    Utils.getRecoveryPartitionPath()),
+                            (String.format("rm -f %s/%s  || true\n", getFilesDir().toString(), ANDROID_REOCVERY_IMG)),
+                            ("rm -rf /data/system.img || true\n"),
+                            ("rm -rf /data/SWAP.img || true\n"),
+            } );
+
+            if (r == 0) {
+                // delete installed version in preferences
+                cleanUpdateCommand();
+                VersionInfo.storeEmptyVersion(
+                        getSharedPreferences(SHARED_PREF, Context.MODE_PRIVATE).edit(), PREF_KEY_INSTALLED_VERSION);
+            }
+            result.putExtra("result", r);
+        } catch (EShellExecException e) {
+            result.putExtra("result", -1);
         }
-        result.putExtra("result", r);
+
         return result;
     }
 
     private Intent doDeleteUbuntuUserData(Intent intent) {
         Intent result = new Intent(VERSION_UPDATE);
         File workingFolder = new File(mRootOfWorkPath, TEMP_FOLDER);
-        File updateCommand = new File(workingFolder, UPDATE_COMMAND);        
-        int r = executeSUCommands(result, "fail_description", new String[]{
+        File updateCommand = new File(workingFolder, UPDATE_COMMAND);
+
+        try {
+            int r = executeSUCommands(new String[]{
                 String.format("echo \"%s %s\" > %s\n", COMMAND_FORMAT, PARTITION_DATA, UPDATE_COMMAND),
                 ("sh " + UPDATE_SCRIPT + " " + updateCommand.getAbsolutePath() + " " + getFilesDir().toString() + "\n")
-        } );
-        result.putExtra("result", r);
+            } );
+            result.putExtra("result", r);
+        } catch (EShellExecException e) {
+            result.putExtra("fail_description", e.getMessage());
+            result.putExtra("result", -1);
+        }
         return result;
     }
 
@@ -579,75 +537,83 @@
             // FIXME: in Android 4.4, we do not get power manager permission.
             // try it with SU permissions
             try {
-                Process process = Runtime.getRuntime().exec("su", null, getFilesDir());
-                DataOutputStream os = new DataOutputStream(process.getOutputStream());
-                
-                Utils.extractExecutableAsset(this, ANDROID_BOOTMGR, getFilesDir().toString(), true);
-                // overwrite the recovery partition.
-                os.writeBytes(String.format("%s/%s -b %s/%s %s\n",
-                        getFilesDir().getAbsolutePath(),
-                        ANDROID_BOOTMGR,
-                        getFilesDir().getAbsolutePath(),
-                        UBUNTU_BOOT_IMG,
-                        Utils.getRecoveryPartitionPath()
-                        ));
-                os.writeBytes("reboot recovery\n");
-                os.flush();
-                try {
-                    process.waitFor();
-                    if (process.exitValue() != 255) {
-                        Utils.showToast(this.getApplicationContext(), "Rebooting to Ubuntu");
-                    } else {
-                        Utils.showToast(this.getApplicationContext(),  "No permissions to reboot to recovery");
-                    }
-                } catch (InterruptedException ee) {
-                    Utils.showToast(this.getApplicationContext(), "No permissions to reboot to recovery");
+                int r = executeSUCommands(new String[] {
+                        String.format("%s -b %s/%s %s || true\n",
+                                ANDROID_BOOTMGR,
+                                getFilesDir().getAbsolutePath(),
+                                UBUNTU_BOOT_IMG,
+                                Utils.getRecoveryPartitionPath()),
+                        "reboot recovery\n"
+                });
+                if(r != 255) {
+                    Utils.showToast(this.getApplicationContext(), "Rebooting to Ubuntu");
+                } else {
+                    Utils.showToast(this.getApplicationContext(),  "No permissions to reboot to recovery");
                 }
-            } catch (IOException eee) {
-                Utils.showToast(this.getApplicationContext(), "No permissions to reboot to recovery");
+            } catch (EShellExecException e1) {
+                Utils.showToast(this.getApplicationContext(),  "No permissions to reboot to recovery");
             }
         }
     }
 
     /**
-     * 
-     * @param result intent to update with result text
-     * @param resultExtraText 
-     * @param commands commands to execute
-     * @return 0 for success and -1 for fail
+     * This command exec commands in the working folder with supporting utils.
+     *
+     * @param commands commands to be executed
+     * @return shell script exit value.
+     * @throws EShellExecException
      */
-    private int executeSUCommands(Intent result, String resultExtraText, String[] commands) {
+    private int executeSUCommands(String[] commands) throws EShellExecException {
+        int ret = 0;
         File rootFolder = new File(mRootOfWorkPath);
         File workingFolder = new File(rootFolder, TEMP_FOLDER);
+        String workingFolderPath = workingFolder.getAbsolutePath();
+
         if (!workingFolder.exists() && !workingFolder.mkdir()) {
-            result.putExtra(resultExtraText, "Failed to create working folder");
-            return -1;
+            throw(new EShellExecException("Failed to create working folder"));
         }
+
+        broadcastProgress(0, "Extracting supporting files at " + workingFolder.getAbsolutePath());
         try {
-            Utils.extractExecutableAsset(this, UPDATE_SCRIPT, workingFolder.toString(), true);
-            Utils.extractExecutableAsset(this, ANDROID_LOOP_MOUNT, workingFolder.toString(), true);
-            Utils.extractExecutableAsset(this, ANDROID_BOOTMGR, workingFolder.toString(), true);
+            // extract utils into working folder.
+            Utils.extractExecutableAsset(this, ANDROID_BOOTMGR, workingFolderPath, true);
+            Utils.extractExecutableAsset(this, ANDROID_LOOP_MOUNT, workingFolderPath, true);
+            Utils.extractExecutableAsset(this, ARCHIVE_MASTER_ASC, workingFolderPath, false);
+            Utils.extractExecutableAsset(this, ARCHIVE_MASTER, workingFolderPath, false);
+            Utils.extractExecutableAsset(this, BUSYBOX, workingFolderPath, true);
+            Utils.extractExecutableAsset(this, GPG, workingFolderPath, true);
+            Utils.extractExecutableAsset(this, TAR, workingFolderPath, true);
+            Utils.extractExecutableAsset(this, UPDATE_SCRIPT, workingFolderPath, true);
+            Utils.extractExecutableAsset(this, U_REBOOT_APP_ASC, workingFolderPath, false);
+            Utils.extractExecutableAsset(this, U_REBOOT_APP, workingFolderPath, false);
+            Utils.extractExecutableAsset(this, UPGRADECHECKER, workingFolderPath, true);
         } catch (IOException e) {
-            e.printStackTrace();
-            result.putExtra(resultExtraText, "Failed to extract supporting files");
-            return -1;
+            throw(new EShellExecException("Failed to extract supporting utils"));
         }
 
-        mWakeLock = mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "ubuntu-installing");
+        mWakeLock = mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "shelling");
         try {
             Process process = Runtime.getRuntime().exec("su", null, workingFolder);
             DataOutputStream os = new DataOutputStream(process.getOutputStream());
+            // debug purpose.
+            os.writeBytes("set -x\n");
+
+            os.writeBytes("echo \"SU granted\"\n");
             // make sure we are in work folder
-            os.writeBytes("echo \"SU granted\"\n");
-            for (String c : commands) {
-                Log.v(TAG, "Executing:" + c);
-                // make sure we are always at working folder before running next command
-                os.writeBytes(String.format("cd %s\n", workingFolder.getAbsolutePath()));
-                os.writeBytes(c);
+            os.writeBytes(String.format("cd %s\n", workingFolder.getAbsolutePath()));
+            // setup search path for commands
+            os.writeBytes(String.format("export PATH=%s:$PATH\n", workingFolder.getAbsolutePath()));
+
+            for (String cmd : commands) {
+                Log.d(TAG, "Executing: " + cmd + "\n");
+                os.writeBytes(cmd + "\n");
+                os.writeBytes("CMDSTATES=$?\n");
             }
+            // clean up supporting utils.
             os.writeBytes(String.format("rm -rf %s\n", workingFolder.getAbsolutePath()));
-            os.writeBytes("exit\n");
+            os.writeBytes("exit $CMDSTATES\n");
             os.flush();
+
             int read = 0;
             byte[] buff = new byte[4096];
             InputStream is = process.getInputStream();
@@ -661,7 +627,7 @@
                         break;
                     }
                     scriptExecuted = true;
-                    String seg = new String(buff,0,read);
+                    String seg = new String(buff, 0, read);
                     Log.i(TAG, "Script Output: " + seg);
                     broadcastProgress(-1, seg);
                 }
@@ -672,37 +638,44 @@
                     }
                     scriptExecuted = true;
                     String seg = new String(buff,0,read);
+                    
+                    if (seg.startsWith("SWAP-file-missing")) {
+                        // this is signal that we will also install swap, adjust progress estimates
+                        mTotalSize += PROGRESS_MKSWAP_ADJUSTMENT + PROGRESS_SWAP_CREATION_ADJUSTMENT;
+                    } else {
+                        mProgress++;
+                        if (mTotalSize > 0 && mLastSignalledProgress < (mProgress * 100 / mTotalSize)) {
+                            // update and signal new progress
+                            mLastSignalledProgress = (int) (mProgress * 100 / mTotalSize);
+                            broadcastProgress(mLastSignalledProgress, null);
+                        }
+                    }
+
                     Log.i(TAG, "Stderr Output: " + seg);
                 }
                 try {
-                    int ret = process.exitValue();
-                    Log.v(TAG, "Worker thread exited with: " + ret);
+                    ret = process.exitValue();
+                    Log.d(TAG, "Worker thread exited with: " + ret);
                     // if script was not executed, then user did not granted SU permissions
-                    if (ret == 255 || !scriptExecuted ) {
-                        result.putExtra(resultExtraText, "Failed to get SU permissions");
-                        return -1;
-                    } else if (ret != 0) {
-                        result.putExtra(resultExtraText, "Script failed");
-                        return -1;                    
+                    if (!scriptExecuted) {
+                        throw new EShellExecException("Failed to get SU permissions");
                     }
-                    running =false;
+                    running = false;
                 } catch (IllegalThreadStateException e) {
                     // still running, wait a bit
                     try { Thread.sleep(200); } catch(Exception ex) {}
                 }
             } while (running);
-        }catch (IOException e) {
-            e.printStackTrace();
-            result.putExtra(resultExtraText, "Script execution exception");
-            return -1;
+        } catch (IOException e) {
+            throw(new EShellExecException("Script execution exception " + e.getMessage()));
         } finally {
             if (mWakeLock != null && mWakeLock.isHeld()) {
                 mWakeLock.release();
             }
         }
-        return 0;
+        return ret;
     }
-    
+
     private Intent doDownloadRelease(Intent intent) {
         mWakeLock = mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "ufa-downloading");
         mIsCanceled = false;
@@ -780,7 +753,7 @@
             }
 
             // make sure release folder exists
-            File release = new File(rootFolder,RELEASE_FOLDER);
+            File release = new File(rootFolder, RELEASE_FOLDER);
             release.mkdir();
             // download release
             long time = System.currentTimeMillis();
@@ -970,8 +943,11 @@
                  }
             }
             // store update command
+            setUpdateCommand(updateCommand.getAbsolutePath());
+
+            // updated downloaded information.
             VersionInfo v = new VersionInfo(alias, jsonUrl, choosenRelease.description, choosenRelease.version, 0, releaseType);
-            editor.putString(PREF_KEY_UPDATE_COMMAND, updateCommand.getAbsolutePath());
+
             editor.putInt(PREF_KEY_ESTIMATED_CHECKPOINTS, estimatedCheckCount);
             v.storeVersion(editor, PREF_KEY_DOWNLOADED_VERSION);
             mProgress = 100;
@@ -1071,40 +1047,38 @@
         return fileName;
     }
 
+
+    private static  boolean deleteDirectory(File path) {
+        if( path.exists() ) {
+            File[] files = path.listFiles();
+            for(int i=0; i<files.length; i++) {
+                if(files[i].isDirectory()) {
+                    deleteDirectory(files[i]);
+                } else {
+                    files[i].delete();
+                }
+            }
+        }
+        return( path.delete() );
+    }
+
     /**
-     * 
      * @return null if success or error
      */
     private String deleteRelease() {
         // First delete old release if it exists
         File rootFolder = new File(mRootOfWorkPath);
-        File release = new File(rootFolder,RELEASE_FOLDER);
+        File release = new File(rootFolder, RELEASE_FOLDER);
         if (release.exists()) {
-            try {
-                String command = "rm -rf " + release.getAbsolutePath();
-                Process p = Runtime.getRuntime().exec(command , null, rootFolder);
-                try {   
-                    p.waitFor();
-                    int r = p.exitValue();
-                    if (r == 255) {
-                        return "failed to remove old download";
-                    } 
-                } catch (InterruptedException e) {   
-                }   
-            }catch (IOException e) {
-                e.printStackTrace();
-                Log.w(TAG, "failed to remove old download");
-                return "failed to remove old download";
-            }
-            SharedPreferences pref = getSharedPreferences(SHARED_PREF, Context.MODE_PRIVATE);
-            SharedPreferences.Editor editor = pref.edit();
-            editor.putString(PREF_KEY_UPDATE_COMMAND, "");
-            VersionInfo.storeEmptyVersion(editor, PREF_KEY_DOWNLOADED_VERSION);
-            editor.commit();
+            deleteDirectory(release);
+            // cleanup update command
+            cleanUpdateCommand();
+            // clean up version number.
+            VersionInfo.storeEmptyVersion(getSharedPreferences(SHARED_PREF, Context.MODE_PRIVATE).edit(), PREF_KEY_DOWNLOADED_VERSION);
         }
         return null;
     }
-    
+
     private void broadcastInstallerState() {
         Intent i = new Intent(SERVICE_STATE);
         i.putExtra(SERVICE_STATE, mInstallerState.ordinal());
@@ -1117,16 +1091,7 @@
         i.putExtra(SERVICE_STATE, mInstallerState.ordinal());
         sendBroadcast(i);        
     }
-    
-    private void broadcastProgress(int val, String progress) {
-        Intent i = new Intent(PROGRESS);
-        i.putExtra(PROGRESS_EXTRA_INT, val);
-        if (progress!= null) {
-            i.putExtra(PROGRESS_EXTRA_TEXT, progress);
-        }
-        sendBroadcast(i);
-    }
-    
+
     /**
      * Check whether storage free space is enough.
      * @param downloadSize: download size from json. 0 means file already downloaded.
@@ -1161,6 +1126,7 @@
         }
         return null;
     }
+
     /**
      * Internal helper function to get current DOWNLOAD_VERSION even download is partial
      * @param context
@@ -1186,6 +1152,7 @@
     public static VersionInfo getInstalledVersion(Context c) {
         return getVersionWithPrefKey(c, PREF_KEY_INSTALLED_VERSION);
     }
+ 
     public static boolean isUbuntuInstalled(Context c) {
         SharedPreferences pref = c.getSharedPreferences(SHARED_PREF, Context.MODE_PRIVATE);
         if (VersionInfo.hasValidVersion(pref, PREF_KEY_INSTALLED_VERSION)) {
@@ -1194,9 +1161,111 @@
         }
         return false;
     }
+
+    /**
+     *  check if update_command available for upgrade.
+     *
+     * @param c
+     * @return
+     */
+    public static boolean isUpgradeable(Context c) {
+        String cmd = c.getSharedPreferences(SHARED_PREF, Context.MODE_PRIVATE).getString(PREF_KEY_UPDATE_COMMAND, "");
+        return (cmd.startsWith("/cache/"));
+    }
+
+    /**
+     * check if recovery command is exist on the system.
+     * system-image in Ubuntu Touch downloaded new version of image at /cache/recovery.
+     * This function check if there is a ubuntu_command file in /cache/recovery.
+     *
+     * The ubuntu_command  will be renamed or removed after installation.
+     *
+     * @return if there is upgradeable images stored in /cache.
+     */
+    public boolean findInstallCommand () {
+        String[] candidates = {
+                "/cache/recovery/ubuntu_command",
+                "/cache/ubunturecovery/ubuntu_command",
+        };
+        boolean ret = false;
+        for(String command: candidates) {
+            if(new File("/cache").canRead()) {
+                // if we have permission, we can read /cache.
+                File cmd = new File(command);
+                if(cmd.exists() && cmd.isFile()) {
+                    Log.d(TAG, "Found upgrade command - " + cmd.getAbsoluteFile().toString());
+                    // find the upgradeable file, stored into pref.
+                    setUpdateCommand(cmd.getAbsolutePath());
+                    ret = true;
+                }
+            } else {
+                // check the file with su
+                File workingFolder = new File(mRootOfWorkPath + "/" + TEMP_FOLDER);
+                if (!workingFolder.exists() && !workingFolder.mkdir()) {
+                    Log.e(TAG, "can not create working folder");
+                    ret = false;
+                }
+                try {
+                    int r = executeSUCommands(new String[] {
+                            String.format("%s %s\n", UPGRADECHECKER, command),
+                    });
+                    if(r == 1) {
+                        Log.d(TAG, "Found upgradeable file - " + command);
+                        setUpdateCommand(command);
+                        ret = true;
+                    }
+                } catch (EShellExecException e) {
+                    ret = false;
+                }
+            }
+        }
+        if(ret) {
+            // FIXME we don't know what's the version in /cache.
+            SharedPreferences pref = getSharedPreferences(SHARED_PREF, Context.MODE_PRIVATE);
+            VersionInfo v = new VersionInfo(pref, PREF_KEY_INSTALLED_VERSION);
+            v.storeVersion(pref.edit(), PREF_KEY_DOWNLOADED_VERSION);
+        }
+        return ret;
+    }
+
+    /**
+     * set update command string stored in shared preferences.
+     * @file absolute file path of Ubuntu Command file.
+     */
+    private String getUpdateCommand(){
+        return getSharedPreferences(SHARED_PREF, Context.MODE_PRIVATE).getString(PREF_KEY_UPDATE_COMMAND, "");
+    }
+
+    /**
+     * set update command string stored in shared preferences.
+     * @file absolute file path of Ubuntu Command file.
+     */
+    private void setUpdateCommand(String file){
+        getSharedPreferences(SHARED_PREF, Context.MODE_PRIVATE).
+        edit().
+        putString(PREF_KEY_UPDATE_COMMAND, file).
+        commit();
+    }
+
+    /**
+     * clean update command string stored in shared preferences.
+     */
+    private void cleanUpdateCommand() {
+        this.setUpdateCommand("");
+    }
     
+    private void broadcastProgress(int val, String progress) {
+        Intent i = new Intent(PROGRESS);
+        i.putExtra(PROGRESS_EXTRA_INT, val);
+        if (progress!= null) {
+            i.putExtra(PROGRESS_EXTRA_TEXT, progress);
+        }
+        sendBroadcast(i);
+    }
+
     /**
-     * Check if there is downloaded release ready to install
+     * Check if there is downloaded release ready to install.
+     * If command file is not exist, reset downloaded version.
      * @param context
      * @return true if there is downloaded release ready to install
      */
@@ -1207,9 +1276,10 @@
         if (versionInfo.getDownloadedSize() != 0) return false;
         
         String command = pref.getString(PREF_KEY_UPDATE_COMMAND, "");
+        Log.d(TAG, "checkifReadyToInstall");
         if (!command.equals("")) {
-            File f = new File(command);
-            if (f.exists()) {
+            if (new File(command).exists() || command.startsWith("/cache")) {
+                Log.d(TAG, "checkifReadyToInstall - found command file " + command);
                 return true;
             } else {
                 pref.edit().putString(PREF_KEY_UPDATE_COMMAND, "").commit();

=== modified file 'src/com/canonical/ubuntu/installer/VersionInfo.java'
--- src/com/canonical/ubuntu/installer/VersionInfo.java	2013-12-24 03:50:41 +0000
+++ src/com/canonical/ubuntu/installer/VersionInfo.java	2013-12-26 07:18:46 +0000
@@ -5,7 +5,6 @@
 
 /**
  * Version holder
- *
  */
 public class VersionInfo {
     
@@ -109,9 +108,6 @@
     }
 
     public static boolean hasValidVersion(SharedPreferences sp, String set) {
-        int v = sp.getInt(set + VERSION, -1);
-        String s1 = sp.getString(set + ALIAS, "");
-        String s2 = sp.getString(set + JSON, "");
         return (-1 != sp.getInt(set + VERSION, -1));
     }