diff options
Diffstat (limited to 'src')
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 { |