/*
* Copyright (C) 2024
The Andro
id Open Source Project
*
* Licensed under
the Apache License, Version 2
.0 (
the "License");
* you may
not use th
is 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
* d
istributed under
the License
is d
istributed on an "AS
IS" BAS
IS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, ei
ther express or implied
.
* See
the License for
the specific language governing perm
issions and
* limitations under
the License
.
*/
package com
.andro
id.server
.pinner;
import static andro
id.app
.ActivityManager
.U
ID_OBSERVER_ACTIVE;
import static andro
id.app
.ActivityManager
.U
ID_OBSERVER_GONE;
import static andro
id.os
.Process
.SYSTEM_U
ID;
import static com
.andro
id.server
.flags
.Flags
.pinGlobalQuota;
import static com
.andro
id.server
.flags
.Flags
.pinWebview;
import andro
id.an
notation
.EnforcePerm
ission;
import andro
id.an
notation
.IntDef;
import andro
id.an
notation
.NonNull;
import andro
id.an
notation
.Nullable;
import andro
id.app
.ActivityManager;
import andro
id.app
.ActivityManagerInternal;
import andro
id.app
.IActivityManager;
import andro
id.app
.U
idObserver;
import andro
id.app
.pinner
.IPinnerService;
import andro
id.app
.pinner
.PinnedFileStat;
import andro
id.content
.BroadcastReceiver;
import andro
id.content
.Context;
import andro
id.content
.Intent;
import andro
id.content
.IntentFilter;
import andro
id.content
.pm
.ActivityInfo;
import andro
id.content
.pm
.ApplicationInfo;
import andro
id.content
.pm
.PackageManager;
import andro
id.content
.pm
.ResolveInfo;
import andro
id.database
.ContentObserver;
import andro
id.net
.Uri;
import andro
id.os
.Binder;
import andro
id.os
.Build;
import andro
id.os
.Handler;
import andro
id.os
.HandlerExecutor;
import andro
id.os
.Looper;
import andro
id.os
.Message;
import andro
id.os
.Process;
import andro
id.os
.RemoteException;
import andro
id.os
.ResultReceiver;
import andro
id.os
.ShellCallback;
import andro
id.os
.SystemProperties;
import andro
id.os
.UserHandle;
import andro
id.os
.UserManager;
import andro
id.prov
ider
.DeviceConfig;
import andro
id.prov
ider
.DeviceConfigInterface;
import andro
id.prov
ider
.MediaStore;
import andro
id.prov
ider
.Settings;
import andro
id.system
.Err
noException;
import andro
id.system
.Os;
import andro
id.system
.OsConstants;
import andro
id.util
.ArrayMap;
import andro
id.util
.ArraySet;
import andro
id.util
.Slog;
import com
.andro
id.internal
.an
notations
.GuardedBy;
import com
.andro
id.internal
.an
notations
.V
isibleForTesting;
import com
.andro
id.internal
.app
.ResolverActivity;
import com
.andro
id.internal
.os
.BackgroundThread;
import com
.andro
id.internal
.util
.DumpUtils;
import com
.andro
id.internal
.util
.function
.pooled
.PooledLambda;
import com
.andro
id.server
.LocalServices;
import com
.andro
id.server
.SystemService;
import com
.andro
id.server
.wm
.ActivityTaskManagerInternal;
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
.PrintWriter;
import java
.lang
.an
notation
.Retention;
import java
.lang
.an
notation
.RetentionPolicy;
import java
.lang
.reflect
.Method;
import java
.util
.ArrayL
ist;
import java
.util
.Collection;
import java
.util
.HashSet;
import java
.util
.L
ist;
import java
.util
.zip
.ZipEntry;
import java
.util
.zip
.ZipFile;
import sun
.m
isc
.Unsafe;
// #ifdef OPLUS_EXTENSION_HOOK
// Haoran
.Xu@ROM
.Framework, 2021/07/12, Modify for ALM
:1770593
import com
.andro
id.server
.IPinnerServiceExt;
// #endif /* OPLUS_EXTENSION_HOOK */
/**
* <p>PinnerService pins important files for key processes in memory
.</p>
* <p>Files to pin are specified in
the config_defaultPinnerServiceFiles
* overlay
.</p>
* <p>Pin
the default camera application if specified in config_pinnerCameraApp
.</p>
* <p>(Optional) Pin experimental carveout regions based on DeviceConfig flags
.</p>
*/
public final class PinnerService extends SystemService {
private static final boolean DEBUG = false;
private static final String TAG = "PinnerService";
private static final String PIN_META_FILE
NAME = "pinl
ist
.meta";
private static final int PAGE_SIZE = (int) Os
.sysconf(OsConstants
._SC_PAGESIZE);
private static final int MATCH_FLAGS = PackageManager
.MATCH_DEFAULT_ONLY
| PackageManager
.MATCH_DIRECT_BOOT_AWARE | PackageManager
.MATCH_DIRECT_BOOT_UNAWARE;
private static final int KEY_CAMERA = 0;
private static final int KEY_HOME = 1;
private static final int KEY_ASS
ISTANT = 2;
// Pin using pinl
ist
.meta when pinning apps
.
private static boolean PROP_PIN_PINL
IST =
SystemProperties
.getBoolean("pinner
.use_pinl
ist", true);
public static final String A
NON_REGION_STAT_
NAME = "[a
non]";
private static final String SYSTEM_GROUP_
NAME = "system";
@IntDef({KEY_CAMERA, KEY_HOME, KEY_ASS
ISTANT})
@Retention(RetentionPolicy
.SOURCE)
public @interface AppKey {}
private final Context mContext;
private final Injector mInjector;
private final DeviceConfigInterface mDeviceConfigInterface;
private final ActivityTaskManagerInternal mAtmInternal;
private final ActivityManagerInternal mAmInternal;
private final IActivityManager mAm;
private final
UserManager m
UserManager;
/**
The l
ist of
the statically pinned files
. */
@GuardedBy("th
is")
private final ArrayMap<String, PinnedFile> mPinnedFiles = new ArrayMap<>();
/**
The l
ist of
the pinned apps
. Th
is is a map from {@link AppKey} to a pinned app
. */
@GuardedBy("th
is")
private final ArrayMap<Integer, PinnedApp> mPinnedApps = new ArrayMap<>();
/**
*
The l
ist of
the pinned apps that need to be repinned as soon as
the all processes of a given
* u
id 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 pinned until
the processes restart
.
* <p>
* Th
is is a map from u
id to {@link AppKey}
*/
@GuardedBy("th
is")
private final ArrayMap<Integer, Integer> mPendingRepin = new ArrayMap<>();
/**
* A set of {@link AppKey} that are configured to be pinned
.
*/
@GuardedBy("th
is") private
ArraySet<Integer> mPinKeys;
//
Note that we don't use
the `_BOOT`
namespace for
anonymous pinnings, as we want
//
them to be responsive to dynamic flag changes for experimentation
.
private static final String DEVICE_CONFIG_
NAMESPACE_A
NON_SIZE =
DeviceConfig
.NAMESPACE_RUNTIME_NATIVE;
private static final String DEVICE_CONFIG_KEY_A
NON_SIZE = "pin_shared_a
non_size";
private static final long DEFAULT_A
NON_SIZE =
SystemProperties
.getLong("pinner
.pin_shared_a
non_size", 0);
private static final long MAX_A
NON_SIZE = 2L * (1L << 30); // 2GB
private long mPinA
nonSize;
private long mPinA
nonAddress;
private long mCurrentlyPinnedA
nonSize;
// Resource-configured pinner flags;
private final boolean mConfiguredToPinCamera;
private final int mConfiguredCameraPinBytes;
private final int mConfiguredHomePinBytes;
private final boolean mConfiguredToPinAss
istant;
private final int mConfiguredAss
istantPinBytes;
private final int mConfiguredWebviewPinBytes;
// Th
is is the percentage of total device memory that will be used to set
the global quota
.
private final int mConfiguredMaxPinnedMemoryPercentage;
// Th
is is the global pinner quota that can be pinned
.
private long mConfiguredMaxPinnedMemory;
// Th
is is the currently pinned memory
.
private long mCurrentPinnedMemory = 0;
private BinderService mBinderService;
private PinnerHandler mPinnerHandler = null;
// #ifdef OPLUS_EXTENSION_HOOK
// Haoran
.Xu@ROM
.Framework, 2021/07/12, Modify for ALM
:1770593
public IPinnerServiceExt mPinnerServiceExt = ExtLoader
.type(IPinnerServiceExt
.class)
.create();
// #endif /* OPLUS_EXTENSION_HOOK */
private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
@Overr
ide
public vo
id onReceive(Context context, Intent intent) {
// If an app has updated, update pinned files accordingly
.
if (Intent
.ACTION_PACKAGE_REPLACED
.equals(intent
.getAction())) {
Uri packageUri = intent
.getData();
String package
Name = packageUri
.getSchemeSpecificPart();
ArraySet<String> updatedPackages = new ArraySet<>();
updatedPackages
.add(package
Name);
update(updatedPackages, true /* force */);
}
}
};
private final DeviceConfig
.OnPropertiesChangedL
istener mDeviceConfigA
nonSizeL
istener =
new DeviceConfig
.OnPropertiesChangedL
istener() {
@Overr
ide
public vo
id onPropertiesChanged(DeviceConfig
.Properties properties) {
if (DEVICE_CONFIG_
NAMESPACE_A
NON_SIZE
.equals(properties
.get
Namespace())
&& properties
.getKeyset()
.contains(DEVICE_CONFIG_KEY_A
NON_SIZE)) {
refreshPinA
nonConfig();
}
}
};
/** Utility class for testing
. */
@V
isibleForTesting
public static class Injector {
protected DeviceConfigInterface getDeviceConfigInterface() {
return DeviceConfigInterface
.REAL;
}
protected vo
id publ
ishBinderService(PinnerService service, Binder binderService) {
service
.publ
ishBinderService("pinner", binderService);
}
protected PinnedFile pinFileInternal(PinnerService service, String fileToPin,
long maxBytesToPin, boolean attemptPinIntrospection) {
return service
.pinFileInternal(fileToPin, maxBytesToPin, attemptPinIntrospection);
}
}
public PinnerService(Context context) {
th
is(context, new Injector());
}
@V
isibleForTesting
public PinnerService(Context context, Injector injector) {
super(context);
mContext = context;
mInjector = injector;
mDeviceConfigInterface = mInjector
.getDeviceConfigInterface();
mConfiguredToPinCamera = context
.getResources()
.getBoolean(
com
.andro
id.internal
.R
.bool
.config_pinnerCameraApp);
mConfiguredCameraPinBytes = context
.getResources()
.getInteger(
com
.andro
id.internal
.R
.integer
.config_pinnerCameraPinBytes);
mConfiguredAss
istantPinBytes = context
.getResources()
.getInteger(
com
.andro
id.internal
.R
.integer
.config_pinnerAss
istantPinBytes);
mConfiguredHomePinBytes = context
.getResources()
.getInteger(
com
.andro
id.internal
.R
.integer
.config_pinnerHomePinBytes);
mConfiguredToPinAss
istant = context
.getResources()
.getBoolean(
com
.andro
id.internal
.R
.bool
.config_pinnerAss
istantApp);
mConfiguredWebviewPinBytes = context
.getResources()
.getInteger(
com
.andro
id.internal
.R
.integer
.config_pinnerWebviewPinBytes);
mConfiguredMaxPinnedMemoryPercentage = context
.getResources()
.getInteger(
com
.andro
id.internal
.R
.integer
.config_pinnerMaxPinnedMemoryPercentage);
mPinKeys = createPinKeys();
mPinnerHandler = new PinnerHandler(BackgroundThread
.get()
.getLooper());
mAtmInternal = LocalServices
.getService(ActivityTaskManagerInternal
.class);
mAmInternal = LocalServices
.getService(ActivityManagerInternal
.class);
mAm = ActivityManager
.getService();
m
UserManager = mContext
.getSystemService(
UserManager
.class);
IntentFilter filter = new IntentFilter();
filter
.addAction(Intent
.ACTION_PACKAGE_REPLACED);
filter
.addDataScheme("package");
mContext
.reg
isterReceiver(mBroadcastReceiver, filter);
reg
isterU
idL
istener();
reg
ister
UserSetupCompleteL
istener();
mDeviceConfigInterface
.addOnPropertiesChangedL
istener(DEVICE_CONFIG_
NAMESPACE_A
NON_SIZE,
new HandlerExecutor(mPinnerHandler), mDeviceConfigA
nonSizeL
istener);
}
@Overr
ide
public vo
id onStart() {
if (DEBUG) {
Slog
.i(TAG, "Starting PinnerService");
}
mConfiguredMaxPinnedMemory =
(Process
.getTotalMemory()
* Math
.clamp(mConfiguredMaxPinnedMemoryPercentage, 0, 100))
/ 100;
mBinderService = new BinderService();
mInjector
.publ
ishBinderService(th
is, mBinderService);
publ
ishLocalService(PinnerService
.class, th
is);
mPinnerHandler
.obtainMessage(PinnerHandler
.PIN_ONSTART_MSG)
.sendToTarget();
sendPinAppsMessage(
UserHandle
.USER_SYSTEM);
}
/**
* Repin apps on
user switch
.
* <p>
* If more than one
user is using
the device each
user may set a different preference for
the
* indiv
idual apps
. Make sure that
user's preference
is pinned into memory
.
*/
@Overr
ide
public vo
id on
UserSwitching(@Nullable Target
User from, @
NonNull Target
User to) {
int
userId = to
.get
UserIdentifier();
if (!m
UserManager
.isManagedProfile(
userId)) {
sendPinAppsMessage(
userId);
}
}
@Overr
ide
public vo
id on
UserUnlocking(@
NonNull Target
User user) {
final int
userId =
user.get
UserIdentifier();
if (
userId !=
UserHandle
.USER_SYSTEM && !m
UserManager
.isManagedProfile(
userId)) {
// App pinning for
the system should have already been triggered from onStart()
.
sendPinAppsMessage(
userId);
}
}
/**
* Update
the currently pinned files
.
* Specifically, th
is only updates pinning for
the apps that need to be pinned
.
*
The o
ther files pinned in onStart will
not need to be updated
.
*/
public vo
id update(ArraySet<String> updatedPackages, boolean force) {
ArraySet<Integer> pinKeys = getPinKeys();
int current
User = ActivityManager
.getCurrent
User();
for (int i = pinKeys
.size() - 1; i >= 0; i--) {
int key = pinKeys
.valueAt(i);
ApplicationInfo info = getInfoForKey(key, current
User);
if (info != null && updatedPackages
.contains(info
.package
Name)) {
Slog
.i(TAG, "Updating pinned files for " + info
.package
Name + " force=" + force);
sendPinAppMessage(key, current
User, force);
}
}
// #ifdef OPLUS_EXTENSION_HOOK
// Haoran
.Xu@ROM
.Framework, 2021/07/12, Modify for ALM
:1770593
mPinnerServiceExt
.updateExt(updatedPackages, force);
// #endif /* OPLUS_EXTENSION_HOOK */
}
/** Returns information about pinned files and sizes for StatsPullAtomService
. */
public L
ist<PinnedFileStats> dumpDataForStatsd() {
L
ist<PinnedFileStats> pinnedFileStats = new ArrayL
ist<>();
synchronized (PinnerService
.th
is) {
for (PinnedFile pinnedFile
: mPinnedFiles
.values()) {
pinnedFileStats
.add(new PinnedFileStats(SYSTEM_U
ID, pinnedFile));
}
for (int key
: mPinnedApps
.keySet()) {
PinnedApp app = mPinnedApps
.get(key);
for (PinnedFile pinnedFile
: mPinnedApps
.get(key)
.mFiles) {
pinnedFileStats
.add(new PinnedFileStats(app
.u
id, pinnedFile));
}
}
}
return pinnedFileStats;
}
/** Wrapper class for stat
istics for a pinned file
. */
public static class PinnedFileStats {
public final int u
id;
public final String file
name;
public final int sizeKb;
protected PinnedFileStats(int u
id, PinnedFile file) {
th
is.u
id = u
id;
th
is.file
name = file
.file
Name.substring(file
.file
Name.lastIndexOf('/') + 1);
th
is.sizeKb = (int) file
.bytesPinned / 1024;
}
}
/**
* Handler for on start pinning message
*/
private vo
id handlePi
nOnStart() {
// Files to pin come from
the overlay and can be specified per-device config
String[] filesToPin = mContext
.getResources()
.getStringArray(
com
.andro
id.internal
.R
.array
.config_defaultPinnerServiceFiles);
// #ifdef OPLUS_EXTENSION_HOOK
// Chucheng
.Ye@ANDRO
ID.RESCONTROL, 2021/08/03, add for customize pinner file
.
filesToPin = mPinnerServiceExt
.replaceDefaultFiles(filesToPin);
// #endif /* OPLUS_EXTENSION_HOOK */
// Continue trying to pin each file even if we fail to pin some of
them
for (String fileToPin
: filesToPin) {
pinFile(fileToPin, Integer
.MAX_VALUE, /*appInfo=*/null, /*group
Name=*/SYSTEM_GROUP_
NAME,
true);
}
refreshPinA
nonConfig();
}
/**
* Reg
isters a l
istener to repin
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 vo
id reg
ister
UserSetupCompleteL
istener() {
Uri
userSetupCompleteUri = Settings
.Secure
.getUriFor(Settings
.Secure
.USER_SETUP_COMPLETE);
mContext
.getContentResolver()
.reg
isterContentObserver(
userSetupCompleteUri, false, new ContentObserver(null) {
@Overr
ide
public vo
id onChange(boolean selfChange, Uri uri) {
if (
userSetupCompleteUri
.equals(uri)) {
if (mConfiguredHomePinBytes > 0) {
sendPinAppMessage(KEY_HOME, ActivityManager
.getCurrent
User(),
true /* force */);
}
}
}
},
UserHandle
.USER_ALL);
}
private vo
id reg
isterU
idL
istener() {
try {
mAm
.reg
isterU
idObserver(new U
idObserver() {
@Overr
ide
public vo
id onU
idGone(int u
id, boolean d
isabled) {
mPinnerHandler
.sendMessage(PooledLambda
.obtainMessage(
PinnerService
::handleU
idGone, PinnerService
.th
is, u
id));
}
@Overr
ide
public vo
id onU
idActive(int u
id) {
mPinnerHandler
.sendMessage(PooledLambda
.obtainMessage(
PinnerService
::handleU
idActive, PinnerService
.th
is, u
id));
}
}, U
ID_OBSERVER_GONE | U
ID_OBSERVER_ACTIVE, 0, null);
} catch (RemoteException e) {
Slog
.e(TAG, "Failed to reg
ister u
id observer", e);
}
}
private vo
id handleU
idGone(int u
id) {
updateActiveState(u
id, false /* active */);
int key;
synchronized (th
is) {
// In case we have a pending repin, repin
now
. See mPendingRepin for more information
.
key = mPendingRepin
.getOrDefault(u
id, -1);
if (key == -1) {
return;
}
mPendingRepin
.remove(u
id);
}
pinApp(key, ActivityManager
.getCurrent
User(), false /* force */);
}
private vo
id handleU
idActive(int u
id) {
updateActiveState(u
id, true /* active */);
}
private vo
id updateActiveState(int u
id, boolean active) {
synchronized (th
is) {
for (int i = mPinnedApps
.size() - 1; i >= 0; i--) {
PinnedApp app = mPinnedApps
.valueAt(i);
if (app
.u
id == u
id) {
app
.active = active;
}
}
}
}
private vo
id unpinApps() {
ArraySet<Integer> pinKeys = getPinKeys();
for (int i = pinKeys
.size() - 1; i >= 0; i--) {
int key = pinKeys
.valueAt(i);
unpinApp(key);
}
}
private vo
id unpinApp(@AppKey int key) {
ArrayL
ist<PinnedFile> pinnedAppFiles;
synchronized (th
is) {
PinnedApp app = mPinnedApps
.get(key);
if (app == null) {
return;
}
mPinnedApps
.remove(key);
pinnedAppFiles = new ArrayL
ist<>(app
.mFiles);
}
for (PinnedFile pinnedFile
: pinnedAppFiles) {
unpinFile(pinnedFile
.file
Name);
}
}
private boolean
isResolverActivity(ActivityInfo info) {
return ResolverActivity
.class
.get
Name()
.equals(info
.name);
}
public int getWebviewPinQuota() {
if (!pinWebview()) {
return 0;
}
int quota = mConfiguredWebviewPinBytes;
int overr
ideQuota = SystemProperties
.getInt("pinner
.pin_webview_size", -1);
if (overr
ideQuota != -1) {
// Quota was overr
idden
quota = overr
ideQuota;
}
return quota;
}
private ApplicationInfo getCameraInfo(int
userHandle) {
Intent cameraIntent = new Intent(MediaStore
.INTENT_ACTION_STILL_IMAGE_CAMERA);
ApplicationInfo info = getApplicationInfoForIntent(
cameraIntent,
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 unlocking
their device, we may still be able to
identify
their
// preference using th
is intent
.
if (info == null) {
cameraIntent = new Intent(MediaStore
.INTENT_ACTION_STILL_IMAGE_CAMERA_SECURE);
info = getApplicationInfoForIntent(
cameraIntent,
userHandle, false /* defaultToSystemApp */);
}
// If
the _SECURE intent doesn't resolve, try
the original intent but request
//
the system app for camera if
there was more than one result
.
if (info == null) {
cameraIntent = new Intent(MediaStore
.INTENT_ACTION_STILL_IMAGE_CAMERA);
info = getApplicationInfoForIntent(
cameraIntent,
userHandle, true /* defaultToSystemApp */);
}
return info;
}
private ApplicationInfo getHomeInfo(int
userHandle) {
Intent intent = mAtmInternal
.getHomeIntent();
return getApplicationInfoForIntent(intent,
userHandle, false);
}
private ApplicationInfo getAss
istantInfo(int
userHandle) {
Intent intent = new Intent(Intent
.ACTION_ASS
IST);
return getApplicationInfoForIntent(intent,
userHandle, true);
}
private ApplicationInfo getApplicationInfoForIntent(
Intent intent, int
userHandle, boolean defaultToSystemApp) {
if (intent == null) {
return null;
}
ResolveInfo resolveInfo =
mContext
.getPackageManager()
.resolveActivityAs
User(intent, MATCH_FLAGS,
userHandle);
// If th
is intent can resolve to only one app, choose that one
.
// O
therw
ise, 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 since we don't k
now which to pick
.
if (resolveInfo == null) {
return null;
}
if (!
isResolverActivity(resolveInfo
.activityInfo)) {
return resolveInfo
.activityInfo
.applicationInfo;
}
if (defaultToSystemApp) {
L
ist<ResolveInfo> infoL
ist = mContext
.getPackageManager()
.queryIntentActivitiesAs
User(
intent, MATCH_FLAGS,
userHandle);
ApplicationInfo systemAppInfo = null;
for (ResolveInfo info
: infoL
ist) {
if ((info
.activityInfo
.applicationInfo
.flags & ApplicationInfo
.FLAG_SYSTEM) != 0) {
if (systemAppInfo == null) {
systemAppInfo = info
.activityInfo
.applicationInfo;
} else {
// If
there's more than one system app, return null due to ambiguity
.
return null;
}
}
}
return systemAppInfo;
}
return null;
}
private vo
id sendPinAppsMessage(int
userHandle) {
mPinnerHandler
.sendMessage(
PooledLambda
.obtainMessage(PinnerService
::pinApps, th
is,
userHandle));
}
private vo
id sendPinAppsWithUpdatedKeysMessage(int
userHandle) {
mPinnerHandler
.sendMessage(PooledLambda
.obtainMessage(
PinnerService
::pinAppsWithUpdatedKeys, th
is,
userHandle));
}
private vo
id sendUnpinAppsMessage() {
mPinnerHandler
.sendMessage(PooledLambda
.obtainMessage(PinnerService
::unpinApps, th
is));
}
private ArraySet<Integer> createPinKeys() {
ArraySet<Integer> pinKeys = new ArraySet<>();
// Pin
the camera application
. Default to
the system property only if
the experiment
// phe
notype property
is not set
.
boolean shouldPinCamera = mConfiguredToPinCamera
&& mDeviceConfigInterface
.getBoolean(DeviceConfig
.NAMESPACE_RUNTIME_NATIVE_BOOT,
"pin_camera", SystemProperties
.getBoolean("pinner
.pin_camera", true));
if (shouldPinCamera) {
pinKeys
.add(KEY_CAMERA);
} else if (DEBUG) {
Slog
.i(TAG, "Pinner - skip pinning camera app");
}
if (mConfiguredHomePinBytes > 0) {
pinKeys
.add(KEY_HOME);
}
if (mConfiguredToPinAss
istant) {
pinKeys
.add(KEY_ASS
ISTANT);
}
return pinKeys;
}
private synchronized ArraySet<Integer> getPinKeys() {
return mPinKeys;
}
private vo
id pinApps(int
userHandle) {
pinAppsInternal(
userHandle, false);
}
private vo
id pinAppsWithUpdatedKeys(int
userHandle) {
pinAppsInternal(
userHandle, true);
}
/**
* @param updateKeys True if
the pinned app l
ist has to be updated
. Th
is is true only when
* "pinner repin" shell command
is requested
.
*/
private vo
id pinAppsInternal(int
userHandle, boolean updateKeys) {
if (updateKeys) {
ArraySet<Integer> newKeys = createPinKeys();
synchronized (th
is) {
// Th
is code path demands preceding unpinApps() call
.
if (!mPinnedApps
.isEmpty()) {
Slog
.e(TAG,
"Attempted to update a l
ist of apps, "
+ "but apps were already pinned
. Skipping
.");
return;
}
mPinKeys = newKeys;
}
}
ArraySet<Integer> currentPinKeys = getPinKeys();
for (int i = currentPinKeys
.size() - 1; i >= 0; i--) {
int key = currentPinKeys
.valueAt(i);
pinApp(key,
userHandle, true /* force */);
}
}
/**
* @see #pinApp(int, int, boolean)
*/
private vo
id sendPinAppMessage(int key, int
userHandle, boolean force) {
mPinnerHandler
.sendMessage(
PooledLambda
.obtainMessage(PinnerService
::pinApp, th
is, key,
userHandle, force));
}
/**
* Pins an app of a specific type {@code key}
.
*
* @param force If false, th
is will
not repin
the app if it's currently active
. See
* {@link #mPendingRepin}
.
*/
private vo
id pinApp(int key, int
userHandle, boolean force) {
int u
id = getU
idForKey(key);
// In case
the app
is currently active, don't repin until next process restart
. See
// mPendingRepin for more information
.
if (!force && u
id != -1) {
synchronized (th
is) {
mPendingRepin
.put(u
id, key);
}
return;
}
ApplicationInfo info = getInfoForKey(key,
userHandle);
unpinApp(key);
if (info != null) {
pinAppInternal(key, info);
}
}
/**
* Checks whe
ther
the pinned package with {@code key}
is active or
not.
* @return
The u
id of
the pinned app, or {@code -1} o
therw
ise
.
*/
private int getU
idForKey(@AppKey int key) {
synchronized (th
is) {
PinnedApp ex
isting = mPinnedApps
.get(key);
return ex
isting != null && ex
isting
.active ? ex
isting
.u
id : -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 ApplicationInfo getInfoForKey(@AppKey int key, int
userHandle) {
switch (key) {
case KEY_CAMERA
:
return getCameraInfo(
userHandle);
case KEY_HOME
:
return getHomeInfo(
userHandle);
case KEY_ASS
ISTANT
:
return getAss
istantInfo(
userHandle);
default
:
return null;
}
}
/**
* @return
The app type
name for {@code key}
.
*/
private String get
NameForKey(@AppKey int key) {
switch (key) {
case KEY_CAMERA
:
return "Camera";
case KEY_HOME
:
return "Home";
case KEY_ASS
ISTANT
:
return "Ass
istant";
default
:
return "";
}
}
/**
* Handle any changes in
the a
non region pinner config
.
*/
private vo
id refreshPinA
nonConfig() {
long newPinA
nonSize = mDeviceConfigInterface
.getLong(
DEVICE_CONFIG_
NAMESPACE_A
NON_SIZE, DEVICE_CONFIG_KEY_A
NON_SIZE, DEFAULT_A
NON_SIZE);
newPinA
nonSize = Math
.max(0, Math
.min(newPinA
nonSize, MAX_A
NON_SIZE));
if (newPinA
nonSize != mPinA
nonSize) {
mPinA
nonSize = newPinA
nonSize;
pinA
nonRegion();
}
}
/**
* Pin an empty
anonymous region
. Th
is should only be used for ablation experiments
.
*/
private vo
id pinA
nonRegion() {
if (mPinA
nonSize == 0) {
Slog
.d(TAG, "pinA
nonRegion
: releasing pinned region");
unpinA
nonRegion();
return;
}
long alignedPinSize = mPinA
nonSize;
if (alignedPinSize % PAGE_SIZE != 0) {
alignedPinSize -= alignedPinSize % PAGE_SIZE;
Slog
.e(TAG, "pinA
nonRegion
: aligning size to " + alignedPinSize);
}
if (mPinA
nonAddress != 0) {
if (mCurrentlyPinnedA
nonSize == alignedPinSize) {
Slog
.d(TAG, "pinA
nonRegion
: already pinned region of size " + alignedPinSize);
return;
}
Slog
.d(TAG, "pinA
nonRegion
: resetting pinned region for new size " + alignedPinSize);
unpinA
nonRegion();
}
long address = 0;
try {
// Map as SHARED to avo
id changing rss
.a
non for system_server (per /proc/*/status)
.
//
The mapping
is v
isible in o
ther rss metrics, and as private dirty in smaps/meminfo
.
address = Os
.mmap(0, alignedPinSize, OsConstants
.PROT_READ | OsConstants
.PROT_WRITE,
OsConstants
.MAP_SHARED | OsConstants
.MAP_
ANONYMOUS, new FileDescriptor(),
/*offset=*/0);
Unsafe tempUnsafe = null;
Class<sun
.m
isc
.Unsafe> clazz = sun
.m
isc
.Unsafe
.class;
for (java
.lang
.reflect
.Field f
: clazz
.getDeclaredFields()) {
f
.setAccessible(true);
Object obj = f
.get(null);
if (clazz
.isInstance(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, alignedPinSize, (byte) 1);
Os
.mlock(address, alignedPinSize);
mCurrentlyPinnedA
nonSize = alignedPinSize;
mPinA
nonAddress = address;
address = -1;
Slog
.w(TAG, "pinA
nonRegion success, size=" + mCurrentlyPinnedA
nonSize);
} catch (Exception ex) {
Slog
.e(TAG, "Could
not pin a
non region of size " + alignedPinSize, ex);
return;
} finally {
if (address >= 0) {
PinnerUtils
.safeMunmap(address, alignedPinSize);
}
}
}
private vo
id unpinA
nonRegion() {
if (mPinA
nonAddress != 0) {
PinnerUtils
.safeMunmap(mPinA
nonAddress, mCurrentlyPinnedA
nonSize);
}
mPinA
nonAddress = 0;
mCurrentlyPinnedA
nonSize = 0;
}
/**
* @return
The maximum amount of bytes to be pinned for an app of type {@code key}
.
*/
private int getSizeLimitForKey(@AppKey int key) {
switch (key) {
case KEY_CAMERA
:
return mConfiguredCameraPinBytes;
case KEY_HOME
:
return mConfiguredHomePinBytes;
case KEY_ASS
ISTANT
:
return mConfiguredAss
istantPinBytes;
default
:
return 0;
}
}
/**
* Retrieves remaining quota for pinner service, once it reaches 0 it will
no longer
* pin any file
.
*/
private long getAvailableGlobalQuota() {
return mConfiguredMaxPinnedMemory - mCurrentPinnedMemory;
}
/**
* Pins an application
.
*
* @param key
The key of
the app to pin
.
* @param appInfo
The corresponding app info
.
*/
private vo
id pinAppInternal(@AppKey int key, @Nullable ApplicationInfo appInfo) {
if (appInfo == null) {
return;
}
PinnedApp pinnedApp = new PinnedApp(appInfo);
synchronized (th
is) {
mPinnedApps
.put(key, pinnedApp);
}
// pin APK
final int pinSizeLimit = getSizeLimitForKey(key);
L
ist<String> apks = new ArrayL
ist<>();
apks
.add(appInfo
.sourceDir);
if (appInfo
.splitSourceDirs != null) {
for (String splitApk
: appInfo
.splitSourceDirs) {
apks
.add(splitApk);
}
}
long apkPinSizeLimit = pinSizeLimit;
for (String apk
: apks) {
if (apkPinSizeLimit <= 0) {
Slog
.w(TAG, "Reached to
the pin size limit
. Skipping
: " + apk);
// Continue instead of break to print all skipped APK
names
.
continue;
}
String pinGroup = get
NameForKey(key);
boolean shouldPinDeps = apk
.equals(appInfo
.sourceDir);
PinnedFile pf = pinFile(apk, apkPinSizeLimit, appInfo, pinGroup, shouldPinDeps);
if (pf == null) {
Slog
.e(TAG, "Failed to pin " + apk);
continue;
}
if (DEBUG) {
Slog
.i(TAG, "Pinned " + pf
.file
Name);
}
synchronized (th
is) {
pinnedApp
.mFiles
.add(pf);
}
apkPinSizeLimit -= pf
.bytesPinned;
}
}
/**
* Pin file or apk to memory
.
*
* Prefer to use th
is method instead of {@link #pinFileInternal(String, int, boolean)} as it
* takes care of accounting and if pinning an apk, it also pins any extra optimized art files
* that related to
the file but
not within itself
.
*
* @param fileToPin File to pin
* @param bytesRequestedToPin maximum bytes requested to pin for {@code fileToPin}
.
* @param pi
nOptimizedDeps whe
ther optimized dependencies
such as odex,vdex, etc be pinned
.
*
Note
: {@code bytesRequestedToPin} limit will
not apply to optimized
* dependencies pinned, only global quotas will apply instead
.
* @return pinned file
*/
public PinnedFile pinFile(String fileToPin, long bytesRequestedToPin,
@Nullable ApplicationInfo appInfo, @Nullable String group
Name,
boolean pi
nOptimizedDeps) {
PinnedFile ex
istingPin;
synchronized (th
is) {
ex
istingPin = mPinnedFiles
.get(fileToPin);
}
if (ex
istingPin != null) {
if (ex
istingPin
.bytesPinned == bytesRequestedToPin) {
// Duplicate pin requesting same amount of bytes, lets just bail out
.
return null;
} else {
//
User dec
ided to pin a different amount of bytes than currently pinned
// so th
is is a val
id pin request
. Unpin
the previous version before repining
.
if (DEBUG) {
Slog
.d(TAG, "Unpinning file prior to repin
: " + fileToPin);
}
unpinFile(fileToPin);
}
}
long remainingQuota = getAvailableGlobalQuota();
if (pinGlobalQuota()) {
if (remainingQuota <= 0) {
Slog
.w(TAG, "Reached pin quota, skipping file
: " + fileToPin);
return null;
}
bytesRequestedToPin = Math
.min(bytesRequestedToPin, remainingQuota);
}
boolean
isApk = fileToPin
.endsWith("
.apk");
PinnedFile pf = mInjector
.pinFileInternal(th
is, fileToPin, bytesRequestedToPin,
/*attemptPinIntrospection=*/
isApk);
if (pf == null) {
Slog
.e(TAG, "Failed to pin file = " + fileToPin);
return null;
}
pf
.group
Name = group
Name != null ? group
Name : "";
mCurrentPinnedMemory += pf
.bytesPinned;
synchronized (th
is) {
mPinnedFiles
.put(pf
.file
Name, pf);
}
if (pi
nOptimizedDeps) {
mCurrentPinnedMemory +=
pi
nOptimizedDexDependencies(pf, getAvailableGlobalQuota(), appInfo);
}
return pf;
}
/**
* Pin any dependency optimized files generated by ART
.
* @param pinnedFile An already pinned file whose dependencies we want pinned
.
* @param maxBytesToPin Maximum amount of bytes to pin
.
* @param appInfo Used to determine
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 pinned
.
*/
private long pi
nOptimizedDexDependencies(
PinnedFile pinnedFile, long maxBytesToPin, @Nullable ApplicationInfo appInfo) {
if (pinnedFile == null) {
return 0;
}
long bytesPinned = 0;
if (pinnedFile
.file
Name.endsWith("
.jar") | pinnedFile
.file
Name.endsWith("
.apk")) {
String abi = null;
if (appInfo != null) {
abi = appInfo
.primaryCpuAbi;
}
if (abi == null) {
abi = Build
.SUPPORTED_AB
IS[0];
}
// Check whe
ther
the runtime has compilation artifacts to pin
.
String arch = VMRuntime
.getInstructionSet(abi);
String[] files = null;
try {
files = DexFile
.getDexFileOutputPaths(pinnedFile
.file
Name, arch);
} catch (IOException ioe) {
}
if (files == null) {
return bytesPinned;
}
for (String file
: files) {
// Unpin if it was already pinned prior to re-pinning
.
unpinFile(file);
PinnedFile df = mInjector
.pinFileInternal(th
is, file, maxBytesToPin,
/*attemptPinIntrospection=*/false);
if (df == null) {
Slog
.i(TAG, "Failed to pin ART file = " + file);
return bytesPinned;
}
df
.group
Name = pinnedFile
.group
Name;
pinnedFile
.pinnedDeps
.add(df);
maxBytesToPin -= df
.bytesPinned;
bytesPinned += df
.bytesPinned;
synchronized (th
is) {
mPinnedFiles
.put(df
.file
Name, df);
}
}
}
return bytesPinned;
}
/**
* mlock length bytes of fileToPin in memory
*
* If attemptPinIntrospection
is true,
then treat
the file to pin as a zip file and
* look for a "pinl
ist
.meta" file in
the archive root directory
. The structure of th
is
* file
is a PINL
IST_META as described below
:
*
* <pre>
* PINL
IST_META
: PIN_RANGE*
* PIN_RANGE
: PIN_START PIN_LENGTH
* PIN_START
: big endian i32
: offset in bytes of pin region from file start
* PIN_LENGTH
: big endian i32
: length of pin region in bytes
* </pre>
*
* (We use big endian because that's what DataInputStream
is hardcoded to use
.)
*
* If attemptPinIntrospection
is false,
then we use a single implicit PIN_RANGE of (0,
* maxBytesToPin); that
is, we attempt to pin
the first maxBytesToPin bytes of
the file
.
*
* After we open a file, we march through
the l
ist of pin ranges and attempt to pin
* each one, stopping after we've pinned maxBytesToPin bytes
. (We may truncate
the last
* pinned range to fit
.) In th
is way, by choosing to emit certain PIN_RANGE pairs
* before o
thers, file generators can express pins in priority order, making most
* effective use of
the pinned-page quota
.
*
* N
.B
. Each PIN_RANGE
is clamped to
the actual bounds of
the file; all inputs have a
* meaningful interpretation
. Also, a range locking a single byte of a page locks
the
* whole page
. Any truncated PIN_RANGE at EOF
is ig
nored
. Overlapping pinned entries
* are legal, but each pin of a byte counts toward
the pin quota regardless of whe
ther
* that byte has already been pinned, so
the generator of PINL
IST_META ought to ensure
* that ranges are
non-overlapping
.
*
* @param fileToPin Path to file to pin
* @param maxBytesToPin Maximum number of bytes to pin
* @param attemptPinIntrospection If true, try to open file as a
* zip in order to extract
the
* @return Pinned memory resource owner thing or null on error
*/
private PinnedFile pinFileInternal(
String fileToPin, long maxBytesToPin, boolean attemptPinIntrospection) {
if (DEBUG) {
Slog
.d(TAG, "pin file
: " + fileToPin + " use-pinl
ist
: " + attemptPinIntrospection);
}
ZipFile fileAsZip = null;
InputStream pinRangeStream = null;
try {
if (attemptPinIntrospection) {
fileAsZip = maybeOpenZip(fileToPin);
}
if (fileAsZip != null) {
pinRangeStream = maybeOpenPinMetaInZip(fileAsZip, fileToPin);
}
boolean use_pinl
ist = (pinRangeStream != null);
PinRangeSource pinRangeSource = use_pinl
ist
? new PinRangeSourceStream(pinRangeStream)
: new PinRangeSourceStatic(0, Integer
.MAX_VALUE /* will be clipped */);
PinnedFile pinnedFile = pinFileRanges(fileToPin, maxBytesToPin, pinRangeSource);
if (pinnedFile != null) {
pinnedFile
.used_pinl
ist = use_pinl
ist;
}
return pinnedFile;
} finally {
PinnerUtils
.safeClose(pinRangeStream);
PinnerUtils
.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(String file
Name) {
ZipFile zip = null;
try {
zip = new ZipFile(file
Name);
} catch (IOException ex) {
Slog
.w(TAG, String
.format("could
not open \"%s\" as zip
: pinning as blob", file
Name),
ex);
}
return zip;
}
/**
* Open a pin 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 maybeOpenPinMetaInZip(ZipFile zipFile, String file
Name) {
if (!PROP_PIN_PINL
IST) {
if (DEBUG) {
Slog
.i(TAG, "Pin - skip pinl
ist
.meta in " + file
Name);
}
return null;
}
// Looking at root directory
is the old behavior but still some apps rely on it so keeping
// for backward compatibility
. As doing a single item lookup
is cheap in
the root
.
ZipEntry pinMetaEntry = zipFile
.getEntry(PIN_META_FILE
NAME);
if (pinMetaEntry == null) {
// It
is usually within an apk's control to include files in assets/ directory
// so th
is would be
the expected point to have
the pinl
ist
.meta coming from
.
// we explicitly avo
id doing an exhaustive search because it may be expensive so
// prefer to have a good k
nown location to retrieve
the file
.
pinMetaEntry = zipFile
.getEntry("assets/" + PIN_META_FILE
NAME);
}
InputStream pinMetaStream = null;
if (pinMetaEntry != null) {
if (DEBUG) {
Slog
.d(TAG, "
Found pinl
ist
.meta for " + file
Name);
}
try {
pinMetaStream = zipFile
.getInputStream(pinMetaEntry);
} catch (IOException ex) {
Slog
.w(TAG,
String
.format(
"error reading pin metadata \"%s\"
: pinning as blob", file
Name),
ex);
}
} else {
Slog
.w(TAG,
String
.format(
"Could
not find pinl
ist
.meta for \"%s\"
: pinning as blob", file
Name));
}
return pinMetaStream;
}
/**
* Helper for pinFile
.
*
* @param fileToPin
Name of file to pin
* @param maxBytesToPin Maximum number of bytes to pin
* @param pinRangeSource Read PIN_RANGE entries from th
is stream to tell us what bytes
* to pin
.
* @return PinnedFile or null on error
*/
private static PinnedFile pinFileRanges(
String fileToPin, long maxBytesToPin, PinRangeSource pinRangeSource) {
FileDescriptor fd = new FileDescriptor();
long address = -1;
long mapSize = 0;
try {
int openFlags = (OsConstants
.O_RDONLY | OsConstants
.O_CLOEXEC);
fd = Os
.open(fileToPin, openFlags, 0);
mapSize = (int) Math
.min(Os
.fstat(fd)
.st_size, Integer
.MAX_VALUE);
address = Os
.mmap(
0, mapSize, OsConstants
.PROT_READ, OsConstants
.MAP_SHARED, fd, /*offset=*/0);
PinRange pinRange = new PinRange();
long bytesPinned = 0;
// We pin at page granularity, so make sure
the limit
is page-aligned
if (maxBytesToPin % PAGE_SIZE != 0) {
maxBytesToPin -= maxBytesToPin % PAGE_SIZE;
}
while (bytesPinned < maxBytesToPin && pinRangeSource
.read(pinRange)) {
long pinStart = pinRange
.start;
long pinLength = pinRange
.length;
pinStart = PinnerUtils
.clamp(0, pinStart, mapSize);
pinLength = PinnerUtils
.clamp(0, pinLength, mapSize - pinStart);
pinLength = Math
.min(maxBytesToPin - bytesPinned, pinLength);
// 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
// locking a single byte of a page as a charge of one byte even though
the
// OS will retain
the whole page
. Thanks to th
is adjustment, we slightly
// over-count
the pin charge of back-to-back pins touching
the same page,
// but better that than undercounting
. Bes
ides
: nothing stops pin metafile
// creators from making
the actual regions page-aligned
.
pinLength += pinStart % PAGE_SIZE;
pinStart -= pinStart % PAGE_SIZE;
if (pinLength % PAGE_SIZE != 0) {
pinLength += PAGE_SIZE - pinLength % PAGE_SIZE;
}
pinLength = PinnerUtils
.clamp(0, pinLength, maxBytesToPin - bytesPinned);
if (pinLength > 0) {
if (DEBUG) {
Slog
.d(TAG,
String
.format("pinning at %s %s bytes of %s", pinStart, pinLength,
fileToPin));
}
Os
.mlock(address + pinStart, pinLength);
}
bytesPinned += pinLength;
}
PinnedFile pinnedFile = new PinnedFile(address, mapSize, fileToPin, bytesPinned);
address = -1; // Ownership transferred
return pinnedFile;
} catch (Err
noException ex) {
Slog
.e(TAG, "Could
not pin file " + fileToPin, ex);
return null;
} finally {
PinnerUtils
.safeClose(fd);
if (address >= 0) {
PinnerUtils
.safeMunmap(address, mapSize);
}
}
}
private L
ist<PinnedFile> getAllPinsF
orGroup(String group) {
L
ist<PinnedFile> filesInGroup;
synchronized (th
is) {
filesInGroup = mPinnedFiles
.values()
.stream()
.filter(pf -> pf
.group
Name.equals(group))
.toL
ist();
}
return filesInGroup;
}
public vo
id unpinGroup(String group) {
L
ist<PinnedFile> pinnedFiles = getAllPinsF
orGroup(group);
for (PinnedFile pf
: pinnedFiles) {
unpinFile(pf
.file
Name);
}
}
/**
* Unpin a file and its optimized dependencies
.
*
* @param file
name file to unpin
.
* @return number of bytes unpinned, 0 in case of failure or
nothing to unpin
.
*/
public long unpinFile(String file
name) {
PinnedFile pinnedFile;
synchronized (th
is) {
pinnedFile = mPinnedFiles
.get(file
name);
}
if (pinnedFile == null) {
// File
not pinned,
nothing to do
.
return 0;
}
long unpinnedBytes = pinnedFile
.bytesPinned;
pinnedFile
.close();
synchronized (th
is) {
if (DEBUG) {
Slog
.d(TAG, "Unpinned file
: " + file
name);
}
mCurrentPinnedMemory -= pinnedFile
.bytesPinned;
mPinnedFiles
.remove(pinnedFile
.file
Name);
for (PinnedFile dep
: pinnedFile
.pinnedDeps) {
if (dep == null) {
continue;
}
unpinnedBytes -= dep
.bytesPinned;
mCurrentPinnedMemory -= dep
.bytesPinned;
mPinnedFiles
.remove(dep
.file
Name);
if (DEBUG) {
Slog
.d(TAG, "Unpinned dependency
: " + dep
.file
Name);
}
}
}
return unpinnedBytes;
}
public L
ist<PinnedFileStat> getPinnerStats() {
ArrayL
ist<PinnedFileStat> stats = new ArrayL
ist<>();
Collection<PinnedFile> pinnedFiles;
synchronized (th
is) {
pinnedFiles = mPinnedFiles
.values();
}
for (PinnedFile pf
: pinnedFiles) {
PinnedFileStat stat = new PinnedFileStat(pf
.file
Name, pf
.bytesPinned, pf
.group
Name);
stats
.add(stat);
}
if (mCurrentlyPinnedA
nonSize > 0) {
stats
.add(new PinnedFileStat(
A
NON_REGION_STAT_
NAME, mCurrentlyPinnedA
nonSize, A
NON_REGION_STAT_
NAME));
}
return stats;
}
public final class BinderService extends IPinnerService
.Stub {
@Overr
ide
protected vo
id dump(FileDescriptor fd, PrintWriter pw, String[] args) {
if (!DumpUtils
.checkDumpPerm
ission(mContext, TAG, pw))
return;
HashSet<PinnedFile> shownPins = new HashSet<>();
HashSet<String> shownGroups = new HashSet<>();
HashSet<String> groupsToPrint = new HashSet<>();
final double bytesPerMB = 1024 * 1024;
pw
.format("Pinner Configs
:\n");
pw
.format(" Total Pinner quota
: %d%% of total device memory\n",
mConfiguredMaxPinnedMemoryPercentage);
pw
.format(" Maximum Pinner quota
: %d bytes (%
.2f MB)\n", mConfiguredMaxPinnedMemory,
mConfiguredMaxPinnedMemory / bytesPerMB);
pw
.format(" Max Home App Pin Bytes (without deps)
: %d (%
.2f MB)\n",
mConfiguredHomePinBytes, mConfiguredHomePinBytes / bytesPerMB);
pw
.format(" Max Ass
istant App Pin Bytes (without deps)
: %d (%
.2f MB)\n",
mConfiguredAss
istantPinBytes, mConfiguredAss
istantPinBytes / bytesPerMB);
pw
.format(
" Max Camera App Pin Bytes (without deps)
: %d (%
.2f MB)\n",
mConfiguredCameraPinBytes, mConfiguredCameraPinBytes / bytesPerMB);
pw
.format("\nPinned Files
:\n");
synchronized (PinnerService
.th
is) {
long totalSize = 0;
// We print apps separately from regular pins as
they contain extra information that
// o
ther pins do
not.
for (int key
: mPinnedApps
.keySet()) {
PinnedApp app = mPinnedApps
.get(key);
pw
.print(get
NameForKey(key));
pw
.print(" u
id=");
pw
.print(app
.u
id);
pw
.print(" active=");
pw
.print(app
.active);
if (!app
.mFiles
.isEmpty()) {
shownGroups
.add(app
.mFiles
.getFirst()
.group
Name);
}
pw
.println();
long bytesPinnedForApp = 0;
long bytesPinnedForAppDeps = 0;
for (PinnedFile pf
: mPinnedApps
.get(key)
.mFiles) {
pw
.print(" ");
pw
.format("%s pinned
:%d bytes (%
.2f MB) pinl
ist
:%b\n", pf
.file
Name,
pf
.bytesPinned, pf
.bytesPinned / bytesPerMB, pf
.used_pinl
ist);
totalSize += pf
.bytesPinned;
bytesPinnedForApp += pf
.bytesPinned;
shownPins
.add(pf);
for (PinnedFile dep
: pf
.pinnedDeps) {
pw
.print(" ");
pw
.format("%s pinned
:%d bytes (%
.2f MB) pinl
ist
:%b (Dependency)\n",
dep
.file
Name, dep
.bytesPinned, dep
.bytesPinned / bytesPerMB,
dep
.used_pinl
ist);
totalSize += dep
.bytesPinned;
bytesPinnedForAppDeps += dep
.bytesPinned;
shownPins
.add(dep);
}
}
long bytesPinnedForAppAndDeps = bytesPinnedForApp + bytesPinnedForAppDeps;
pw
.format("Total Pinned = %d (%
.2f MB) [App=%d (%
.2f MB), "
+ "Dependencies=%d (%
.2f MB)]\n\n",
bytesPinnedForAppAndDeps, bytesPinnedForAppAndDeps / bytesPerMB,
bytesPinnedForApp, bytesPinnedForApp / bytesPerMB,
bytesPinnedForAppDeps, bytesPinnedForAppDeps / bytesPerMB);
}
pw
.println();
for (PinnedFile pinnedFile
: mPinnedFiles
.values()) {
if (!groupsToPrint
.contains(pinnedFile
.group
Name)
&& !shownGroups
.contains(pinnedFile
.group
Name)) {
groupsToPrint
.add(pinnedFile
.group
Name);
}
}
// Print all
the non app groups
.
for (String group
: groupsToPrint) {
L
ist<PinnedFile> groupPins = getAllPinsF
orGroup(group);
pw
.print("\nGroup
:" + group);
long bytesPinnedF
orGroup
NoDeps = 0;
long bytesPinnedF
orGroupDeps = 0;
pw
.println();
for (PinnedFile pinnedFile
: groupPins) {
if (shownPins
.contains(pinnedFile)) {
// Already d
isplayed and accounted for, skip
.
continue;
}
pw
.format(" %s pinned
: %d bytes (%
.2f MB) pinl
ist
:%b\n",
pinnedFile
.file
Name, pinnedFile
.bytesPinned,
pinnedFile
.bytesPinned / bytesPerMB, pinnedFile
.used_pinl
ist);
totalSize += pinnedFile
.bytesPinned;
bytesPinnedF
orGroup
NoDeps += pinnedFile
.bytesPinned;
shownPins
.add(pinnedFile);
for (PinnedFile dep
: pinnedFile
.pinnedDeps) {
if (shownPins
.contains(dep)) {
// Already d
isplayed and accounted for, skip
.
continue;
}
pw
.print(" ");
pw
.format("%s pinned
:%d bytes (%
.2f MB) pinl
ist
:%b (Dependency)\n",
dep
.file
Name, dep
.bytesPinned, dep
.bytesPinned / bytesPerMB,
dep
.used_pinl
ist);
totalSize += dep
.bytesPinned;
bytesPinnedF
orGroupDeps += dep
.bytesPinned;
shownPins
.add(dep);
}
}
long bytesPinnedF
orGroup = bytesPinnedF
orGroup
NoDeps + bytesPinnedF
orGroupDeps;
pw
.format("Total Pinned = %d (%
.2f MB) [Main=%d (%
.2f MB), "
+ "Dependencies=%d (%
.2f MB)]\n\n",
bytesPinnedF
orGroup, bytesPinnedF
orGroup / bytesPerMB,
bytesPinnedF
orGroup
NoDeps, bytesPinnedF
orGroup
NoDeps / bytesPerMB,
bytesPinnedF
orGroupDeps, bytesPinnedF
orGroupDeps / bytesPerMB);
}
pw
.println();
if (mPinA
nonAddress != 0) {
pw
.format("Pinned a
non region
: %d (%
.2f MB)\n", mCurrentlyPinnedA
nonSize,
mCurrentlyPinnedA
nonSize / bytesPerMB);
totalSize += mCurrentlyPinnedA
nonSize;
}
pw
.format("Total pinned
: %d bytes (%
.2f MB)\n", totalSize, totalSize / bytesPerMB);
pw
.format("Available Pinner quota
: %d bytes (%
.2f MB)\n", getAvailableGlobalQuota(),
getAvailableGlobalQuota() / bytesPerMB);
pw
.println();
if (!mPendingRepin
.isEmpty()) {
pw
.print("Pending repin
: ");
for (int key
: mPendingRepin
.values()) {
pw
.print(get
NameForKey(key));
pw
.print(' ');
}
pw
.println();
}
}
}
private vo
id repin() {
sendUnpinAppsMessage();
// TODO(morrita)
: Cons
ider supporting
non-system
user.
sendPinAppsWithUpdatedKeysMessage(
UserHandle
.USER_SYSTEM);
}
private vo
id printError(FileDescriptor out, String message) {
PrintWriter writer = new PrintWriter(new FileOutputStream(out));
writer
.println(message);
writer
.flush();
}
@Overr
ide
public vo
id onShellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,
String[] args, ShellCallback callback, ResultReceiver resultReceiver) {
if (args
.length < 1) {
printError(out, "Command
is not given
.");
resultReceiver
.send(-1, null);
return;
}
String command = args[0];
switch (command) {
case "repin"
:
repin();
break;
default
:
printError(out,
String
.format("Unk
nown pinner command
: %s
. Supported commands
: repin",
command));
resultReceiver
.send(-1, null);
return;
}
resultReceiver
.send(0, null);
}
@EnforcePerm
ission(andro
id.Manifest
.perm
ission
.DUMP)
@Overr
ide
public L
ist<PinnedFileStat> getPinnerStats() {
getPinnerStats_enforcePerm
ission();
return PinnerService
.th
is.getPinnerStats();
}
}
final static class PinRange {
int start;
int length;
}
/**
* Represents an app that was pinned
.
*/
private final class PinnedApp {
/**
*
The u
id of
the package being pinned
. Th
is stays constant while
the package stays
* installed
.
*/
final int u
id;
/** Whe
ther it
is currently active, i
.e
. there
is a running process from that package
. */
boolean active;
/** L
ist of pinned files
. */
final ArrayL
ist<PinnedFile> mFiles = new ArrayL
ist<>();
private PinnedApp(ApplicationInfo appInfo) {
u
id = appInfo
.u
id;
active = mAmInternal
.isU
idActive(u
id);
}
}
final class PinnerHandler extends Handler {
static final int PIN_ONSTART_MSG = 4001;
public PinnerHandler(Looper looper) {
super(looper, null, true);
}
@Overr
ide
public vo
id handleMessage(Message msg) {
switch (msg
.what) {
case PIN_ONSTART_MSG
: {
handlePi
nOnStart();
} break;
default
:
super
.handleMessage(msg);
}
}
}
}
我想改这个java文件 在pi
nOptimizedDexDependencies函数中加上 files = DexFile
.getDexFileOutputPaths(pinnedFile
.file
Name, arch); 打印出所有的dex file文件名 并且看一下dex文件是否pin成功 这个push到手机里面去验证 加上日志打印
扫一扫
3683
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
