/*
* Copyright (C)
20
24 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 obta
in a copy of the License at
*
* http
://www.apache.org/licenses/LICENSE-
2.0
*
* Unless required by applicable law or agreed to
in writ
ing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY K
IND, either express or implied.
* See the License for the specific language govern
ing permissions and
* limitations under the License.
*/
package com.android.server.p
inner;
import static android.app.ActivityManager.UID_OBSERVER_ACTIVE;
import static android.app.ActivityManager.UID_OBSERVER_GONE;
import static android.os.Process.SYSTEM_UID;
import static com.android.server.flags.Flags.p
inGlobalQuota;
import static com.android.server.flags.Flags.p
inWebview;
import android.annotation.EnforcePermission;
import android.annotation.
IntDef;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.app.ActivityManager;
import android.app.ActivityManager
Internal;
import android.app.IActivityManager;
import android.app.UidObserver;
import android.app.p
inner.IP
innerService;
import android.app.p
inner.P
inned
FileStat;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.
Intent;
import android.content.
IntentFilter;
import android.content.pm.Activity
Info;
import android.content.pm.Application
Info;
import android.content.pm.PackageManager;
import android.content.pm.Resolve
Info;
import android.database.ContentObserver;
import android.net.Uri;
import android.os.B
inder;
import android.os.Build;
import android.os.Handler;
import android.os.HandlerExecutor;
import android.os.Looper;
import android.os.Message;
import android.os.Process;
import android.os.RemoteException;
import android.os.ResultReceiver;
import android.os.ShellCallback;
import android.os.SystemProperties;
import android.os.UserHandle;
import android.os.UserManager;
import android.provider.Device
Config;
import android.provider.Device
ConfigInterface;
import android.provider.MediaStore;
import android.provider.Sett
ings;
import android.system.ErrnoException;
import android.system.Os;
import android.system.OsConstants;
import android.util.ArrayMap;
import android.util.ArraySet;
import android.util.Slog;
import com.android.
internal.annotations.GuardedBy;
import com.android.
internal.annotations.VisibleForTest
ing;
import com.android.
internal.app.ResolverActivity;
import com.android.
internal.os.BackgroundThread;
import com.android.
internal.util.DumpUtils;
import com.android.
internal.util.function.pooled.PooledLambda;
import com.android.server.LocalServices;
import com.android.server.SystemService;
import com.android.server.wm.ActivityTaskManager
Internal;
import dalvik.system.DexFile;
import dalvik.system.VMRuntime;
import system.ext.loader.core.ExtLoader;
import java.io.FileDescriptor;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.
InputStream;
import java.io.Pr
intWriter;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import sun.misc.Unsafe;
// #ifdef OPLUS_EXTENSION_HOOK
// Haoran.Xu@ROM.Framework,
20
21/07/1
2, Modify for ALM
:1770593
import com.android.server.IP
innerServiceExt;
// #endif /* OPLUS_EXTENSION_HOOK */
/**
* <p>P
innerService p
ins
important files for key processes
in memory.</p>
* <p>
Files to p
in are specified
in the
config_defaultP
innerService
Files
* overlay.</p>
* <p>P
in the default camera application if specified
in config_p
innerCameraApp.</p>
* <p>(Optional) P
in experimental carveout regions based on Device
Config flags.</p>
*/
public f
inal class P
innerService extends SystemService {
private static f
inal boolean DEBUG = false;
private static f
inal Str
ing TAG = "P
innerService";
private static f
inal Str
ing P
IN_META_FILENAME = "p
inlist.meta";
private static f
inal
int PAGE_SIZE = (
int) Os.sysconf(OsConstants._SC_PAGESIZE);
private static f
inal
int MATCH_FLAGS = PackageManager.MATCH_DEFAULT_ONLY
| PackageManager.MATCH_DIRECT_BOOT_AWARE | PackageManager.MATCH_DIRECT_BOOT_UNAWARE;
private static f
inal
int KEY_CAMERA = 0;
private static f
inal
int KEY_HOME = 1;
private static f
inal
int KEY_ASSISTANT =
2;
// P
in us
ing p
inlist.meta when p
inn
ing apps.
private static boolean PROP_P
IN_P
INLIST =
SystemProperties.getBoolean("p
inner.use_p
inlist", true);
public static f
inal Str
ing ANON_REGION_STAT_NAME = "[anon]";
private static f
inal Str
ing SYSTEM_GROUP_NAME = "system";
@
IntDef({KEY_CAMERA, KEY_HOME, KEY_ASSISTANT})
@Retention(RetentionPolicy.SOURCE)
public @
interface AppKey {}
private f
inal Context mContext;
private f
inal
Injector m
Injector;
private f
inal Device
ConfigInterface mDevice
ConfigInterface;
private f
inal ActivityTaskManager
Internal mAtm
Internal;
private f
inal ActivityManager
Internal mAm
Internal;
private f
inal IActivityManager mAm;
private f
inal UserManager mUserManager;
/** The list of the statically p
inned
files. */
@GuardedBy("this")
private f
inal ArrayMap<Str
ing, P
innedFile> mP
inned
Files = new ArrayMap<>();
/** The list of the p
inned apps. This is a map from {@l
ink AppKey} to a p
inned app. */
@GuardedBy("this")
private f
inal ArrayMap<
Integer, P
innedApp> mP
innedApps = new ArrayMap<>();
/**
* The list of the p
inned apps that
need to be rep
inned as soon as the all processes of a given
* uid are no longer active. Note that with background dex opt, the new dex/vdex
files are only
* loaded
into the processes once it restarts. So
in case background dex opt recompiled these
*
files, we still
need to keep the old ones p
inned until the processes restart.
* <p>
* This is a map from uid to {@l
ink AppKey}
*/
@GuardedBy("this")
private f
inal ArrayMap<
Integer,
Integer> mPend
ingRep
in = new ArrayMap<>();
/**
* A set of {@l
ink AppKey} that are
configured to be p
inned.
*/
@GuardedBy("this") private
ArraySet<
Integer> mP
inKeys;
// Note that we don't use the `_BOOT` namespace for anonymous p
inn
ings, as we want
// them to be responsive to dynamic flag changes for experimentation.
private static f
inal Str
ing DEVICE_
CONFIG_NAMESPACE_ANON_SIZE =
Device
Config.NAMESPACE_RUNTIME_NATIVE;
private static f
inal Str
ing DEVICE_
CONFIG_KEY_ANON_SIZE = "p
in_shared_anon_size";
private static f
inal long DEFAULT_ANON_SIZE =
SystemProperties.getLong("p
inner.p
in_shared_anon_size", 0);
private static f
inal long MAX_ANON_SIZE =
2L * (1L << 30); //
2GB
private long mP
inAnonSize;
private long mP
inAnonAddress;
private long mCurrentlyP
innedAnonSize;
// Resource-
configured p
inner flags;
private f
inal boolean m
ConfiguredToP
inCamera;
private f
inal
int m
ConfiguredCameraP
inBytes;
private f
inal
int m
ConfiguredHomeP
inBytes;
private f
inal boolean m
ConfiguredToP
inAssistant;
private f
inal
int m
ConfiguredAssistantP
inBytes;
private f
inal
int m
ConfiguredWebviewP
inBytes;
// This is the percentage of total device memory that will be used to set the global quota.
private f
inal
int m
ConfiguredMaxP
innedMemoryPercentage;
// This is the global p
inner quota that can be p
inned.
private long m
ConfiguredMaxP
innedMemory;
// This is the currently p
inned memory.
private long mCurrentP
innedMemory = 0;
private B
inderService mB
inderService;
private P
innerHandler mP
innerHandler = null;
// #ifdef OPLUS_EXTENSION_HOOK
// Haoran.Xu@ROM.Framework,
20
21/07/1
2, Modify for ALM
:1770593
public IP
innerServiceExt mP
innerServiceExt = ExtLoader.type(IP
innerServiceExt.class).create();
// #endif /* OPLUS_EXTENSION_HOOK */
private f
inal BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context,
Intent
intent) {
// If an app has updated, update p
inned
files accord
ingly.
if (
Intent.ACTION_PACKAGE_REPLACED.equals(
intent.getAction())) {
Uri packageUri =
intent.getData();
Str
ing packageName = packageUri.getSchemeSpecificPart();
ArraySet<Str
ing> updatedPackages = new ArraySet<>();
updatedPackages.add(packageName);
update(updatedPackages, true /* force */);
}
}
};
private f
inal Device
Config.OnPropertiesChangedListener mDevice
ConfigAnonSizeListener =
new Device
Config.OnPropertiesChangedListener() {
@Override
public void onPropertiesChanged(Device
Config.Properties properties) {
if (DEVICE_
CONFIG_NAMESPACE_ANON_SIZE.equals(properties.getNamespace())
&& properties.getKeyset().conta
ins(DEVICE_
CONFIG_KEY_ANON_SIZE)) {
refreshP
inAnon
Config();
}
}
};
/** Utility class for test
ing. */
@VisibleForTest
ing
public static class
Injector {
protected Device
ConfigInterface getDevice
ConfigInterface() {
return Device
ConfigInterface.REAL;
}
protected void publishB
inderService(P
innerService service, B
inder b
inderService) {
service.publishB
inderService("p
inner", b
inderService);
}
protected P
innedFile p
inFile
Internal(P
innerService service, Str
ing fileToP
in,
long maxBytesToP
in, boolean attemptP
inIntrospection) {
return service.p
inFile
Internal(fileToP
in, maxBytesToP
in, attemptP
inIntrospection);
}
}
public P
innerService(Context context) {
this(context, new
Injector());
}
@VisibleForTest
ing
public P
innerService(Context context,
Injector
injector) {
super(context);
mContext = context;
m
Injector =
injector;
mDevice
ConfigInterface = m
Injector.getDevice
ConfigInterface();
m
ConfiguredToP
inCamera = context.getResources().getBoolean(
com.android.
internal.R.bool.
config_p
innerCameraApp);
m
ConfiguredCameraP
inBytes = context.getResources().get
Integer(
com.android.
internal.R.
integer.
config_p
innerCameraP
inBytes);
m
ConfiguredAssistantP
inBytes = context.getResources().get
Integer(
com.android.
internal.R.
integer.
config_p
innerAssistantP
inBytes);
m
ConfiguredHomeP
inBytes = context.getResources().get
Integer(
com.android.
internal.R.
integer.
config_p
innerHomeP
inBytes);
m
ConfiguredToP
inAssistant = context.getResources().getBoolean(
com.android.
internal.R.bool.
config_p
innerAssistantApp);
m
ConfiguredWebviewP
inBytes = context.getResources().get
Integer(
com.android.
internal.R.
integer.
config_p
innerWebviewP
inBytes);
m
ConfiguredMaxP
innedMemoryPercentage = context.getResources().get
Integer(
com.android.
internal.R.
integer.
config_p
innerMaxP
innedMemoryPercentage);
mP
inKeys = createP
inKeys();
mP
innerHandler = new P
innerHandler(BackgroundThread.get().getLooper());
mAtm
Internal = LocalServices.getService(ActivityTaskManager
Internal.class);
mAm
Internal = LocalServices.getService(ActivityManager
Internal.class);
mAm = ActivityManager.getService();
mUserManager = mContext.getSystemService(UserManager.class);
IntentFilter filter = new
IntentFilter();
filter.addAction(
Intent.ACTION_PACKAGE_REPLACED);
filter.addDataScheme("package");
mContext.registerReceiver(mBroadcastReceiver, filter);
registerUidListener();
registerUserSetupCompleteListener();
mDevice
ConfigInterface.addOnPropertiesChangedListener(DEVICE_
CONFIG_NAMESPACE_ANON_SIZE,
new HandlerExecutor(mP
innerHandler), mDevice
ConfigAnonSizeListener);
}
@Override
public void onStart() {
if (DEBUG) {
Slog.i(TAG, "Start
ing P
innerService");
}
m
ConfiguredMaxP
innedMemory =
(Process.getTotalMemory()
* Math.clamp(m
ConfiguredMaxP
innedMemoryPercentage, 0, 100))
/ 100;
mB
inderService = new B
inderService();
m
Injector.publishB
inderService(this, mB
inderService);
publishLocalService(P
innerService.class, this);
mP
innerHandler.obta
inMessage(P
innerHandler.P
IN_ONSTART_MSG).sendToTarget();
sendP
inAppsMessage(UserHandle.USER_SYSTEM);
}
/**
* Rep
in apps on user switch.
* <p>
* If more than one user is us
ing the device each user may set a different preference for the
*
individual apps. Make sure that user's preference is p
inned
into memory.
*/
@Override
public void onUserSwitch
ing(@Nullable TargetUser from, @NonNull TargetUser to) {
int userId = to.getUserIdentifier();
if (!mUserManager.isManagedProfile(userId)) {
sendP
inAppsMessage(userId);
}
}
@Override
public void onUserUnlock
ing(@NonNull TargetUser user) {
f
inal
int userId = user.getUserIdentifier();
if (userId != UserHandle.USER_SYSTEM && !mUserManager.isManagedProfile(userId)) {
// App p
inn
ing for the system should have already been triggered from onStart().
sendP
inAppsMessage(userId);
}
}
/**
* Update the currently p
inned
files.
* Specifically, this only updates p
inn
ing for the apps that
need to be p
inned.
* The other
files p
inned
in onStart will not
need to be updated.
*/
public void update(ArraySet<Str
ing> updatedPackages, boolean force) {
ArraySet<
Integer> p
inKeys = getP
inKeys();
int currentUser = ActivityManager.getCurrentUser();
for (
int i = p
inKeys.size() - 1; i >= 0; i--) {
int key = p
inKeys.valueAt(i);
Application
Info
info = get
InfoForKey(key, currentUser);
if (
info != null && updatedPackages.conta
ins(
info.packageName)) {
Slog.i(TAG, "
Updating p
inned
files for " +
info.packageName + " force=" + force);
sendP
inAppMessage(key, currentUser, force);
}
}
// #ifdef OPLUS_EXTENSION_HOOK
// Haoran.Xu@ROM.Framework,
20
21/07/1
2, Modify for ALM
:1770593
mP
innerServiceExt.updateExt(updatedPackages, force);
// #endif /* OPLUS_EXTENSION_HOOK */
}
/** Returns
information about p
inned
files and sizes for StatsPullAtomService. */
public List<P
inned
FileStats> dumpDataForStatsd() {
List<P
inned
FileStats> p
inned
FileStats = new ArrayList<>();
synchronized (P
innerService.this) {
for (P
innedFile p
innedFile
: mP
inned
Files.values()) {
p
inned
FileStats.add(new P
inned
FileStats(SYSTEM_UID, p
innedFile));
}
for (
int key
: mP
innedApps.keySet()) {
P
innedApp app = mP
innedApps.get(key);
for (P
innedFile p
innedFile
: mP
innedApps.get(key).m
Files) {
p
inned
FileStats.add(new P
inned
FileStats(app.uid, p
innedFile));
}
}
}
return p
inned
FileStats;
}
/** Wrapper class for statistics for a p
inned file. */
public static class P
inned
FileStats {
public f
inal
int uid;
public f
inal Str
ing filename;
public f
inal
int sizeKb;
protected P
inned
FileStats(
int uid, P
innedFile file) {
this.uid = uid;
this.filename = file.fileName.substr
ing(file.fileName.last
IndexOf('/') + 1);
this.sizeKb = (
int) file.bytesP
inned / 10
24;
}
}
/**
* Handler for on start p
inn
ing message
*/
private void handleP
inOnStart() {
//
Files to p
in come from the overlay and can be specified per-device
config
Str
ing[]
filesToP
in = mContext.getResources().getStr
ingArray(
com.android.
internal.R.array.
config_defaultP
innerService
Files);
// #ifdef OPLUS_EXTENSION_HOOK
// Chucheng.Ye@ANDROID.RESCONTROL,
20
21/08/03, add for customize p
inner file.
filesToP
in = mP
innerServiceExt.replaceDefault
Files(
filesToP
in);
// #endif /* OPLUS_EXTENSION_HOOK */
// Cont
inue try
ing to p
in each file even if we fail to p
in some of them
for (Str
ing fileToP
in : filesToP
in) {
p
inFile(fileToP
in,
Integer.MAX_VALUE, /*app
Info=*/null, /*groupName=*/SYSTEM_GROUP_NAME,
true);
}
refreshP
inAnon
Config();
}
/**
* Registers a listener to rep
in the home app when user setup is complete, as the home
intent
*
initially resolves to setup wizard, but once setup is complete, it will resolve to the
* regular home app.
*/
private void registerUserSetupCompleteListener() {
Uri userSetupCompleteUri = Sett
ings.Secure.getUriFor(Sett
ings.Secure.USER_SETUP_COMPLETE);
mContext.getContentResolver().registerContentObserver(
userSetupCompleteUri, false, new ContentObserver(null) {
@Override
public void onChange(boolean selfChange, Uri uri) {
if (userSetupCompleteUri.equals(uri)) {
if (m
ConfiguredHomeP
inBytes > 0) {
sendP
inAppMessage(KEY_HOME, ActivityManager.getCurrentUser(),
true /* force */);
}
}
}
}, UserHandle.USER_ALL);
}
private void registerUidListener() {
try {
mAm.registerUidObserver(new UidObserver() {
@Override
public void onUidGone(
int uid, boolean disabled) {
mP
innerHandler.sendMessage(PooledLambda.obta
inMessage(
P
innerService
::handleUidGone, P
innerService.this, uid));
}
@Override
public void onUidActive(
int uid) {
mP
innerHandler.sendMessage(PooledLambda.obta
inMessage(
P
innerService
::handleUidActive, P
innerService.this, uid));
}
}, UID_OBSERVER_GONE | UID_OBSERVER_ACTIVE, 0, null);
} catch (RemoteException e) {
Slog.e(TAG, "Failed to register uid observer", e);
}
}
private void handleUidGone(
int uid) {
updateActiveState(uid, false /* active */);
int key;
synchronized (this) {
//
In case we have a pend
ing rep
in, rep
in now. See mPend
ingRep
in for more
information.
key = mPend
ingRep
in.getOrDefault(uid, -1);
if (key == -1) {
return;
}
mPend
ingRep
in.remove(uid);
}
p
inApp(key, ActivityManager.getCurrentUser(), false /* force */);
}
private void handleUidActive(
int uid) {
updateActiveState(uid, true /* active */);
}
private void updateActiveState(
int uid, boolean active) {
synchronized (this) {
for (
int i = mP
innedApps.size() - 1; i >= 0; i--) {
P
innedApp app = mP
innedApps.valueAt(i);
if (app.uid == uid) {
app.active = active;
}
}
}
}
private void unp
inApps() {
ArraySet<
Integer> p
inKeys = getP
inKeys();
for (
int i = p
inKeys.size() - 1; i >= 0; i--) {
int key = p
inKeys.valueAt(i);
unp
inApp(key);
}
}
private void unp
inApp(@AppKey
int key) {
ArrayList<P
innedFile> p
innedApp
Files;
synchronized (this) {
P
innedApp app = mP
innedApps.get(key);
if (app == null) {
return;
}
mP
innedApps.remove(key);
p
innedApp
Files = new ArrayList<>(app.m
Files);
}
for (P
innedFile p
innedFile
: p
innedApp
Files) {
unp
inFile(p
innedFile.fileName);
}
}
private boolean isResolverActivity(Activity
Info
info) {
return ResolverActivity.class.getName().equals(
info.name);
}
public
int getWebviewP
inQuota() {
if (!p
inWebview()) {
return 0;
}
int quota = m
ConfiguredWebviewP
inBytes;
int overrideQuota = SystemProperties.get
Int("p
inner.p
in_webview_size", -1);
if (overrideQuota != -1) {
// Quota was overridden
quota = overrideQuota;
}
return quota;
}
private Application
Info getCamera
Info(
int userHandle) {
Intent camera
Intent = new
Intent(MediaStore.
INTENT_ACTION_STILL_IMAGE_CAMERA);
Application
Info
info = getApplication
InfoFor
Intent(
camera
Intent, userHandle, false /* defaultToSystemApp */);
// If the STILL_IMAGE_CAMERA
intent doesn't resolve, try the _SECURE
intent.
// We don't use _SECURE first because it will never get set on a device
// without File-based Encryption. But if the user has only set the
intent
// before unlock
ing their device, we may still be able to identify their
// preference us
ing this
intent.
if (
info == null) {
camera
Intent = new
Intent(MediaStore.
INTENT_ACTION_STILL_IMAGE_CAMERA_SECURE);
info = getApplication
InfoFor
Intent(
camera
Intent, userHandle, false /* defaultToSystemApp */);
}
// If the _SECURE
intent doesn't resolve, try the orig
inal
intent but request
// the system app for camera if there was more than one result.
if (
info == null) {
camera
Intent = new
Intent(MediaStore.
INTENT_ACTION_STILL_IMAGE_CAMERA);
info = getApplication
InfoFor
Intent(
camera
Intent, userHandle, true /* defaultToSystemApp */);
}
return
info;
}
private Application
Info getHome
Info(
int userHandle) {
Intent
intent = mAtm
Internal.getHome
Intent();
return getApplication
InfoFor
Intent(
intent, userHandle, false);
}
private Application
Info getAssistant
Info(
int userHandle) {
Intent
intent = new
Intent(
Intent.ACTION_ASSIST);
return getApplication
InfoFor
Intent(
intent, userHandle, true);
}
private Application
Info getApplication
InfoFor
Intent(
Intent
intent,
int userHandle, boolean defaultToSystemApp) {
if (
intent == null) {
return null;
}
Resolve
Info resolve
Info =
mContext.getPackageManager().resolveActivityAsUser(
intent, MATCH_FLAGS, userHandle);
// If this
intent can resolve to only one app, choose that one.
// Otherwise, if we've requested to default to the system app, return it;
// if we have not requested that default, return null if there's more than one option.
// If there's more than one system app, return null s
ince we don't know which to pick.
if (resolve
Info == null) {
return null;
}
if (!isResolverActivity(resolve
Info.activity
Info)) {
return resolve
Info.activity
Info.application
Info;
}
if (defaultToSystemApp) {
List<Resolve
Info>
infoList = mContext.getPackageManager().query
IntentActivitiesAsUser(
intent, MATCH_FLAGS, userHandle);
Application
Info systemApp
Info = null;
for (Resolve
Info
info
: infoList) {
if ((
info.activity
Info.application
Info.flags & Application
Info.FLAG_SYSTEM) != 0) {
if (systemApp
Info == null) {
systemApp
Info =
info.activity
Info.application
Info;
} else {
// If there's more than one system app, return null due to ambiguity.
return null;
}
}
}
return systemApp
Info;
}
return null;
}
private void sendP
inAppsMessage(
int userHandle) {
mP
innerHandler.sendMessage(
PooledLambda.obta
inMessage(P
innerService
::p
inApps, this, userHandle));
}
private void sendP
inAppsWithUpdatedKeysMessage(
int userHandle) {
mP
innerHandler.sendMessage(PooledLambda.obta
inMessage(
P
innerService
::p
inAppsWithUpdatedKeys, this, userHandle));
}
private void sendUnp
inAppsMessage() {
mP
innerHandler.sendMessage(PooledLambda.obta
inMessage(P
innerService
::unp
inApps, this));
}
private ArraySet<
Integer> createP
inKeys() {
ArraySet<
Integer> p
inKeys = new ArraySet<>();
// P
in the camera application. Default to the system property only if the experiment
// phenotype property is not set.
boolean shouldP
inCamera = m
ConfiguredToP
inCamera
&& mDevice
ConfigInterface.getBoolean(Device
Config.NAMESPACE_RUNTIME_NATIVE_BOOT,
"p
in_camera", SystemProperties.getBoolean("p
inner.p
in_camera", true));
if (shouldP
inCamera) {
p
inKeys.add(KEY_CAMERA);
} else if (DEBUG) {
Slog.i(TAG, "P
inner - skip p
inn
ing camera app");
}
if (m
ConfiguredHomeP
inBytes > 0) {
p
inKeys.add(KEY_HOME);
}
if (m
ConfiguredToP
inAssistant) {
p
inKeys.add(KEY_ASSISTANT);
}
return p
inKeys;
}
private synchronized ArraySet<
Integer> getP
inKeys() {
return mP
inKeys;
}
private void p
inApps(
int userHandle) {
p
inApps
Internal(userHandle, false);
}
private void p
inAppsWithUpdatedKeys(
int userHandle) {
p
inApps
Internal(userHandle, true);
}
/**
* @param updateKeys True if the p
inned app list has to be updated. This is true only when
* "p
inner rep
in" shell command is requested.
*/
private void p
inApps
Internal(
int userHandle, boolean updateKeys) {
if (updateKeys) {
ArraySet<
Integer> newKeys = createP
inKeys();
synchronized (this) {
// This code path demands preced
ing unp
inApps() call.
if (!mP
innedApps.isEmpty()) {
Slog.e(TAG,
"Attempted to update a list of apps, "
+ "but apps were already p
inned. Skipp
ing.");
return;
}
mP
inKeys = newKeys;
}
}
ArraySet<
Integer> currentP
inKeys = getP
inKeys();
for (
int i = currentP
inKeys.size() - 1; i >= 0; i--) {
int key = currentP
inKeys.valueAt(i);
p
inApp(key, userHandle, true /* force */);
}
}
/**
* @see #p
inApp(
int,
int, boolean)
*/
private void sendP
inAppMessage(
int key,
int userHandle, boolean force) {
mP
innerHandler.sendMessage(
PooledLambda.obta
inMessage(P
innerService
::p
inApp, this, key, userHandle, force));
}
/**
* P
ins an app of a specific type {@code key}.
*
* @param force If false, this will not rep
in the app if it's currently active. See
* {@l
ink #mPend
ingRep
in}.
*/
private void p
inApp(
int key,
int userHandle, boolean force) {
int uid = getUidForKey(key);
//
In case the app is currently active, don't rep
in until next process restart. See
// mPend
ingRep
in for more
information.
if (!force && uid != -1) {
synchronized (this) {
mPend
ingRep
in.put(uid, key);
}
return;
}
Application
Info
info = get
InfoForKey(key, userHandle);
unp
inApp(key);
if (
info != null) {
p
inApp
Internal(key,
info);
}
}
/**
* Checks whether the p
inned package with {@code key} is active or not.
* @return The uid of the p
inned app, or {@code -1} otherwise.
*/
private
int getUidForKey(@AppKey
int key) {
synchronized (this) {
P
innedApp exist
ing = mP
innedApps.get(key);
return exist
ing != null && exist
ing.active ? exist
ing.uid
: -1;
}
}
/**
* Retrieves the current application
info for the given app type.
*
* @param key The app type to retrieve the
info for.
* @param userHandle The user id of the current user.
*/
private @Nullable Application
Info get
InfoForKey(@AppKey
int key,
int userHandle) {
switch (key) {
case KEY_CAMERA
:
return getCamera
Info(userHandle);
case KEY_HOME
:
return getHome
Info(userHandle);
case KEY_ASSISTANT
:
return getAssistant
Info(userHandle);
default
:
return null;
}
}
/**
* @return The app type name for {@code key}.
*/
private Str
ing getNameForKey(@AppKey
int key) {
switch (key) {
case KEY_CAMERA
:
return "Camera";
case KEY_HOME
:
return "Home";
case KEY_ASSISTANT
:
return "Assistant";
default
:
return "";
}
}
/**
* Handle any changes
in the anon region p
inner
config.
*/
private void refreshP
inAnon
Config() {
long newP
inAnonSize = mDevice
ConfigInterface.getLong(
DEVICE_
CONFIG_NAMESPACE_ANON_SIZE, DEVICE_
CONFIG_KEY_ANON_SIZE, DEFAULT_ANON_SIZE);
newP
inAnonSize = Math.max(0, Math.m
in(newP
inAnonSize, MAX_ANON_SIZE));
if (newP
inAnonSize != mP
inAnonSize) {
mP
inAnonSize = newP
inAnonSize;
p
inAnonRegion();
}
}
/**
* P
in an empty anonymous region. This should only be used for ablation experiments.
*/
private void p
inAnonRegion() {
if (mP
inAnonSize == 0) {
Slog.d(TAG, "p
inAnonRegion
: releas
ing p
inned region");
unp
inAnonRegion();
return;
}
long alignedP
inSize = mP
inAnonSize;
if (alignedP
inSize % PAGE_SIZE != 0) {
alignedP
inSize -= alignedP
inSize % PAGE_SIZE;
Slog.e(TAG, "p
inAnonRegion
: align
ing size to " + alignedP
inSize);
}
if (mP
inAnonAddress != 0) {
if (mCurrentlyP
innedAnonSize == alignedP
inSize) {
Slog.d(TAG, "p
inAnonRegion
: already p
inned region of size " + alignedP
inSize);
return;
}
Slog.d(TAG, "p
inAnonRegion
: resett
ing p
inned region for new size " + alignedP
inSize);
unp
inAnonRegion();
}
long address = 0;
try {
// Map as SHARED to avoid chang
ing rss.anon for system_server (per /proc/*/status).
// The mapp
ing is visible
in other rss metrics, and as private dirty
in smaps/mem
info.
address = Os.mmap(0, alignedP
inSize, OsConstants.PROT_READ | OsConstants.PROT_WRITE,
OsConstants.MAP_SHARED | OsConstants.MAP_ANONYMOUS, new FileDescriptor(),
/*offset=*/0);
Unsafe tempUnsafe = null;
Class<sun.misc.Unsafe> clazz = sun.misc.Unsafe.class;
for (java.lang.reflect.Field f
: clazz.getDeclaredFields()) {
f.setAccessible(true);
Object obj = f.get(null);
if (clazz.is
Instance(obj)) {
tempUnsafe = clazz.cast(obj);
}
}
if (tempUnsafe == null) {
throw new Exception("Couldn't get Unsafe");
}
Method setMemory = clazz.getMethod("setMemory", long.class, long.class, byte.class);
setMemory.
invoke(tempUnsafe, address, alignedP
inSize, (byte) 1);
Os.mlock(address, alignedP
inSize);
mCurrentlyP
innedAnonSize = alignedP
inSize;
mP
inAnonAddress = address;
address = -1;
Slog.w(TAG, "p
inAnonRegion success, size=" + mCurrentlyP
innedAnonSize);
} catch (Exception ex) {
Slog.e(TAG, "Could not p
in anon region of size " + alignedP
inSize, ex);
return;
} f
inally {
if (address >= 0) {
P
innerUtils.safeMunmap(address, alignedP
inSize);
}
}
}
private void unp
inAnonRegion() {
if (mP
inAnonAddress != 0) {
P
innerUtils.safeMunmap(mP
inAnonAddress, mCurrentlyP
innedAnonSize);
}
mP
inAnonAddress = 0;
mCurrentlyP
innedAnonSize = 0;
}
/**
* @return The maximum amount of bytes to be p
inned for an app of type {@code key}.
*/
private
int getSizeLimitForKey(@AppKey
int key) {
switch (key) {
case KEY_CAMERA
:
return m
ConfiguredCameraP
inBytes;
case KEY_HOME
:
return m
ConfiguredHomeP
inBytes;
case KEY_ASSISTANT
:
return m
ConfiguredAssistantP
inBytes;
default
:
return 0;
}
}
/**
* Retrieves rema
ining quota for p
inner service, once it reaches 0 it will no longer
* p
in any file.
*/
private long getAvailableGlobalQuota() {
return m
ConfiguredMaxP
innedMemory - mCurrentP
innedMemory;
}
/**
* P
ins an application.
*
* @param key The key of the app to p
in.
* @param app
Info The correspond
ing app
info.
*/
private void p
inApp
Internal(@AppKey
int key, @Nullable Application
Info app
Info) {
if (app
Info == null) {
return;
}
P
innedApp p
innedApp = new P
innedApp(app
Info);
synchronized (this) {
mP
innedApps.put(key, p
innedApp);
}
// p
in APK
f
inal
int p
inSizeLimit = getSizeLimitForKey(key);
List<Str
ing> apks = new ArrayList<>();
apks.add(app
Info.sourceDir);
if (app
Info.splitSourceDirs != null) {
for (Str
ing splitApk
: app
Info.splitSourceDirs) {
apks.add(splitApk);
}
}
long apkP
inSizeLimit = p
inSizeLimit;
for (Str
ing apk
: apks) {
if (apkP
inSizeLimit <= 0) {
Slog.w(TAG, "Reached to the p
in size limit. Skipp
ing
: " + apk);
// Cont
inue
instead of break to pr
int all skipped APK names.
cont
inue;
}
Str
ing p
inGroup = getNameForKey(key);
boolean shouldP
inDeps = apk.equals(app
Info.sourceDir);
P
innedFile pf = p
inFile(apk, apkP
inSizeLimit, app
Info, p
inGroup, shouldP
inDeps);
if (pf == null) {
Slog.e(TAG, "Failed to p
in " + apk);
cont
inue;
}
if (DEBUG) {
Slog.i(TAG, "P
inned " + pf.fileName);
}
synchronized (this) {
p
innedApp.m
Files.add(pf);
}
apkP
inSizeLimit -= pf.bytesP
inned;
}
}
/**
* P
in file or apk to memory.
*
* Prefer to use this method
instead of {@l
ink #p
inFile
Internal(Str
ing,
int, boolean)} as it
* takes care of account
ing and if p
inn
ing an apk, it also p
ins any extra optimized art
files
* that related to the file but not with
in itself.
*
* @param fileToP
in File to p
in
* @param bytesRequestedToP
in maximum bytes requested to p
in for {@code fileToP
in}.
* @param p
inOptimizedDeps whether optimized dependencies such as odex,vdex, etc be p
inned.
* Note
: {@code bytesRequestedToP
in} limit will not apply to optimized
* dependencies p
inned, only global quotas will apply
instead.
* @return p
inned file
*/
public P
innedFile p
inFile(Str
ing fileToP
in, long bytesRequestedToP
in,
@Nullable Application
Info app
Info, @Nullable Str
ing groupName,
boolean p
inOptimizedDeps) {
P
innedFile exist
ingP
in;
synchronized (this) {
exist
ingP
in = mP
inned
Files.get(fileToP
in);
}
if (exist
ingP
in != null) {
if (exist
ingP
in.bytesP
inned == bytesRequestedToP
in) {
// Duplicate p
in request
ing same amount of bytes, lets just bail out.
return null;
} else {
// User decided to p
in a different amount of bytes than currently p
inned
// so this is a valid p
in request. Unp
in the previous version before rep
ining.
if (DEBUG) {
Slog.d(TAG, "Unp
inn
ing file prior to rep
in: " + fileToP
in);
}
unp
inFile(fileToP
in);
}
}
long rema
iningQuota = getAvailableGlobalQuota();
if (p
inGlobalQuota()) {
if (rema
iningQuota <= 0) {
Slog.w(TAG, "Reached p
in quota, skipp
ing file
: " + fileToP
in);
return null;
}
bytesRequestedToP
in = Math.m
in(bytesRequestedToP
in, rema
iningQuota);
}
boolean isApk = fileToP
in.endsWith(".apk");
P
innedFile pf = m
Injector.p
inFile
Internal(this, fileToP
in, bytesRequestedToP
in,
/*attemptP
inIntrospection=*/isApk);
if (pf == null) {
Slog.e(TAG, "Failed to p
in file = " + fileToP
in);
return null;
}
pf.groupName = groupName != null ? groupName
: "";
mCurrentP
innedMemory += pf.bytesP
inned;
synchronized (this) {
mP
inned
Files.put(pf.fileName, pf);
}
if (p
inOptimizedDeps) {
mCurrentP
innedMemory +=
p
inOptimizedDexDependencies(pf, getAvailableGlobalQuota(), app
Info);
}
return pf;
}
/**
* P
in any dependency optimized
files generated by ART.
* @param p
innedFile An already p
inned file whose dependencies we want p
inned.
* @param maxBytesToP
in Maximum amount of bytes to p
in.
* @param app
Info Used to determ
ine the ABI
in case the application has one custom set, when set
* to null it will use the default supported ABI by the device.
* @return total bytes p
inned.
*/
private long p
inOptimizedDexDependencies(
P
innedFile p
innedFile, long maxBytesToP
in, @Nullable Application
Info app
Info) {
if (p
innedFile == null) {
return 0;
}
long bytesP
inned = 0;
if (p
innedFile.fileName.endsWith(".jar") | p
innedFile.fileName.endsWith(".apk")) {
Str
ing abi = null;
if (app
Info != null) {
abi = app
Info.primaryCpuAbi;
}
if (abi == null) {
abi = Build.SUPPORTED_ABIS[0];
}
// Check whether the runtime has compilation artifacts to p
in.
Str
ing arch = VMRuntime.get
InstructionSet(abi);
Str
ing[]
files = null;
try {
files = DexFile.getDexFileOutputPaths(p
innedFile.fileName, arch);
} catch (IOException ioe) {
}
if (
files == null) {
return bytesP
inned;
}
for (Str
ing file
: files) {
// Unp
in if it was already p
inned prior to re-p
inn
ing.
unp
inFile(file);
P
innedFile df = m
Injector.p
inFile
Internal(this, file, maxBytesToP
in,
/*attemptP
inIntrospection=*/false);
if (df == null) {
Slog.i(TAG, "Failed to p
in ART file = " + file);
return bytesP
inned;
}
df.groupName = p
innedFile.groupName;
p
innedFile.p
innedDeps.add(df);
maxBytesToP
in -= df.bytesP
inned;
bytesP
inned += df.bytesP
inned;
synchronized (this) {
mP
inned
Files.put(df.fileName, df);
}
}
}
return bytesP
inned;
}
/**
* mlock length bytes of fileToP
in in memory
*
* If attemptP
inIntrospection is true, then treat the file to p
in as a zip file and
* look for a "p
inlist.meta" file
in the archive root directory. The structure of this
* file is a P
INLIST_META as described below
:
*
* <pre>
* P
INLIST_META
: P
IN_RANGE*
* P
IN_RANGE
: P
IN_START P
IN_LENGTH
* P
IN_START
: big endian i3
2: offset
in bytes of p
in region from file start
* P
IN_LENGTH
: big endian i3
2: length of p
in region
in bytes
* </pre>
*
* (We use big endian because that's what Data
InputStream is hardcoded to use.)
*
* If attemptP
inIntrospection is false, then we use a s
ingle implicit P
IN_RANGE of (0,
* maxBytesToP
in); that is, we attempt to p
in the first maxBytesToP
in bytes of the file.
*
* After we open a file, we march through the list of p
in ranges and attempt to p
in
* each one, stopp
ing after we've p
inned maxBytesToP
in bytes. (We may truncate the last
* p
inned range to fit.)
In this way, by choos
ing to emit certa
in P
IN_RANGE pairs
* before others, file generators can express p
ins
in priority order, mak
ing most
* effective use of the p
inned-page quota.
*
* N.B. Each P
IN_RANGE is clamped to the actual bounds of the file; all
inputs have a
* mean
ingful
interpretation. Also, a range lock
ing a s
ingle byte of a page locks the
* whole page. Any truncated P
IN_RANGE at EOF is ignored. Overlapp
ing p
inned entries
* are legal, but each p
in of a byte counts toward the p
in quota regardless of whether
* that byte has already been p
inned, so the generator of P
INLIST_META ought to ensure
* that ranges are non-overlapp
ing.
*
* @param fileToP
in Path to file to p
in
* @param maxBytesToP
in Maximum number of bytes to p
in
* @param attemptP
inIntrospection If true, try to open file as a
* zip
in order to extract the
* @return P
inned memory resource owner th
ing or null on error
*/
private P
innedFile p
inFile
Internal(
Str
ing fileToP
in, long maxBytesToP
in, boolean attemptP
inIntrospection) {
if (DEBUG) {
Slog.d(TAG, "p
in file
: " + fileToP
in + " use-p
inlist
: " + attemptP
inIntrospection);
}
ZipFile fileAsZip = null;
InputStream p
inRangeStream = null;
try {
if (attemptP
inIntrospection) {
fileAsZip = maybeOpenZip(fileToP
in);
}
if (fileAsZip != null) {
p
inRangeStream = maybeOpenP
inMeta
InZip(fileAsZip, fileToP
in);
}
boolean use_p
inlist = (p
inRangeStream != null);
P
inRangeSource p
inRangeSource = use_p
inlist
? new P
inRangeSourceStream(p
inRangeStream)
: new P
inRangeSourceStatic(0,
Integer.MAX_VALUE /* will be clipped */);
P
innedFile p
innedFile = p
inFileRanges(fileToP
in, maxBytesToP
in, p
inRangeSource);
if (p
innedFile != null) {
p
innedFile.used_p
inlist = use_p
inlist;
}
return p
innedFile;
} f
inally {
P
innerUtils.safeClose(p
inRangeStream);
P
innerUtils.safeClose(fileAsZip); // Also closes any streams we've opened
}
}
/**
* Attempt to open a file as a zip file. On any sort of corruption, log, swallow the
* error, and return null.
*/
private static ZipFile maybeOpenZip(Str
ing fileName) {
ZipFile zip = null;
try {
zip = new ZipFile(fileName);
} catch (IOException ex) {
Slog.w(TAG, Str
ing.format("could not open \"%s\" as zip
: p
inn
ing as blob", fileName),
ex);
}
return zip;
}
/**
* Open a p
in metadata file
in the zip if one is present.
*
* @param zipFile Zip file to search
* @return Open
input stream or null on any error
*/
private static
InputStream maybeOpenP
inMeta
InZip(ZipFile zipFile, Str
ing fileName) {
if (!PROP_P
IN_P
INLIST) {
if (DEBUG) {
Slog.i(TAG, "P
in - skip p
inlist.meta
in " + fileName);
}
return null;
}
// Look
ing at root directory is the old behavior but still some apps rely on it so keep
ing
// for backward compatibility. As do
ing a s
ingle item lookup is cheap
in the root.
ZipEntry p
inMetaEntry = zipFile.getEntry(P
IN_META_FILENAME);
if (p
inMetaEntry == null) {
// It is usually with
in an apk's control to
include
files in assets/ directory
// so this would be the expected po
int to have the p
inlist.meta com
ing from.
// we explicitly avoid do
ing an exhaustive search because it may be expensive so
// prefer to have a good known location to retrieve the file.
p
inMetaEntry = zipFile.getEntry("assets/" + P
IN_META_FILENAME);
}
InputStream p
inMetaStream = null;
if (p
inMetaEntry != null) {
if (DEBUG) {
Slog.d(TAG, "Found p
inlist.meta for " + fileName);
}
try {
p
inMetaStream = zipFile.get
InputStream(p
inMetaEntry);
} catch (IOException ex) {
Slog.w(TAG,
Str
ing.format(
"error read
ing p
in metadata \"%s\"
: p
inn
ing as blob", fileName),
ex);
}
} else {
Slog.w(TAG,
Str
ing.format(
"Could not f
ind p
inlist.meta for \"%s\"
: p
inn
ing as blob", fileName));
}
return p
inMetaStream;
}
/**
* Helper for p
inFile.
*
* @param fileToP
in Name of file to p
in
* @param maxBytesToP
in Maximum number of bytes to p
in
* @param p
inRangeSource Read P
IN_RANGE entries from this stream to tell us what bytes
* to p
in.
* @return P
innedFile or null on error
*/
private static P
innedFile p
inFileRanges(
Str
ing fileToP
in, long maxBytesToP
in, P
inRangeSource p
inRangeSource) {
FileDescriptor fd = new FileDescriptor();
long address = -1;
long mapSize = 0;
try {
int openFlags = (OsConstants.O_RDONLY | OsConstants.O_CLOEXEC);
fd = Os.open(fileToP
in, openFlags, 0);
mapSize = (
int) Math.m
in(Os.fstat(fd).st_size,
Integer.MAX_VALUE);
address = Os.mmap(
0, mapSize, OsConstants.PROT_READ, OsConstants.MAP_SHARED, fd, /*offset=*/0);
P
inRange p
inRange = new P
inRange();
long bytesP
inned = 0;
// We p
in at page granularity, so make sure the limit is page-aligned
if (maxBytesToP
in % PAGE_SIZE != 0) {
maxBytesToP
in -= maxBytesToP
in % PAGE_SIZE;
}
while (bytesP
inned < maxBytesToP
in && p
inRangeSource.read(p
inRange)) {
long p
inStart = p
inRange.start;
long p
inLength = p
inRange.length;
p
inStart = P
innerUtils.clamp(0, p
inStart, mapSize);
p
inLength = P
innerUtils.clamp(0, p
inLength, mapSize - p
inStart);
p
inLength = Math.m
in(maxBytesToP
in - bytesP
inned, p
inLength);
// mlock doesn't require the region to be page-aligned, but we snap the
// lock region to page boundaries anyway so that we don't under-count
// lock
ing a s
ingle byte of a page as a charge of one byte even though the
// OS will reta
in the whole page. Thanks to this adjustment, we slightly
// over-count the p
in charge of back-to-back p
ins touch
ing the same page,
// but better that than undercount
ing. Besides
: noth
ing stops p
in metafile
// creators from mak
ing the actual regions page-aligned.
p
inLength += p
inStart % PAGE_SIZE;
p
inStart -= p
inStart % PAGE_SIZE;
if (p
inLength % PAGE_SIZE != 0) {
p
inLength += PAGE_SIZE - p
inLength % PAGE_SIZE;
}
p
inLength = P
innerUtils.clamp(0, p
inLength, maxBytesToP
in - bytesP
inned);
if (p
inLength > 0) {
if (DEBUG) {
Slog.d(TAG,
Str
ing.format("p
inn
ing at %s %s bytes of %s", p
inStart, p
inLength,
fileToP
in));
}
Os.mlock(address + p
inStart, p
inLength);
}
bytesP
inned += p
inLength;
}
P
innedFile p
innedFile = new P
innedFile(address, mapSize, fileToP
in, bytesP
inned);
address = -1; // Ownership transferred
return p
innedFile;
} catch (ErrnoException ex) {
Slog.e(TAG, "Could not p
in file " + fileToP
in, ex);
return null;
} f
inally {
P
innerUtils.safeClose(fd);
if (address >= 0) {
P
innerUtils.safeMunmap(address, mapSize);
}
}
}
private List<P
innedFile> getAllP
insForGroup(Str
ing group) {
List<P
innedFile>
filesInGroup;
synchronized (this) {
filesInGroup = mP
inned
Files.values()
.stream()
.filter(pf -> pf.groupName.equals(group))
.toList();
}
return
filesInGroup;
}
public void unp
inGroup(Str
ing group) {
List<P
innedFile> p
inned
Files = getAllP
insForGroup(group);
for (P
innedFile pf
: p
inned
Files) {
unp
inFile(pf.fileName);
}
}
/**
* Unp
in a file and its optimized dependencies.
*
* @param filename file to unp
in.
* @return number of bytes unp
inned, 0
in case of failure or noth
ing to unp
in.
*/
public long unp
inFile(Str
ing filename) {
P
innedFile p
innedFile;
synchronized (this) {
p
innedFile = mP
inned
Files.get(filename);
}
if (p
innedFile == null) {
// File not p
inned, noth
ing to do.
return 0;
}
long unp
innedBytes = p
innedFile.bytesP
inned;
p
innedFile.close();
synchronized (this) {
if (DEBUG) {
Slog.d(TAG, "Unp
inned file
: " + filename);
}
mCurrentP
innedMemory -= p
innedFile.bytesP
inned;
mP
inned
Files.remove(p
innedFile.fileName);
for (P
innedFile dep
: p
innedFile.p
innedDeps) {
if (dep == null) {
cont
inue;
}
unp
innedBytes -= dep.bytesP
inned;
mCurrentP
innedMemory -= dep.bytesP
inned;
mP
inned
Files.remove(dep.fileName);
if (DEBUG) {
Slog.d(TAG, "Unp
inned dependency
: " + dep.fileName);
}
}
}
return unp
innedBytes;
}
public List<P
inned
FileStat> getP
innerStats() {
ArrayList<P
inned
FileStat> stats = new ArrayList<>();
Collection<P
innedFile> p
inned
Files;
synchronized (this) {
p
inned
Files = mP
inned
Files.values();
}
for (P
innedFile pf
: p
inned
Files) {
P
inned
FileStat stat = new P
inned
FileStat(pf.fileName, pf.bytesP
inned, pf.groupName);
stats.add(stat);
}
if (mCurrentlyP
innedAnonSize > 0) {
stats.add(new P
inned
FileStat(
ANON_REGION_STAT_NAME, mCurrentlyP
innedAnonSize, ANON_REGION_STAT_NAME));
}
return stats;
}
public f
inal class B
inderService extends IP
innerService.Stub {
@Override
protected void dump(FileDescriptor fd, Pr
intWriter pw, Str
ing[] args) {
if (!DumpUtils.checkDumpPermission(mContext, TAG, pw))
return;
HashSet<P
innedFile> shownP
ins = new HashSet<>();
HashSet<Str
ing> shownGroups = new HashSet<>();
HashSet<Str
ing> groupsToPr
int = new HashSet<>();
f
inal double bytesPerMB = 10
24 * 10
24;
pw.format("P
inner
Configs
:\n");
pw.format(" Total P
inner quota
: %d%% of total device memory\n",
m
ConfiguredMaxP
innedMemoryPercentage);
pw.format(" Maximum P
inner quota
: %d bytes (%.
2f MB)\n", m
ConfiguredMaxP
innedMemory,
m
ConfiguredMaxP
innedMemory / bytesPerMB);
pw.format(" Max Home App P
in Bytes (without deps)
: %d (%.
2f MB)\n",
m
ConfiguredHomeP
inBytes, m
ConfiguredHomeP
inBytes / bytesPerMB);
pw.format(" Max Assistant App P
in Bytes (without deps)
: %d (%.
2f MB)\n",
m
ConfiguredAssistantP
inBytes, m
ConfiguredAssistantP
inBytes / bytesPerMB);
pw.format(
" Max Camera App P
in Bytes (without deps)
: %d (%.
2f MB)\n",
m
ConfiguredCameraP
inBytes, m
ConfiguredCameraP
inBytes / bytesPerMB);
pw.format("\nP
inned
Files:\n");
synchronized (P
innerService.this) {
long totalSize = 0;
// We pr
int apps separately from regular p
ins as they conta
in extra
information that
// other p
ins do not.
for (
int key
: mP
innedApps.keySet()) {
P
innedApp app = mP
innedApps.get(key);
pw.pr
int(getNameForKey(key));
pw.pr
int(" uid=");
pw.pr
int(app.uid);
pw.pr
int(" active=");
pw.pr
int(app.active);
if (!app.m
Files.isEmpty()) {
shownGroups.add(app.m
Files.getFirst().groupName);
}
pw.pr
intln();
long bytesP
innedForApp = 0;
long bytesP
innedForAppDeps = 0;
for (P
innedFile pf
: mP
innedApps.get(key).m
Files) {
pw.pr
int(" ");
pw.format("%s p
inned
:%d bytes (%.
2f MB) p
inlist
:%b\n", pf.fileName,
pf.bytesP
inned, pf.bytesP
inned / bytesPerMB, pf.used_p
inlist);
totalSize += pf.bytesP
inned;
bytesP
innedForApp += pf.bytesP
inned;
shownP
ins.add(pf);
for (P
innedFile dep
: pf.p
innedDeps) {
pw.pr
int(" ");
pw.format("%s p
inned
:%d bytes (%.
2f MB) p
inlist
:%b (Dependency)\n",
dep.fileName, dep.bytesP
inned, dep.bytesP
inned / bytesPerMB,
dep.used_p
inlist);
totalSize += dep.bytesP
inned;
bytesP
innedForAppDeps += dep.bytesP
inned;
shownP
ins.add(dep);
}
}
long bytesP
innedForAppAndDeps = bytesP
innedForApp + bytesP
innedForAppDeps;
pw.format("Total P
inned = %d (%.
2f MB) [App=%d (%.
2f MB), "
+ "Dependencies=%d (%.
2f MB)]\n\n",
bytesP
innedForAppAndDeps, bytesP
innedForAppAndDeps / bytesPerMB,
bytesP
innedForApp, bytesP
innedForApp / bytesPerMB,
bytesP
innedForAppDeps, bytesP
innedForAppDeps / bytesPerMB);
}
pw.pr
intln();
for (P
innedFile p
innedFile
: mP
inned
Files.values()) {
if (!groupsToPr
int.conta
ins(p
innedFile.groupName)
&& !shownGroups.conta
ins(p
innedFile.groupName)) {
groupsToPr
int.add(p
innedFile.groupName);
}
}
// Pr
int all the non app groups.
for (Str
ing group
: groupsToPr
int) {
List<P
innedFile> groupP
ins = getAllP
insForGroup(group);
pw.pr
int("\nGroup
:" + group);
long bytesP
innedForGroupNoDeps = 0;
long bytesP
innedForGroupDeps = 0;
pw.pr
intln();
for (P
innedFile p
innedFile
: groupP
ins) {
if (shownP
ins.conta
ins(p
innedFile)) {
// Already displayed and accounted for, skip.
cont
inue;
}
pw.format(" %s p
inned
: %d bytes (%.
2f MB) p
inlist
:%b\n",
p
innedFile.fileName, p
innedFile.bytesP
inned,
p
innedFile.bytesP
inned / bytesPerMB, p
innedFile.used_p
inlist);
totalSize += p
innedFile.bytesP
inned;
bytesP
innedForGroupNoDeps += p
innedFile.bytesP
inned;
shownP
ins.add(p
innedFile);
for (P
innedFile dep
: p
innedFile.p
innedDeps) {
if (shownP
ins.conta
ins(dep)) {
// Already displayed and accounted for, skip.
cont
inue;
}
pw.pr
int(" ");
pw.format("%s p
inned
:%d bytes (%.
2f MB) p
inlist
:%b (Dependency)\n",
dep.fileName, dep.bytesP
inned, dep.bytesP
inned / bytesPerMB,
dep.used_p
inlist);
totalSize += dep.bytesP
inned;
bytesP
innedForGroupDeps += dep.bytesP
inned;
shownP
ins.add(dep);
}
}
long bytesP
innedForGroup = bytesP
innedForGroupNoDeps + bytesP
innedForGroupDeps;
pw.format("Total P
inned = %d (%.
2f MB) [Ma
in=%d (%.
2f MB), "
+ "Dependencies=%d (%.
2f MB)]\n\n",
bytesP
innedForGroup, bytesP
innedForGroup / bytesPerMB,
bytesP
innedForGroupNoDeps, bytesP
innedForGroupNoDeps / bytesPerMB,
bytesP
innedForGroupDeps, bytesP
innedForGroupDeps / bytesPerMB);
}
pw.pr
intln();
if (mP
inAnonAddress != 0) {
pw.format("P
inned anon region
: %d (%.
2f MB)\n", mCurrentlyP
innedAnonSize,
mCurrentlyP
innedAnonSize / bytesPerMB);
totalSize += mCurrentlyP
innedAnonSize;
}
pw.format("Total p
inned
: %d bytes (%.
2f MB)\n", totalSize, totalSize / bytesPerMB);
pw.format("Available P
inner quota
: %d bytes (%.
2f MB)\n", getAvailableGlobalQuota(),
getAvailableGlobalQuota() / bytesPerMB);
pw.pr
intln();
if (!mPend
ingRep
in.isEmpty()) {
pw.pr
int("Pend
ing rep
in: ");
for (
int key
: mPend
ingRep
in.values()) {
pw.pr
int(getNameForKey(key));
pw.pr
int(' ');
}
pw.pr
intln();
}
}
}
private void rep
in() {
sendUnp
inAppsMessage();
// TODO(morrita)
: Consider support
ing non-system user.
sendP
inAppsWithUpdatedKeysMessage(UserHandle.USER_SYSTEM);
}
private void pr
intError(FileDescriptor out, Str
ing message) {
Pr
intWriter writer = new Pr
intWriter(new FileOutputStream(out));
writer.pr
intln(message);
writer.flush();
}
@Override
public void onShellCommand(FileDescriptor
in, FileDescriptor out, FileDescriptor err,
Str
ing[] args, ShellCallback callback, ResultReceiver resultReceiver) {
if (args.length < 1) {
pr
intError(out, "Command is not given.");
resultReceiver.send(-1, null);
return;
}
Str
ing command = args[0];
switch (command) {
case "rep
in"
:
rep
in();
break;
default
:
pr
intError(out,
Str
ing.format("Unknown p
inner command
: %s. Supported commands
: rep
in",
command));
resultReceiver.send(-1, null);
return;
}
resultReceiver.send(0, null);
}
@EnforcePermission(android.Manifest.permission.DUMP)
@Override
public List<P
inned
FileStat> getP
innerStats() {
getP
innerStats_enforcePermission();
return P
innerService.this.getP
innerStats();
}
}
f
inal static class P
inRange {
int start;
int length;
}
/**
* Represents an app that was p
inned.
*/
private f
inal class P
innedApp {
/**
* The uid of the package be
ing p
inned. This stays constant while the package stays
*
installed.
*/
f
inal
int uid;
/** Whether it is currently active, i.e. there is a runn
ing process from that package. */
boolean active;
/** List of p
inned
files. */
f
inal ArrayList<P
innedFile> m
Files = new ArrayList<>();
private P
innedApp(Application
Info app
Info) {
uid = app
Info.uid;
active = mAm
Internal.isUidActive(uid);
}
}
f
inal class P
innerHandler extends Handler {
static f
inal
int P
IN_ONSTART_MSG = 4001;
public P
innerHandler(Looper looper) {
super(looper, null, true);
}
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case P
IN_ONSTART_MSG
: {
handleP
inOnStart();
} break;
default
:
super.handleMessage(msg);
}
}
}
}
我想改这个java文件 在p
inOptimizedDexDependencies函数中加上
files = DexFile.getDexFileOutputPaths(p
innedFile.fileName, arch); 打印出所有的dex file文件名 并且看一下dex文件是否p
in成功 这个push到手机里面去验证 加上日志打印
扫一扫
503
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
