Merge commit 'b26b9425d700359d6ee68d45ac334fd1f2ab82d4' into remote

Conflicts:
	src/com/android/packageinstaller/permission/ui/handheld/GrantPermissionsViewHandlerImpl.java

Change-Id: Ia57d17750406754f1e19266f51f0115e3cf774ba

15 files changed, 786 insertions, 131 deletions

diff --git a/src/com/android/packageinstaller/InstallAppProgress.java b/src/com/android/packageinstaller/InstallAppProgress.java
index 7554704b..49d91cf1 100755
--- a/src/com/android/packageinstaller/InstallAppProgress.java
+++ b/src/com/android/packageinstaller/InstallAppProgress.java
@@ -34,6 +34,8 @@ import android.content.pm.PackageInfo;
 import android.content.pm.PackageInstaller;
 import android.content.pm.PackageManager;
 import android.content.pm.PackageManager.NameNotFoundException;
+import android.content.pm.PackageParser;
+import android.content.pm.PackageParser.PackageLite;
 import android.content.pm.ResolveInfo;
 import android.net.Uri;
 import android.os.Bundle;
@@ -48,6 +50,8 @@ import android.widget.ProgressBar;
 import android.widget.TextView;
 import com.android.packageinstaller.permission.utils.IoUtils;
 
+import com.android.internal.content.PackageHelper;
+
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
@@ -353,6 +357,22 @@ public class InstallAppProgress extends Activity implements View.OnClickListener
             params.originatingUid = getIntent().getIntExtra(Intent.EXTRA_ORIGINATING_UID,
                     UID_UNKNOWN);
 
+            File file = new File(mPackageURI.getPath());
+            try {
+                PackageLite pkg = PackageParser.parsePackageLite(file, 0);
+                params.setAppPackageName(pkg.packageName);
+                params.setInstallLocation(pkg.installLocation);
+                params.setSize(
+                    PackageHelper.calculateInstalledSize(pkg, false, params.abiOverride));
+            } catch (PackageParser.PackageParserException e) {
+                Log.e(TAG, "Cannot parse package " + file + ". Assuming defaults.");
+                Log.e(TAG, "Cannot calculate installed size " + file + ". Try only apk size.");
+                params.setSize(file.length());
+            } catch (IOException e) {
+                Log.e(TAG, "Cannot calculate installed size " + file + ". Try only apk size.");
+                params.setSize(file.length());
+            }
+
             mInstallHandler.post(new Runnable() {
                 @Override
                 public void run() {
diff --git a/src/com/android/packageinstaller/PackageInstallerActivity.java b/src/com/android/packageinstaller/PackageInstallerActivity.java
index 1903f917..55a1f814 100644
--- a/src/com/android/packageinstaller/PackageInstallerActivity.java
+++ b/src/com/android/packageinstaller/PackageInstallerActivity.java
@@ -37,6 +37,7 @@ import android.net.Uri;
 import android.os.AsyncTask;
 import android.os.Build;
 import android.os.Bundle;
+import android.os.Process;
 import android.os.UserManager;
 import android.provider.Settings;
 import android.support.v4.view.ViewPager;
@@ -119,6 +120,9 @@ public class PackageInstallerActivity extends Activity implements OnCancelListen
     private static final int DLG_NOT_SUPPORTED_ON_WEAR = DLG_BASE + 7;
 
     private void startInstallConfirm() {
+        ((TextView) findViewById(R.id.install_confirm_question))
+                .setText(R.string.install_confirm_question);
+        findViewById(R.id.spacer).setVisibility(View.GONE);
         TabHost tabHost = (TabHost)findViewById(android.R.id.tabhost);
         tabHost.setup();
         tabHost.setVisibility(View.VISIBLE);
@@ -323,7 +327,7 @@ public class PackageInstallerActivity extends Activity implements OnCancelListen
         // whether the untrusted sources setting is on. This allows partners to
         // implement a "allow untrusted source once" feature.
         if (request == REQUEST_ENABLE_UNKNOWN_SOURCES && result == RESULT_OK) {
-            initiateInstall();
+            checkIfAllowedAndInitiateInstall(true);
         } else {
             clearCachedApkIfNeededAndFinish();
         }
@@ -360,8 +364,8 @@ public class PackageInstallerActivity extends Activity implements OnCancelListen
     /**
      * @return whether the device admin restricts installation from unknown sources
      */
-    private boolean isUnknownSourcesAllowedByAdmin() {
-        return !mUserManager.hasUserRestriction(UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES);
+    private boolean isUnknownSourcesDisallowed() {
+        return mUserManager.hasUserRestriction(UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES);
     }
 
     private void initiateInstall() {
@@ -453,27 +457,54 @@ public class PackageInstallerActivity extends Activity implements OnCancelListen
         mOk.setOnClickListener(this);
         mCancel.setOnClickListener(this);
 
+        boolean wasSetUp = processPackageUri(packageUri);
+        if (!wasSetUp) {
+            return;
+        }
+
+        checkIfAllowedAndInitiateInstall(false);
+    }
+
+    /**
+     * Check if it is allowed to install the package and initiate install if allowed. If not allowed
+     * show the appropriate dialog.
+     *
+     * @param ignoreUnknownSourcesSettings Ignore {@link #isUnknownSourcesEnabled()} and proceed
+     *                                     even if this would prevented installation.
+     */
+    private void checkIfAllowedAndInitiateInstall(boolean ignoreUnknownSourcesSettings) {
         // Block the install attempt on the Unknown Sources setting if necessary.
-        final boolean requestFromUnknownSource = isInstallRequestFromUnknownSource(intent);
+        final boolean requestFromUnknownSource = isInstallRequestFromUnknownSource(getIntent());
         if (!requestFromUnknownSource) {
-            processPackageUri(packageUri);
-            return;
+            initiateInstall();
         }
 
         // If the admin prohibits it, or we're running in a managed profile, just show error
         // and exit. Otherwise show an option to take the user to Settings to change the setting.
         final boolean isManagedProfile = mUserManager.isManagedProfile();
-        if (!isUnknownSourcesAllowedByAdmin()) {
-            startActivity(new Intent(Settings.ACTION_SHOW_ADMIN_SUPPORT_DETAILS));
-            clearCachedApkIfNeededAndFinish();
+        if (isUnknownSourcesDisallowed()) {
+            if ((mUserManager.getUserRestrictionSource(UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES,
+                    Process.myUserHandle()) & UserManager.RESTRICTION_SOURCE_SYSTEM) != 0) {
+                if (ignoreUnknownSourcesSettings) {
+                    initiateInstall();
+                } else {
+                    showDialogInner(DLG_UNKNOWN_SOURCES);
+                }
+            } else {
+                startActivity(new Intent(Settings.ACTION_SHOW_ADMIN_SUPPORT_DETAILS));
+                clearCachedApkIfNeededAndFinish();
+            }
         } else if (!isUnknownSourcesEnabled() && isManagedProfile) {
             showDialogInner(DLG_ADMIN_RESTRICTS_UNKNOWN_SOURCES);
         } else if (!isUnknownSourcesEnabled()) {
-            // Ask user to enable setting first
-
-            showDialogInner(DLG_UNKNOWN_SOURCES);
+            if (ignoreUnknownSourcesSettings) {
+                initiateInstall();
+            } else {
+                // Ask user to enable setting first
+                showDialogInner(DLG_UNKNOWN_SOURCES);
+            }
         } else {
-            processPackageUri(packageUri);
+            initiateInstall();
         }
     }
 
@@ -486,7 +517,14 @@ public class PackageInstallerActivity extends Activity implements OnCancelListen
         super.onDestroy();
     }
 
-    private void processPackageUri(final Uri packageUri) {
+    /**
+     * Parse the Uri and set up the installer for this package.
+     *
+     * @param packageUri The URI to parse
+     *
+     * @return {@code true} iff the installer could be set up
+     */
+    private boolean processPackageUri(final Uri packageUri) {
         mPackageURI = packageUri;
 
         final String scheme = packageUri.getScheme();
@@ -505,7 +543,7 @@ public class PackageInstallerActivity extends Activity implements OnCancelListen
                             + " not available. Discontinuing installation");
                     showDialogInner(DLG_PACKAGE_ERROR);
                     setPmResult(PackageManager.INSTALL_FAILED_INVALID_APK);
-                    return;
+                    return false;
                 }
                 as = new PackageUtil.AppSnippet(mPm.getApplicationLabel(mPkgInfo.applicationInfo),
                         mPm.getApplicationIcon(mPkgInfo.applicationInfo));
@@ -520,7 +558,7 @@ public class PackageInstallerActivity extends Activity implements OnCancelListen
                     Log.w(TAG, "Parse error when parsing manifest. Discontinuing installation");
                     showDialogInner(DLG_PACKAGE_ERROR);
                     setPmResult(PackageManager.INSTALL_FAILED_INVALID_APK);
-                    return;
+                    return false;
                 }
                 mPkgInfo = PackageParser.generatePackageInfo(parsed, null,
                         PackageManager.GET_PERMISSIONS, 0, 0, null,
@@ -531,20 +569,20 @@ public class PackageInstallerActivity extends Activity implements OnCancelListen
             case SCHEME_CONTENT: {
                 mStagingAsynTask = new StagingAsyncTask();
                 mStagingAsynTask.execute(packageUri);
-                return;
+                return false;
             }
 
             default: {
                 Log.w(TAG, "Unsupported scheme " + scheme);
                 setPmResult(PackageManager.INSTALL_FAILED_INVALID_URI);
                 clearCachedApkIfNeededAndFinish();
-                return;
+                return false;
             }
         }
 
         PackageUtil.initSnippetForNewApp(this, as, R.id.app_snippet);
 
-        initiateInstall();
+        return true;
     }
 
     /** Get the ApplicationInfo for the calling package, if available */
@@ -770,7 +808,11 @@ public class PackageInstallerActivity extends Activity implements OnCancelListen
             }
             mContentUriApkStagingFile = file;
             Uri fileUri = Uri.fromFile(file);
-            processPackageUri(fileUri);
+
+            boolean wasSetUp = processPackageUri(fileUri);
+            if (wasSetUp) {
+                checkIfAllowedAndInitiateInstall(false);
+            }
         }
 
         @Override
diff --git a/src/com/android/packageinstaller/permission/ui/GrantPermissionsActivity.java b/src/com/android/packageinstaller/permission/ui/GrantPermissionsActivity.java
index fdb16484..48d8dbb3 100644
--- a/src/com/android/packageinstaller/permission/ui/GrantPermissionsActivity.java
+++ b/src/com/android/packageinstaller/permission/ui/GrantPermissionsActivity.java
@@ -49,6 +49,7 @@ import com.android.packageinstaller.permission.ui.handheld.GrantPermissionsViewH
 import com.android.packageinstaller.permission.utils.SafetyNetLogger;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.LinkedHashMap;
 import java.util.List;
 
@@ -92,6 +93,7 @@ public class GrantPermissionsActivity extends OverlayTouchActivity
 
         final int requestedPermCount = mRequestedPermissions.length;
         mGrantResults = new int[requestedPermCount];
+        Arrays.fill(mGrantResults, PackageManager.PERMISSION_DENIED);
 
         if (requestedPermCount == 0) {
             setResultAndFinish();
@@ -207,10 +209,12 @@ public class GrantPermissionsActivity extends OverlayTouchActivity
         // window height needed to show all content. We have to
         // re-add the window to force it to be resized if needed.
         View decor = getWindow().getDecorView();
-        getWindowManager().removeViewImmediate(decor);
-        getWindowManager().addView(decor, decor.getLayoutParams());
-        if (mViewHandler instanceof GrantPermissionsViewHandlerImpl) {
-            ((GrantPermissionsViewHandlerImpl) mViewHandler).onConfigurationChanged();
+        if (decor.getParent() != null) {
+            getWindowManager().removeViewImmediate(decor);
+            getWindowManager().addView(decor, decor.getLayoutParams());
+            if (mViewHandler instanceof GrantPermissionsViewHandlerImpl) {
+                ((GrantPermissionsViewHandlerImpl) mViewHandler).onConfigurationChanged();
+            }
         }
     }
 
diff --git a/src/com/android/packageinstaller/permission/ui/ManualLayoutFrame.java b/src/com/android/packageinstaller/permission/ui/ManualLayoutFrame.java
index a20c9523..0b07c806 100644
--- a/src/com/android/packageinstaller/permission/ui/ManualLayoutFrame.java
+++ b/src/com/android/packageinstaller/permission/ui/ManualLayoutFrame.java
@@ -61,8 +61,13 @@ public class ManualLayoutFrame extends ViewGroup {
 
     @Override
     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+        // We want to keep the content bottom at the same place to avoid movement of the "Allow"
+        // button.
+        // Try to keep the content bottom at the same height. If this would move the dialog out of
+        // the top of the screen move it down as much as possible, then keep it at that position for
+        // the rest of the sequence of permission dialogs.
         View content = getChildAt(0);
-        if (mContentBottom == 0) {
+        if (mContentBottom == 0 || content.getMeasuredHeight() > mContentBottom) {
             mContentBottom = (getMeasuredHeight() + content.getMeasuredHeight()) / 2;
         }
         final int contentLeft = (getMeasuredWidth() - content.getMeasuredWidth()) / 2;
diff --git a/src/com/android/packageinstaller/permission/ui/OverlayTouchActivity.java b/src/com/android/packageinstaller/permission/ui/OverlayTouchActivity.java
index b23ab2e2..a7800ca5 100644
--- a/src/com/android/packageinstaller/permission/ui/OverlayTouchActivity.java
+++ b/src/com/android/packageinstaller/permission/ui/OverlayTouchActivity.java
@@ -40,6 +40,8 @@ public class OverlayTouchActivity extends Activity {
         if (appOpsManager != null) {
             appOpsManager.setUserRestriction(AppOpsManager.OP_SYSTEM_ALERT_WINDOW,
                     !allowed, mToken);
+            appOpsManager.setUserRestriction(AppOpsManager.OP_TOAST_WINDOW,
+                    !allowed, mToken);
         }
     }
 }
diff --git a/src/com/android/packageinstaller/permission/ui/SecureButtonView.java b/src/com/android/packageinstaller/permission/ui/SecureButtonView.java
deleted file mode 100644
index 624744e5..00000000
--- a/src/com/android/packageinstaller/permission/ui/SecureButtonView.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source 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.
- */
-
-package com.android.packageinstaller.permission.ui;
-
-import android.content.Context;
-import android.util.AttributeSet;
-import android.view.MotionEvent;
-import android.widget.Button;
-
-/**
- * Extension of Button that uses the hidden MotionEvent flag for partially obscured windows to
- * prevent tapjacking attacks.
- */
-public class SecureButtonView extends Button {
-
-    public SecureButtonView(Context context) {
-        this(context, null);
-    }
-
-    public SecureButtonView(Context context, AttributeSet attrs) {
-        this(context, attrs, 0);
-    }
-
-    public SecureButtonView(Context context, AttributeSet attrs, int defStyleAttr) {
-        this(context, attrs, defStyleAttr, 0);
-    }
-
-    public SecureButtonView(Context context, AttributeSet attrs, int defStyleAttr,
-            int defStyleRes) {
-        super(context, attrs, defStyleAttr, defStyleRes);
-    }
-
-    @Override
-    public boolean onFilterTouchEventForSecurity(MotionEvent event) {
-        if ((event.getFlags() & MotionEvent.FLAG_WINDOW_IS_OBSCURED) != 0
-                || (event.getFlags() & MotionEvent.FLAG_WINDOW_IS_PARTIALLY_OBSCURED) != 0) {
-            // Window is obscured, drop this touch.
-            return false;
-        }
-        return true;
-    }
-}
diff --git a/src/com/android/packageinstaller/permission/ui/handheld/GrantPermissionsViewHandlerImpl.java b/src/com/android/packageinstaller/permission/ui/handheld/GrantPermissionsViewHandlerImpl.java
index 3d677d63..713b3e27 100755
--- a/src/com/android/packageinstaller/permission/ui/handheld/GrantPermissionsViewHandlerImpl.java
+++ b/src/com/android/packageinstaller/permission/ui/handheld/GrantPermissionsViewHandlerImpl.java
@@ -339,7 +339,7 @@ public final class GrantPermissionsViewHandlerImpl
                 if (mResultListener != null) {
                     view.clearAccessibilityFocus();
                     mResultListener.onPermissionGrantResult(mGroupName, false,
-                            AppPermissionGroup.isStrictOpEnable()? false: mDoNotAskCheckbox.isChecked());
+                            AppPermissionGroup.isStrictOpEnable()? false: mShowDonNotAsk && mDoNotAskCheckbox.isChecked());
                 }
                 break;
             case R.id.do_not_ask_checkbox:
diff --git a/src/com/android/packageinstaller/permission/ui/handheld/PermissionAppsFragment.java b/src/com/android/packageinstaller/permission/ui/handheld/PermissionAppsFragment.java
index df0bdd46..8fe96c97 100644
--- a/src/com/android/packageinstaller/permission/ui/handheld/PermissionAppsFragment.java
+++ b/src/com/android/packageinstaller/permission/ui/handheld/PermissionAppsFragment.java
@@ -34,9 +34,6 @@ import android.view.Menu;
 import android.view.MenuInflater;
 import android.view.MenuItem;
 import android.view.View;
-import android.view.ViewGroup;
-import android.widget.ImageView;
-import android.widget.TextView;
 import com.android.packageinstaller.DeviceUtils;
 import com.android.packageinstaller.R;
 import com.android.packageinstaller.permission.model.AppPermissionGroup;
@@ -81,6 +78,7 @@ public final class PermissionAppsFragment extends PermissionsFrameFragment imple
     private boolean mHasConfirmedRevoke;
 
     private boolean mShowSystem;
+    private boolean mHasSystemApps;
     private MenuItem mShowSystemMenu;
     private MenuItem mHideSystemMenu;
 
@@ -110,13 +108,16 @@ public final class PermissionAppsFragment extends PermissionsFrameFragment imple
 
     @Override
     public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
-        mShowSystemMenu = menu.add(Menu.NONE, MENU_SHOW_SYSTEM, Menu.NONE,
-                R.string.menu_show_system);
-        mHideSystemMenu = menu.add(Menu.NONE, MENU_HIDE_SYSTEM, Menu.NONE,
-                R.string.menu_hide_system);
+        if (mHasSystemApps) {
+            mShowSystemMenu = menu.add(Menu.NONE, MENU_SHOW_SYSTEM, Menu.NONE,
+                    R.string.menu_show_system);
+            mHideSystemMenu = menu.add(Menu.NONE, MENU_HIDE_SYSTEM, Menu.NONE,
+                    R.string.menu_hide_system);
+            updateMenu();
+        }
+
         HelpUtils.prepareHelpMenuItem(getActivity(), menu, R.string.help_app_permissions,
                 getClass().getName());
-        updateMenu();
     }
 
     @Override
@@ -176,6 +177,8 @@ public final class PermissionAppsFragment extends PermissionsFrameFragment imple
             setPreferenceScreen(screen);
         }
 
+        screen.setOrderingAsAdded(false);
+
         ArraySet<String> preferencesToRemove = new ArraySet<>();
         for (int i = 0, n = screen.getPreferenceCount(); i < n; i++) {
             preferencesToRemove.add(screen.getPreference(i).getKey());
@@ -186,11 +189,18 @@ public final class PermissionAppsFragment extends PermissionsFrameFragment imple
             }
         }
 
+        mHasSystemApps = false;
+        boolean menuOptionsInvalided = false;
+
         for (PermissionApp app : permissionApps.getApps()) {
             if (!Utils.shouldShowPermission(app)) {
                 continue;
             }
 
+            if (!app.getAppInfo().enabled) {
+                continue;
+            }
+
             String key = app.getKey();
             preferencesToRemove.remove(key);
             Preference existingPref = screen.findPreference(key);
@@ -199,6 +209,13 @@ public final class PermissionAppsFragment extends PermissionsFrameFragment imple
             }
 
             boolean isSystemApp = Utils.isSystem(app, mLauncherPkgs);
+
+            if (isSystemApp && !menuOptionsInvalided) {
+                mHasSystemApps = true;
+                getActivity().invalidateOptionsMenu();
+                menuOptionsInvalided = true;
+            }
+
             if (isSystemApp && !isTelevision && !mShowSystem) {
                 if (existingPref != null) {
                     screen.removePreference(existingPref);
diff --git a/src/com/android/packageinstaller/permission/ui/television/PermissionAppsFragment.java b/src/com/android/packageinstaller/permission/ui/television/PermissionAppsFragment.java
index 29839c14..ec320701 100644
--- a/src/com/android/packageinstaller/permission/ui/television/PermissionAppsFragment.java
+++ b/src/com/android/packageinstaller/permission/ui/television/PermissionAppsFragment.java
@@ -81,6 +81,7 @@ public final class PermissionAppsFragment extends SettingsWithHeader implements
     private boolean mHasConfirmedRevoke;
 
     private boolean mShowSystem;
+    private boolean mHasSystemApps;
     private MenuItem mShowSystemMenu;
     private MenuItem mHideSystemMenu;
 
@@ -110,11 +111,13 @@ public final class PermissionAppsFragment extends SettingsWithHeader implements
 
     @Override
     public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
-        mShowSystemMenu = menu.add(Menu.NONE, MENU_SHOW_SYSTEM, Menu.NONE,
-                R.string.menu_show_system);
-        mHideSystemMenu = menu.add(Menu.NONE, MENU_HIDE_SYSTEM, Menu.NONE,
-                R.string.menu_hide_system);
-        updateMenu();
+        if (mHasSystemApps) {
+            mShowSystemMenu = menu.add(Menu.NONE, MENU_SHOW_SYSTEM, Menu.NONE,
+                    R.string.menu_show_system);
+            mHideSystemMenu = menu.add(Menu.NONE, MENU_HIDE_SYSTEM, Menu.NONE,
+                    R.string.menu_hide_system);
+            updateMenu();
+        }
     }
 
     @Override
@@ -184,6 +187,9 @@ public final class PermissionAppsFragment extends SettingsWithHeader implements
             }
         }
 
+        mHasSystemApps = false;
+        boolean menuOptionsInvalided = false;
+
         for (PermissionApp app : permissionApps.getApps()) {
             if (!Utils.shouldShowPermission(app)) {
                 continue;
@@ -197,6 +203,13 @@ public final class PermissionAppsFragment extends SettingsWithHeader implements
             }
 
             boolean isSystemApp = Utils.isSystem(app, mLauncherPkgs);
+
+            if (isSystemApp && !menuOptionsInvalided) {
+                mHasSystemApps = true;
+                getActivity().invalidateOptionsMenu();
+                menuOptionsInvalided = true;
+            }
+
             if (isSystemApp && !isTelevision && !mShowSystem) {
                 if (existingPref != null) {
                     screen.removePreference(existingPref);
diff --git a/src/com/android/packageinstaller/wear/InstallTask.java b/src/com/android/packageinstaller/wear/InstallTask.java
new file mode 100644
index 00000000..53a460dc
--- /dev/null
+++ b/src/com/android/packageinstaller/wear/InstallTask.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (C) 2016 The Android Open Source 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
+ */
+
+package com.android.packageinstaller.wear;
+
+import android.content.Context;
+import android.content.IntentSender;
+import android.content.pm.PackageInstaller;
+import android.os.Looper;
+import android.os.ParcelFileDescriptor;
+import android.text.TextUtils;
+import android.util.Log;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * Task that installs an APK. This must not be called on the main thread.
+ * This code is based off the Finsky/Wearsky implementation
+ */
+public class InstallTask {
+    private static final String TAG = "InstallTask";
+
+    private static final int DEFAULT_BUFFER_SIZE = 8192;
+
+    private final Context mContext;
+    private String mPackageName;
+    private ParcelFileDescriptor mParcelFileDescriptor;
+    private PackageInstallerImpl.InstallListener mCallback;
+    private PackageInstaller.Session mSession;
+    private IntentSender mCommitCallback;
+
+    private Exception mException = null;
+    private int mErrorCode = 0;
+    private String mErrorDesc = null;
+
+    public InstallTask(Context context, String packageName,
+            ParcelFileDescriptor parcelFileDescriptor,
+            PackageInstallerImpl.InstallListener callback, PackageInstaller.Session session,
+            IntentSender commitCallback) {
+        mContext = context;
+        mPackageName = packageName;
+        mParcelFileDescriptor = parcelFileDescriptor;
+        mCallback = callback;
+        mSession = session;
+        mCommitCallback = commitCallback;
+    }
+
+    public boolean isError() {
+        return mErrorCode != InstallerConstants.STATUS_SUCCESS || !TextUtils.isEmpty(mErrorDesc);
+    }
+
+    public void execute() {
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            throw new IllegalStateException("This method cannot be called from the UI thread.");
+        }
+
+        OutputStream sessionStream = null;
+        try {
+            sessionStream = mSession.openWrite(mPackageName, 0, -1);
+
+            // 2b: Stream the asset to the installer. Note:
+            // Note: writeToOutputStreamFromAsset() always safely closes the input stream
+            writeToOutputStreamFromAsset(sessionStream);
+            mSession.fsync(sessionStream);
+        } catch (Exception e) {
+            mException = e;
+            mErrorCode = InstallerConstants.ERROR_INSTALL_COPY_STREAM;
+            mErrorDesc = "Could not write to stream";
+        } finally {
+            if (sessionStream != null) {
+                // 2c: close output stream
+                try {
+                    sessionStream.close();
+                } catch (Exception e) {
+                    // Ignore otherwise
+                    if (mException == null) {
+                        mException = e;
+                        mErrorCode = InstallerConstants.ERROR_INSTALL_CLOSE_STREAM;
+                        mErrorDesc = "Could not close session stream";
+                    }
+                }
+            }
+        }
+
+        if (mErrorCode != InstallerConstants.STATUS_SUCCESS) {
+            // An error occurred, we're done
+            Log.e(TAG, "Exception while installing " + mPackageName + ": " + mErrorCode + ", "
+                    + mErrorDesc + ", " + mException);
+            mSession.close();
+            mCallback.installFailed(mErrorCode, "[" + mPackageName + "]" + mErrorDesc);
+        } else {
+            // 3. Commit the session (this actually installs it.)  Session map
+            // will be cleaned up in the callback.
+            mCallback.installBeginning();
+            mSession.commit(mCommitCallback);
+            mSession.close();
+        }
+    }
+
+    /**
+     * {@code PackageInstaller} works with streams. Get the {@code FileDescriptor}
+     * corresponding to the {@code Asset} and then write the contents into an
+     * {@code OutputStream} that is passed in.
+     * <br>
+     * The {@code FileDescriptor} is closed but the {@code OutputStream} is not closed.
+     */
+    private boolean writeToOutputStreamFromAsset(OutputStream outputStream) {
+        if (outputStream == null) {
+            mErrorCode = InstallerConstants.ERROR_INSTALL_COPY_STREAM_EXCEPTION;
+            mErrorDesc = "Got a null OutputStream.";
+            return false;
+        }
+
+        if (mParcelFileDescriptor == null || mParcelFileDescriptor.getFileDescriptor() == null)  {
+            mErrorCode = InstallerConstants.ERROR_COULD_NOT_GET_FD;
+            mErrorDesc = "Could not get FD";
+            return false;
+        }
+
+        InputStream inputStream = null;
+        try {
+            byte[] inputBuf = new byte[DEFAULT_BUFFER_SIZE];
+            int bytesRead;
+            inputStream = new ParcelFileDescriptor.AutoCloseInputStream(mParcelFileDescriptor);
+
+            while ((bytesRead = inputStream.read(inputBuf)) > -1) {
+                if (bytesRead > 0) {
+                    outputStream.write(inputBuf, 0, bytesRead);
+                }
+            }
+
+            outputStream.flush();
+        } catch (IOException e) {
+            mErrorCode = InstallerConstants.ERROR_INSTALL_APK_COPY_FAILURE;
+            mErrorDesc = "Reading from Asset FD or writing to temp file failed: " + e;
+            return false;
+        } finally {
+            safeClose(inputStream);
+        }
+
+        return true;
+    }
+
+    /**
+     * Quietly close a closeable resource (e.g. a stream or file). The input may already
+     * be closed and it may even be null.
+     */
+    public static void safeClose(Closeable resource) {
+        if (resource != null) {
+            try {
+                resource.close();
+            } catch (IOException ioe) {
+                // Catch and discard the error
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/com/android/packageinstaller/wear/InstallerConstants.java b/src/com/android/packageinstaller/wear/InstallerConstants.java
new file mode 100644
index 00000000..3daf3d83
--- /dev/null
+++ b/src/com/android/packageinstaller/wear/InstallerConstants.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2016 The Android Open Source 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
+ */
+
+package com.android.packageinstaller.wear;
+
+/**
+ * Constants for Installation / Uninstallation requests.
+ * Using the same values as Finsky/Wearsky code for consistency in user analytics of failures
+ */
+public class InstallerConstants {
+    /** Request succeeded */
+    public static final int STATUS_SUCCESS = 0;
+
+    /**
+     * The new PackageInstaller also returns a small set of less granular error codes, which
+     * we'll remap to the range -500 and below to keep away from existing installer codes
+     * (which run from -1 to -110).
+     */
+    public final static int ERROR_PACKAGEINSTALLER_BASE = -500;
+
+    public static final int ERROR_COULD_NOT_GET_FD = -603;
+    /** This node is not targeted by this request. */
+
+    /** The install did not complete because could not create PackageInstaller session */
+    public final static int ERROR_INSTALL_CREATE_SESSION = -612;
+    /** The install did not complete because could not open PackageInstaller session  */
+    public final static int ERROR_INSTALL_OPEN_SESSION = -613;
+    /** The install did not complete because could not open PackageInstaller output stream */
+    public final static int ERROR_INSTALL_OPEN_STREAM = -614;
+    /** The install did not complete because of an exception while streaming bytes */
+    public final static int ERROR_INSTALL_COPY_STREAM_EXCEPTION = -615;
+    /** The install did not complete because of an unexpected exception from PackageInstaller */
+    public final static int ERROR_INSTALL_SESSION_EXCEPTION = -616;
+    /** The install did not complete because of an unexpected userActionRequired callback */
+    public final static int ERROR_INSTALL_USER_ACTION_REQUIRED = -617;
+    /** The install did not complete because of an unexpected broadcast (missing fields) */
+    public final static int ERROR_INSTALL_MALFORMED_BROADCAST = -618;
+    /** The install did not complete because of an error while copying from downloaded file */
+    public final static int ERROR_INSTALL_APK_COPY_FAILURE = -619;
+    /** The install did not complete because of an error while copying to the PackageInstaller
+     * output stream */
+    public final static int ERROR_INSTALL_COPY_STREAM = -620;
+    /** The install did not complete because of an error while closing the PackageInstaller
+     * output stream */
+    public final static int ERROR_INSTALL_CLOSE_STREAM = -621;
+}
\ No newline at end of file
diff --git a/src/com/android/packageinstaller/wear/PackageInstallerFactory.java b/src/com/android/packageinstaller/wear/PackageInstallerFactory.java
new file mode 100644
index 00000000..bdc22cf0
--- /dev/null
+++ b/src/com/android/packageinstaller/wear/PackageInstallerFactory.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2016 The Android Open Source 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
+ */
+
+package com.android.packageinstaller.wear;
+
+import android.content.Context;
+
+/**
+ * Factory that creates a Package Installer.
+ */
+public class PackageInstallerFactory {
+    private static PackageInstallerImpl sPackageInstaller;
+
+    /**
+     * Return the PackageInstaller shared object. {@code init} should have already been called.
+     */
+    public synchronized static PackageInstallerImpl getPackageInstaller(Context context) {
+        if (sPackageInstaller == null) {
+            sPackageInstaller = new PackageInstallerImpl(context);
+        }
+        return sPackageInstaller;
+    }
+}
\ No newline at end of file
diff --git a/src/com/android/packageinstaller/wear/PackageInstallerImpl.java b/src/com/android/packageinstaller/wear/PackageInstallerImpl.java
new file mode 100644
index 00000000..3dee7817
--- /dev/null
+++ b/src/com/android/packageinstaller/wear/PackageInstallerImpl.java
@@ -0,0 +1,324 @@
+/*
+ * Copyright (C) 2016 The Android Open Source 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
+ */
+
+package com.android.packageinstaller.wear;
+
+import android.annotation.TargetApi;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.IntentSender;
+import android.content.pm.PackageInstaller;
+import android.os.Build;
+import android.os.ParcelFileDescriptor;
+import android.util.Log;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Implementation of package manager installation using modern PackageInstaller api.
+ *
+ * Heavily copied from Wearsky/Finsky implementation
+ */
+@TargetApi(Build.VERSION_CODES.LOLLIPOP)
+public class PackageInstallerImpl {
+    private static final String TAG = "PackageInstallerImpl";
+
+    /** Intent actions used for broadcasts from PackageInstaller back to the local receiver */
+    private static final String ACTION_INSTALL_COMMIT =
+            "com.android.vending.INTENT_PACKAGE_INSTALL_COMMIT";
+
+    private final Context mContext;
+    private final PackageInstaller mPackageInstaller;
+    private final Map<String, PackageInstaller.SessionInfo> mSessionInfoMap;
+    private final Map<String, PackageInstaller.Session> mOpenSessionMap;
+
+    public PackageInstallerImpl(Context context) {
+        mContext = context.getApplicationContext();
+        mPackageInstaller = mContext.getPackageManager().getPackageInstaller();
+
+        // Capture a map of known sessions
+        // This list will be pruned a bit later (stale sessions will be canceled)
+        mSessionInfoMap = new HashMap<String, PackageInstaller.SessionInfo>();
+        List<PackageInstaller.SessionInfo> mySessions = mPackageInstaller.getMySessions();
+        for (int i = 0; i < mySessions.size(); i++) {
+            PackageInstaller.SessionInfo sessionInfo = mySessions.get(i);
+            String packageName = sessionInfo.getAppPackageName();
+            PackageInstaller.SessionInfo oldInfo = mSessionInfoMap.put(packageName, sessionInfo);
+
+            // Checking for old info is strictly for logging purposes
+            if (oldInfo != null) {
+                Log.w(TAG, "Multiple sessions for " + packageName + " found. Removing " + oldInfo
+                        .getSessionId() + " & keeping " + mySessions.get(i).getSessionId());
+            }
+        }
+        mOpenSessionMap = new HashMap<String, PackageInstaller.Session>();
+    }
+
+    /**
+     * This callback will be made after an installation attempt succeeds or fails.
+     */
+    public interface InstallListener {
+        /**
+         * This callback signals that preflight checks have succeeded and installation
+         * is beginning.
+         */
+        void installBeginning();
+
+        /**
+         * This callback signals that installation has completed.
+         */
+        void installSucceeded();
+
+        /**
+         * This callback signals that installation has failed.
+         */
+        void installFailed(int errorCode, String errorDesc);
+    }
+
+    /**
+     * This is a placeholder implementation that bundles an entire "session" into a single
+     * call. This will be replaced by more granular versions that allow longer session lifetimes,
+     * download progress tracking, etc.
+     *
+     * This must not be called on main thread.
+     */
+    public void install(final String packageName, ParcelFileDescriptor parcelFileDescriptor,
+            final InstallListener callback) {
+        // 0. Generic try/catch block because I am not really sure what exceptions (other than
+        // IOException) might be thrown by PackageInstaller and I want to handle them
+        // at least slightly gracefully.
+        try {
+            // 1. Create or recover a session, and open it
+            // Try recovery first
+            PackageInstaller.Session session = null;
+            PackageInstaller.SessionInfo sessionInfo = mSessionInfoMap.get(packageName);
+            if (sessionInfo != null) {
+                // See if it's openable, or already held open
+                session = getSession(packageName);
+            }
+            // If open failed, or there was no session, create a new one and open it.
+            // If we cannot create or open here, the failure is terminal.
+            if (session == null) {
+                try {
+                    innerCreateSession(packageName);
+                } catch (IOException ioe) {
+                    Log.e(TAG, "Can't create session for " + packageName + ": " + ioe.getMessage());
+                    callback.installFailed(InstallerConstants.ERROR_INSTALL_CREATE_SESSION,
+                            "Could not create session");
+                    mSessionInfoMap.remove(packageName);
+                    return;
+                }
+                sessionInfo = mSessionInfoMap.get(packageName);
+                try {
+                    session = mPackageInstaller.openSession(sessionInfo.getSessionId());
+                    mOpenSessionMap.put(packageName, session);
+                } catch (SecurityException se) {
+                    Log.e(TAG, "Can't open session for " + packageName + ": " + se.getMessage());
+                    callback.installFailed(InstallerConstants.ERROR_INSTALL_OPEN_SESSION,
+                            "Can't open session");
+                    mSessionInfoMap.remove(packageName);
+                    return;
+                }
+            }
+
+            // 2. Launch task to handle file operations.
+            InstallTask task = new InstallTask( mContext, packageName, parcelFileDescriptor,
+                    callback, session,
+                    getCommitCallback(packageName, sessionInfo.getSessionId(), callback));
+            task.execute();
+            if (task.isError()) {
+                cancelSession(sessionInfo.getSessionId(), packageName);
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "Unexpected exception while installing " + packageName);
+            callback.installFailed(InstallerConstants.ERROR_INSTALL_SESSION_EXCEPTION,
+                    "Unexpected exception while installing " + packageName);
+        }
+    }
+
+    /**
+     * Retrieve an existing session. Will open if needed, but does not attempt to create.
+     */
+    private PackageInstaller.Session getSession(String packageName) {
+        // Check for already-open session
+        PackageInstaller.Session session = mOpenSessionMap.get(packageName);
+        if (session != null) {
+            try {
+                // Probe the session to ensure that it's still open. This may or may not
+                // throw (if non-open), but it may serve as a canary for stale sessions.
+                session.getNames();
+                return session;
+            } catch (IOException ioe) {
+                Log.e(TAG, "Stale open session for " + packageName + ": " + ioe.getMessage());
+                mOpenSessionMap.remove(packageName);
+            } catch (SecurityException se) {
+                Log.e(TAG, "Stale open session for " + packageName + ": " + se.getMessage());
+                mOpenSessionMap.remove(packageName);
+            }
+        }
+        // Check to see if this is a known session
+        PackageInstaller.SessionInfo sessionInfo = mSessionInfoMap.get(packageName);
+        if (sessionInfo == null) {
+            return null;
+        }
+        // Try to open it. If we fail here, assume that the SessionInfo was stale.
+        try {
+            session = mPackageInstaller.openSession(sessionInfo.getSessionId());
+        } catch (SecurityException se) {
+            Log.w(TAG, "SessionInfo was stale for " + packageName + " - deleting info");
+            mSessionInfoMap.remove(packageName);
+            return null;
+        } catch (IOException ioe) {
+            Log.w(TAG, "IOException opening old session for " + ioe.getMessage()
+                    + " - deleting info");
+            mSessionInfoMap.remove(packageName);
+            return null;
+        }
+        mOpenSessionMap.put(packageName, session);
+        return session;
+    }
+
+    /** This version throws an IOException when the session cannot be created */
+    private void innerCreateSession(String packageName) throws IOException {
+        if (mSessionInfoMap.containsKey(packageName)) {
+            Log.w(TAG, "Creating session for " + packageName + " when one already exists");
+            return;
+        }
+        PackageInstaller.SessionParams params = new PackageInstaller.SessionParams(
+                PackageInstaller.SessionParams.MODE_FULL_INSTALL);
+        params.setAppPackageName(packageName);
+
+        // IOException may be thrown at this point
+        int sessionId = mPackageInstaller.createSession(params);
+        PackageInstaller.SessionInfo sessionInfo = mPackageInstaller.getSessionInfo(sessionId);
+        mSessionInfoMap.put(packageName, sessionInfo);
+    }
+
+    /**
+     * Cancel a session based on its sessionId. Package name is for logging only.
+     */
+    private void cancelSession(int sessionId, String packageName) {
+        // Close if currently held open
+        closeSession(packageName);
+        // Remove local record
+        mSessionInfoMap.remove(packageName);
+        try {
+            mPackageInstaller.abandonSession(sessionId);
+        } catch (SecurityException se) {
+            // The session no longer exists, so we can exit quietly.
+            return;
+        }
+    }
+
+    /**
+     * Close a session if it happens to be held open.
+     */
+    private void closeSession(String packageName) {
+        PackageInstaller.Session session = mOpenSessionMap.remove(packageName);
+        if (session != null) {
+            // Unfortunately close() is not idempotent. Try our best to make this safe.
+            try {
+                session.close();
+            } catch (Exception e) {
+                Log.w(TAG, "Unexpected error closing session for " + packageName + ": "
+                        + e.getMessage());
+            }
+        }
+    }
+
+    /**
+     * Creates a commit callback for the package install that's underway. This will be called
+     * some time after calling session.commit() (above).
+     */
+    private IntentSender getCommitCallback(final String packageName, final int sessionId,
+            final InstallListener callback) {
+        // Create a single-use broadcast receiver
+        BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                mContext.unregisterReceiver(this);
+                handleCommitCallback(intent, packageName, sessionId, callback);
+            }
+        };
+        // Create a matching intent-filter and register the receiver
+        String action = ACTION_INSTALL_COMMIT + "." + packageName;
+        IntentFilter intentFilter = new IntentFilter();
+        intentFilter.addAction(action);
+        mContext.registerReceiver(broadcastReceiver, intentFilter);
+
+        // Create a matching PendingIntent and use it to generate the IntentSender
+        Intent broadcastIntent = new Intent(action);
+        PendingIntent pendingIntent = PendingIntent.getBroadcast(mContext, packageName.hashCode(),
+                broadcastIntent, PendingIntent.FLAG_ONE_SHOT | PendingIntent.FLAG_UPDATE_CURRENT);
+        return pendingIntent.getIntentSender();
+    }
+
+    /**
+     * Examine the extras to determine information about the package update/install, decode
+     * the result, and call the appropriate callback.
+     *
+     * @param intent The intent, which the PackageInstaller will have added Extras to
+     * @param packageName The package name we created the receiver for
+     * @param sessionId The session Id we created the receiver for
+     * @param callback The callback to report success/failure to
+     */
+    private void handleCommitCallback(Intent intent, String packageName, int sessionId,
+            InstallListener callback) {
+        if (Log.isLoggable(TAG, Log.DEBUG)) {
+            Log.d(TAG, "Installation of " + packageName + " finished with extras "
+                    + intent.getExtras());
+        }
+        String statusMessage = intent.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE);
+        int status = intent.getIntExtra(PackageInstaller.EXTRA_STATUS, Integer.MIN_VALUE);
+        if (status == PackageInstaller.STATUS_SUCCESS) {
+            cancelSession(sessionId, packageName);
+            callback.installSucceeded();
+        } else if (status == -1 /*PackageInstaller.STATUS_USER_ACTION_REQUIRED*/) {
+            // TODO - use the constant when the correct/final name is in the SDK
+            // TODO This is unexpected, so we are treating as failure for now
+            cancelSession(sessionId, packageName);
+            callback.installFailed(InstallerConstants.ERROR_INSTALL_USER_ACTION_REQUIRED,
+                    "Unexpected: user action required");
+        } else {
+            cancelSession(sessionId, packageName);
+            int errorCode = getPackageManagerErrorCode(status);
+            Log.e(TAG, "Error " + errorCode + " while installing " + packageName + ": "
+                    + statusMessage);
+            callback.installFailed(errorCode, null);
+        }
+    }
+
+    private int getPackageManagerErrorCode(int status) {
+        // This is a hack: because PackageInstaller now reports error codes
+        // with small positive values, we need to remap them into a space
+        // that is more compatible with the existing package manager error codes.
+        // See https://sites.google.com/a/google.com/universal-store/documentation
+        //       /android-client/download-error-codes
+        int errorCode;
+        if (status == Integer.MIN_VALUE) {
+            errorCode = InstallerConstants.ERROR_INSTALL_MALFORMED_BROADCAST;
+        } else {
+            errorCode = InstallerConstants.ERROR_PACKAGEINSTALLER_BASE - status;
+        }
+        return errorCode;
+    }
+}
\ No newline at end of file
diff --git a/src/com/android/packageinstaller/wear/WearPackageArgs.java b/src/com/android/packageinstaller/wear/WearPackageArgs.java
index da49192a..2c289b2a 100644
--- a/src/com/android/packageinstaller/wear/WearPackageArgs.java
+++ b/src/com/android/packageinstaller/wear/WearPackageArgs.java
@@ -45,6 +45,8 @@ public class WearPackageArgs {
             "com.google.android.clockwork.EXTRA_KEY_COMPANION_DEVICE_VERSION";
     private static final String KEY_SHOULD_CHECK_GMS_DEPENDENCY =
             "com.google.android.clockwork.EXTRA_KEY_SHOULD_CHECK_GMS_DEPENDENCY";
+    private static final String KEY_SKIP_IF_LOWER_VERSION =
+            "com.google.android.clockwork.EXTRA_SKIP_IF_LOWER_VERSION";
 
     public static String getPackageName(Bundle b) {
         return b.getString(KEY_PACKAGE_NAME);
@@ -87,6 +89,10 @@ public class WearPackageArgs {
         return b.getInt(KEY_START_ID);
     }
 
+    public static boolean skipIfLowerVersion(Bundle b) {
+        return b.getBoolean(KEY_SKIP_IF_LOWER_VERSION, false);
+    }
+
     public static Bundle setStartId(Bundle b, int startId) {
         b.putInt(KEY_START_ID, startId);
         return b;
diff --git a/src/com/android/packageinstaller/wear/WearPackageInstallerService.java b/src/com/android/packageinstaller/wear/WearPackageInstallerService.java
index 7387ed2a..2d4744c2 100644
--- a/src/com/android/packageinstaller/wear/WearPackageInstallerService.java
+++ b/src/com/android/packageinstaller/wear/WearPackageInstallerService.java
@@ -22,7 +22,6 @@ import android.content.Context;
 import android.content.Intent;
 import android.content.pm.FeatureInfo;
 import android.content.pm.IPackageDeleteObserver;
-import android.content.pm.IPackageInstallObserver;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 import android.content.pm.PackageParser;
@@ -98,13 +97,6 @@ public class WearPackageInstallerService extends Service {
     private static final String SHOW_PERMS_SERVICE_CLASS =
             "com.google.android.clockwork.packagemanager.ShowPermsService";
 
-    /**
-     * Normally sent by the Play store (See http://go/playstore-gms_updated), we instead
-     * broadcast, ourselves. http://b/17387718
-     */
-    private static final String GMS_UPDATED_BROADCAST = "com.google.android.gms.GMS_UPDATED";
-    public static final String GMS_PACKAGE_NAME = "com.google.android.gms";
-
     private final int START_INSTALL = 1;
     private final int START_UNINSTALL = 2;
 
@@ -203,13 +195,15 @@ public class WearPackageInstallerService extends Service {
         int companionSdkVersion = WearPackageArgs.getCompanionSdkVersion(argsBundle);
         int companionDeviceVersion = WearPackageArgs.getCompanionDeviceVersion(argsBundle);
         String compressionAlg = WearPackageArgs.getCompressionAlg(argsBundle);
+        boolean skipIfLowerVersion = WearPackageArgs.skipIfLowerVersion(argsBundle);
 
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "Installing package: " + packageName + ", assetUri: " + assetUri +
                     ",permUri: " + permUri + ", startId: " + startId + ", checkPerms: " +
                     checkPerms + ", skipIfSameVersion: " + skipIfSameVersion +
                     ", compressionAlg: " + compressionAlg + ", companionSdkVersion: " +
-                    companionSdkVersion + ", companionDeviceVersion: " + companionDeviceVersion);
+                    companionSdkVersion + ", companionDeviceVersion: " + companionDeviceVersion +
+                    ", skipIfLowerVersion: " + skipIfLowerVersion);
         }
         final PackageManager pm = getPackageManager();
         File tempFile = null;
@@ -233,6 +227,12 @@ public class WearPackageInstallerService extends Service {
                     Log.d(TAG, "Replacing package:" + packageName);
                 }
             }
+            // TODO(28021618): This was left as a temp file due to the fact that this code is being
+            //       deprecated and that we need the bare minimum to continue working moving forward
+            //       If this code is used as reference, this permission logic might want to be
+            //       reworked to use a stream instead of a file so that we don't need to write a
+            //       file at all.  Note that there might be some trickiness with opening a stream
+            //       for multiple users.
             ParcelFileDescriptor parcelFd = getContentResolver()
                     .openFileDescriptor(assetUri, "r");
             tempFile = WearPackageUtil.getFileFromFd(WearPackageInstallerService.this,
@@ -268,9 +268,17 @@ public class WearPackageInstallerService extends Service {
                                 ") is equal to existing app for " + packageName);
                     }
                 } else if (existingPkgInfo.versionCode > pkg.mVersionCode) {
-                    Log.w(TAG, "Version number of new app (" + pkg.mVersionCode +
-                            ") is lower than existing app ( " + existingPkgInfo.versionCode +
-                            ") for " + packageName);
+                    if (skipIfLowerVersion) {
+                        // Starting in Feldspar, we are not going to allow downgrades of any app.
+                        Log.w(TAG, "Version number of new app (" + pkg.mVersionCode +
+                                ") is lower than existing app ( " + existingPkgInfo.versionCode +
+                                ") for " + packageName + "; not installing due to versionCheck");
+                        return;
+                    } else {
+                        Log.w(TAG, "Version number of new app (" + pkg.mVersionCode +
+                                ") is lower than existing app ( " + existingPkgInfo.versionCode +
+                                ") for " + packageName);
+                    }
                 }
 
                 // Following the Android Phone model, we should only check for permissions for any
@@ -318,9 +326,9 @@ public class WearPackageInstallerService extends Service {
             }
 
             // Finally install the package.
-            pm.installPackage(Uri.fromFile(tempFile),
-                    new PackageInstallObserver(this, lock, startId, packageName),
-                        installFlags, packageName);
+            ParcelFileDescriptor fd = getContentResolver().openFileDescriptor(assetUri, "r");
+            PackageInstallerFactory.getPackageInstaller(this).install(packageName, fd,
+                    new PackageInstallListener(this, lock, startId, packageName));
 
             messageSent = true;
             Log.i(TAG, "Sent installation request for " + packageName);
@@ -338,6 +346,10 @@ public class WearPackageInstallerService extends Service {
         }
     }
 
+    // TODO: This was left using the old PackageManager API due to the fact that this code is being
+    //       deprecated and that we need the bare minimum to continue working moving forward
+    //       If this code is used as reference, this logic should be reworked to use the new
+    //       PackageInstaller APIs similar to how installPackage was reworked
     private void uninstallPackage(Bundle argsBundle) {
         int startId = WearPackageArgs.getStartId(argsBundle);
         final String packageName = WearPackageArgs.getPackageName(argsBundle);
@@ -558,12 +570,12 @@ public class WearPackageInstallerService extends Service {
         }
     }
 
-    private class PackageInstallObserver extends IPackageInstallObserver.Stub {
+    private class PackageInstallListener implements PackageInstallerImpl.InstallListener {
         private Context mContext;
         private PowerManager.WakeLock mWakeLock;
         private int mStartId;
         private String mApplicationPackageName;
-        private PackageInstallObserver(Context context, PowerManager.WakeLock wakeLock,
+        private PackageInstallListener(Context context, PowerManager.WakeLock wakeLock,
                 int startId, String applicationPackageName) {
             mContext = context;
             mWakeLock = wakeLock;
@@ -571,35 +583,33 @@ public class WearPackageInstallerService extends Service {
             mApplicationPackageName = applicationPackageName;
         }
 
-        public void packageInstalled(String packageName, int returnCode) {
-            try {
-                // If installation failed, bail out and remove the ShowPermsStore entry
-                if (returnCode < 0) {
-                    Log.e(TAG, "Package install failed " + mApplicationPackageName
-                            + ", returnCode " + returnCode);
-                    WearPackageUtil.removeFromPermStore(mContext, mApplicationPackageName);
-                    return;
-                }
+        @Override
+        public void installBeginning() {
+            Log.i(TAG, "Package " + mApplicationPackageName + " is being installed.");
+        }
 
-                Log.i(TAG, "Package " + packageName + " was installed.");
+        @Override
+        public void installSucceeded() {
+            try {
+                Log.i(TAG, "Package " + mApplicationPackageName + " was installed.");
 
                 // Delete tempFile from the file system.
-                File tempFile = WearPackageUtil.getTemporaryFile(mContext, packageName);
+                File tempFile = WearPackageUtil.getTemporaryFile(mContext, mApplicationPackageName);
                 if (tempFile != null) {
                     tempFile.delete();
                 }
-
-                // Broadcast the "UPDATED" gmscore intent, normally sent by play store.
-                // TODO: Remove this broadcast if/when we get the play store to do this for us.
-                if (GMS_PACKAGE_NAME.equals(packageName)) {
-                    Intent gmsInstalledIntent = new Intent(GMS_UPDATED_BROADCAST);
-                    gmsInstalledIntent.setPackage(GMS_PACKAGE_NAME);
-                    mContext.sendBroadcast(gmsInstalledIntent);
-                }
             } finally {
                 finishService(mWakeLock, mStartId);
             }
         }
+
+        @Override
+        public void installFailed(int errorCode, String errorDesc) {
+            Log.e(TAG, "Package install failed " + mApplicationPackageName
+                    + ", errorCode " + errorCode);
+            WearPackageUtil.removeFromPermStore(mContext, mApplicationPackageName);
+            finishService(mWakeLock, mStartId);
+        }
     }
 
     private class PackageDeleteObserver extends IPackageDeleteObserver.Stub {