case BackupManager.ERROR_TRANSPORT_ABORTED:
return "Transport error";
case BackupManager.ERROR_TRANSPORT_PACKAGE_REJECTED:
- return "Transport rejected package";
+ return "Transport rejected package because it wasn't able to process it"
+ + " at the time";
case BackupManager.ERROR_AGENT_FAILURE:
return "Agent error";
case BackupManager.ERROR_TRANSPORT_QUOTA_EXCEEDED:
ArrayList<Integer> mAvailBackStackIndices;
ArrayList<OnBackStackChangedListener> mBackStackChangeListeners;
- CopyOnWriteArrayList<Pair<FragmentLifecycleCallbacks, Boolean>> mLifecycleCallbacks;
+ final CopyOnWriteArrayList<Pair<FragmentLifecycleCallbacks, Boolean>>
+ mLifecycleCallbacks = new CopyOnWriteArrayList<>();
int mCurState = Fragment.INITIALIZING;
FragmentHostCallback<?> mHost;
public void registerFragmentLifecycleCallbacks(FragmentLifecycleCallbacks cb,
boolean recursive) {
- if (mLifecycleCallbacks == null) {
- mLifecycleCallbacks = new CopyOnWriteArrayList<>();
- }
- mLifecycleCallbacks.add(new Pair(cb, recursive));
+ mLifecycleCallbacks.add(new Pair<>(cb, recursive));
}
public void unregisterFragmentLifecycleCallbacks(FragmentLifecycleCallbacks cb) {
- if (mLifecycleCallbacks == null) {
- return;
- }
-
synchronized (mLifecycleCallbacks) {
for (int i = 0, N = mLifecycleCallbacks.size(); i < N; i++) {
if (mLifecycleCallbacks.get(i).first == cb) {
.dispatchOnFragmentPreAttached(f, context, true);
}
}
- if (mLifecycleCallbacks == null) {
- return;
- }
for (Pair<FragmentLifecycleCallbacks, Boolean> p : mLifecycleCallbacks) {
if (!onlyRecursive || p.second) {
p.first.onFragmentPreAttached(this, f, context);
.dispatchOnFragmentAttached(f, context, true);
}
}
- if (mLifecycleCallbacks == null) {
- return;
- }
for (Pair<FragmentLifecycleCallbacks, Boolean> p : mLifecycleCallbacks) {
if (!onlyRecursive || p.second) {
p.first.onFragmentAttached(this, f, context);
.dispatchOnFragmentPreCreated(f, savedInstanceState, true);
}
}
- if (mLifecycleCallbacks == null) {
- return;
- }
for (Pair<FragmentLifecycleCallbacks, Boolean> p : mLifecycleCallbacks) {
if (!onlyRecursive || p.second) {
p.first.onFragmentPreCreated(this, f, savedInstanceState);
.dispatchOnFragmentCreated(f, savedInstanceState, true);
}
}
- if (mLifecycleCallbacks == null) {
- return;
- }
for (Pair<FragmentLifecycleCallbacks, Boolean> p : mLifecycleCallbacks) {
if (!onlyRecursive || p.second) {
p.first.onFragmentCreated(this, f, savedInstanceState);
.dispatchOnFragmentActivityCreated(f, savedInstanceState, true);
}
}
- if (mLifecycleCallbacks == null) {
- return;
- }
for (Pair<FragmentLifecycleCallbacks, Boolean> p : mLifecycleCallbacks) {
if (!onlyRecursive || p.second) {
p.first.onFragmentActivityCreated(this, f, savedInstanceState);
.dispatchOnFragmentViewCreated(f, v, savedInstanceState, true);
}
}
- if (mLifecycleCallbacks == null) {
- return;
- }
for (Pair<FragmentLifecycleCallbacks, Boolean> p : mLifecycleCallbacks) {
if (!onlyRecursive || p.second) {
p.first.onFragmentViewCreated(this, f, v, savedInstanceState);
.dispatchOnFragmentStarted(f, true);
}
}
- if (mLifecycleCallbacks == null) {
- return;
- }
for (Pair<FragmentLifecycleCallbacks, Boolean> p : mLifecycleCallbacks) {
if (!onlyRecursive || p.second) {
p.first.onFragmentStarted(this, f);
.dispatchOnFragmentResumed(f, true);
}
}
- if (mLifecycleCallbacks == null) {
- return;
- }
for (Pair<FragmentLifecycleCallbacks, Boolean> p : mLifecycleCallbacks) {
if (!onlyRecursive || p.second) {
p.first.onFragmentResumed(this, f);
.dispatchOnFragmentPaused(f, true);
}
}
- if (mLifecycleCallbacks == null) {
- return;
- }
for (Pair<FragmentLifecycleCallbacks, Boolean> p : mLifecycleCallbacks) {
if (!onlyRecursive || p.second) {
p.first.onFragmentPaused(this, f);
.dispatchOnFragmentStopped(f, true);
}
}
- if (mLifecycleCallbacks == null) {
- return;
- }
for (Pair<FragmentLifecycleCallbacks, Boolean> p : mLifecycleCallbacks) {
if (!onlyRecursive || p.second) {
p.first.onFragmentStopped(this, f);
.dispatchOnFragmentSaveInstanceState(f, outState, true);
}
}
- if (mLifecycleCallbacks == null) {
- return;
- }
for (Pair<FragmentLifecycleCallbacks, Boolean> p : mLifecycleCallbacks) {
if (!onlyRecursive || p.second) {
p.first.onFragmentSaveInstanceState(this, f, outState);
.dispatchOnFragmentViewDestroyed(f, true);
}
}
- if (mLifecycleCallbacks == null) {
- return;
- }
for (Pair<FragmentLifecycleCallbacks, Boolean> p : mLifecycleCallbacks) {
if (!onlyRecursive || p.second) {
p.first.onFragmentViewDestroyed(this, f);
.dispatchOnFragmentDestroyed(f, true);
}
}
- if (mLifecycleCallbacks == null) {
- return;
- }
for (Pair<FragmentLifecycleCallbacks, Boolean> p : mLifecycleCallbacks) {
if (!onlyRecursive || p.second) {
p.first.onFragmentDestroyed(this, f);
.dispatchOnFragmentDetached(f, true);
}
}
- if (mLifecycleCallbacks == null) {
- return;
- }
for (Pair<FragmentLifecycleCallbacks, Boolean> p : mLifecycleCallbacks) {
if (!onlyRecursive || p.second) {
p.first.onFragmentDetached(this, f);
};
/**
+ * Keys we no longer back up under the current schema, but want to continue to
+ * process when restoring historical backup datasets.
+ *
+ * @hide
+ */
+ public static final String[] LEGACY_RESTORE_SETTINGS = {
+ };
+
+ /**
* These are all public system settings
*
* @hide
NOTIFICATION_BADGING
};
+ /** @hide */
+ public static final String[] LEGACY_RESTORE_SETTINGS = {
+ };
+
/**
* These entries are considered common between the personal and the managed profile,
* since the managed profile doesn't get to change them.
BLUETOOTH_ON
};
+ /** @hide */
+ public static final String[] LEGACY_RESTORE_SETTINGS = {
+ };
+
private static final ContentProviderHolder sProviderHolder =
new ContentProviderHolder(CONTENT_URI);
return 0f;
}
+ final boolean needsSpanMeasurement;
if (mSpanned == null) {
+ needsSpanMeasurement = false;
+ } else {
+ mMetricAffectingSpanSpanSet.init(mSpanned, mStart + start, mStart + limit);
+ mCharacterStyleSpanSet.init(mSpanned, mStart + start, mStart + limit);
+ needsSpanMeasurement = mMetricAffectingSpanSpanSet.numberOfSpans != 0
+ || mCharacterStyleSpanSet.numberOfSpans != 0;
+ }
+
+ if (!needsSpanMeasurement) {
final TextPaint wp = mWorkPaint;
wp.set(mPaint);
wp.setHyphenEdit(adjustHyphenEdit(start, limit, wp.getHyphenEdit()));
y, bottom, fmi, needWidth, measureLimit, null);
}
- mMetricAffectingSpanSpanSet.init(mSpanned, mStart + start, mStart + limit);
- mCharacterStyleSpanSet.init(mSpanned, mStart + start, mStart + limit);
-
// Shaping needs to take into account context up to metric boundaries,
// but rendering needs to take into account character style boundaries.
// So we iterate through metric runs to get metric bounds,
char useJitProfilesOptsBuf[sizeof("-Xjitsaveprofilinginfo:")-1 + PROPERTY_VALUE_MAX];
char jitprithreadweightOptBuf[sizeof("-Xjitprithreadweight:")-1 + PROPERTY_VALUE_MAX];
char jittransitionweightOptBuf[sizeof("-Xjittransitionweight:")-1 + PROPERTY_VALUE_MAX];
+ char hotstartupsamplesOptsBuf[sizeof("-Xps-hot-startup-method-samples:")-1 + PROPERTY_VALUE_MAX];
char gctypeOptsBuf[sizeof("-Xgc:")-1 + PROPERTY_VALUE_MAX];
char backgroundgcOptsBuf[sizeof("-XX:BackgroundGC=")-1 + PROPERTY_VALUE_MAX];
char heaptargetutilizationOptsBuf[sizeof("-XX:HeapTargetUtilization=")-1 + PROPERTY_VALUE_MAX];
jittransitionweightOptBuf,
"-Xjittransitionweight:");
+ /*
+ * Profile related options.
+ */
+ parseRuntimeOption("dalvik.vm.hot-startup-method-samples", hotstartupsamplesOptsBuf,
+ "-Xps-hot-startup-method-samples:");
+
property_get("ro.config.low_ram", propBuf, "");
if (strcmp(propBuf, "true") == 0) {
addOption("-XX:LowMemoryMode");
<permission android:name="android.permission.TV_VIRTUAL_REMOTE_CONTROLLER"
android:protectionLevel="signature|privileged" />
+ <!-- Allows an application to change HDMI CEC active source.
+ <p>Not for use by third-party applications.
+ @hide -->
+ <permission android:name="android.permission.CHANGE_HDMI_CEC_ACTIVE_SOURCE"
+ android:protectionLevel="signature|privileged" />
+
<!-- @SystemApi Allows an application to modify parental controls
<p>Not for use by third-party applications.
@hide -->
" U+" + Integer.toHexString(vs) + ")";
final String testString =
codePointsToString(new int[] {testCase.mBaseCodepoint, vs});
- if (testCase.mVariationSelectors.contains(vs)) {
+ if (vs == 0xFE0E // U+FE0E is the text presentation emoji. hasGlyph is expected to
+ // return true for that variation selector if the font has the base
+ // glyph.
+ || testCase.mVariationSelectors.contains(vs)) {
assertTrue(signature + " is expected to be true", p.hasGlyph(testString));
} else {
assertFalse(signature + " is expected to be false", p.hasGlyph(testString));
*
* @hide
*/
-//@SystemApi
+// @SystemApi
public class LowpanBeaconInfo extends LowpanIdentity {
private int mRssi = UNKNOWN;
}
public Collection<Integer> getFlags() {
- return mFlags.clone();
+ return (Collection<Integer>) mFlags.clone();
}
public boolean isFlagSet(int flag) {
package android.net.lowpan;
-
/** Provides detailed information about a given channel. */
-//@SystemApi
+// @SystemApi
public class LowpanChannelInfo {
public static final int UNKNOWN_POWER = Integer.MAX_VALUE;
- //////////////////////////////////////////////////////////////////////////
// Instance Variables
private String mName = null;
private float mSpectrumBandwidth = 0.0f;
private int mMaxTransmitPower = UNKNOWN_POWER;
- //////////////////////////////////////////////////////////////////////////
// Public Getters and Setters
public String getName() {
*
* @hide
*/
-//@SystemApi
+// @SystemApi
public abstract class LowpanCommissioningSession {
public LowpanCommissioningSession() {}
*
* @hide
*/
- //@SystemApi
+ // @SystemApi
public class Callback {
public void onReceiveFromCommissioner(@NonNull byte[] packet) {};
package android.net.lowpan;
-
import java.util.Map;
/**
*
* @hide
*/
-//@SystemApi
+// @SystemApi
public class LowpanCredential {
public static final int UNSPECIFIED_KEY_INDEX = 0;
void addToMap(Map<String, Object> parameters) throws LowpanException {
if (isMasterKey()) {
LowpanProperties.KEY_NETWORK_MASTER_KEY.putInMap(parameters, getMasterKey());
- LowpanProperties.KEY_NETWORK_MASTER_KEY_INDEX.putInMap(
- parameters, getMasterKeyIndex());
+ LowpanProperties.KEY_NETWORK_MASTER_KEY_INDEX.putInMap(parameters, getMasterKeyIndex());
} else {
throw new LowpanException("Unsupported Network Credential");
}
package android.net.lowpan;
-
/**
* Describes the result from one channel of an energy scan.
*
* @hide
*/
-//@SystemApi
+// @SystemApi
public class LowpanEnergyScanResult {
public static final int UNKNOWN = Integer.MAX_VALUE;
* @see LowpanInterface
* @hide
*/
-//@SystemApi
+// @SystemApi
public class LowpanException extends AndroidException {
// Make the eclipse warning about serializable exceptions go away
private static final long serialVersionUID = 0x31863cbe562b0e11l; // randomly generated
*
* @hide
*/
-//@SystemApi
+// @SystemApi
public class LowpanIdentity {
- //////////////////////////////////////////////////////////////////////////
// Constants
/** @hide */
public static final int UNKNOWN = Integer.MAX_VALUE;
- //////////////////////////////////////////////////////////////////////////
// Builder
/** @hide */
- //@SystemApi
+ // @SystemApi
public static class Builder {
private final LowpanIdentity identity = new LowpanIdentity();
LowpanIdentity() {}
- //////////////////////////////////////////////////////////////////////////
// Instance Variables
private String mName = null;
private int mPanid = UNKNOWN;
private int mChannel = UNKNOWN;
- //////////////////////////////////////////////////////////////////////////
// Public Getters and Setters
public String getName() {
LowpanProperties.KEY_NETWORK_NAME.putInMap(parameters, networkInfo.getName());
}
if (networkInfo.getPanid() != LowpanIdentity.UNKNOWN) {
- LowpanProperties.KEY_NETWORK_PANID.putInMap(
- parameters, networkInfo.getPanid());
+ LowpanProperties.KEY_NETWORK_PANID.putInMap(parameters, networkInfo.getPanid());
}
if (networkInfo.getChannel() != LowpanIdentity.UNKNOWN) {
- LowpanProperties.KEY_CHANNEL.putInMap(
- parameters, networkInfo.getChannel());
+ LowpanProperties.KEY_CHANNEL.putInMap(parameters, networkInfo.getChannel());
}
if (networkInfo.getXpanid() != null) {
LowpanProperties.KEY_NETWORK_XPANID.putInMap(parameters, networkInfo.getXpanid());
*
* @hide
*/
-//@SystemApi
+// @SystemApi
public class LowpanInterface {
private static final String TAG = LowpanInterface.class.getSimpleName();
*
* @hide
*/
- //@SystemApi
+ // @SystemApi
public abstract static class Callback {
public void onConnectedChanged(boolean value) {}
LowpanException.throwAsPublicException(t);
}
- //////////////////////////////////////////////////////////////////////////
// Private Property Helpers
void setProperties(Map properties) throws LowpanException {
boolean getPropertyAsBoolean(LowpanProperty<Boolean> key) throws LowpanException {
Boolean value = getProperty(key);
- return (value != null) ? value : 0;
+ return (value != null) ? value : false;
}
- //////////////////////////////////////////////////////////////////////////
// Public Actions
/**
}
}
- //////////////////////////////////////////////////////////////////////////
// Public Getters and Setters
/**
return "";
}
- /**
- * Indicates if the interface is enabled or disabled.
- *
- * @see #setEnabled
- * @see android.net.lowpan.LowpanException#LOWPAN_DISABLED
- */
- public boolean isEnabled() {
+ /**
+ * Indicates if the interface is enabled or disabled.
+ *
+ * @see #setEnabled
+ * @see android.net.lowpan.LowpanException#LOWPAN_DISABLED
+ */
+ public boolean isEnabled() {
try {
return getPropertyAsBoolean(LowpanProperties.KEY_INTERFACE_ENABLED);
} catch (LowpanException x) {
}
}
- /**
- * Enables or disables the LoWPAN interface. When disabled, the interface is put into a low-power
- * state and all commands that require the NCP to be queried will fail with {@link
- * android.net.lowpan.LowpanException#LOWPAN_DISABLED}.
- *
- * @see #isEnabled
- * @see android.net.lowpan.LowpanException#LOWPAN_DISABLED
- * @hide
- */
- public void setEnabled(boolean enabled) throws LowpanException {
+ /**
+ * Enables or disables the LoWPAN interface. When disabled, the interface is put into a
+ * low-power state and all commands that require the NCP to be queried will fail with {@link
+ * android.net.lowpan.LowpanException#LOWPAN_DISABLED}.
+ *
+ * @see #isEnabled
+ * @see android.net.lowpan.LowpanException#LOWPAN_DISABLED
+ * @hide
+ */
+ public void setEnabled(boolean enabled) throws LowpanException {
setProperty(LowpanProperties.KEY_INTERFACE_ENABLED, enabled);
}
setProperties(map);
}
- //////////////////////////////////////////////////////////////////////////
// Listener Support
/**
public void registerCallback(@NonNull Callback cb, @Nullable Handler handler) {
ILowpanInterfaceListener.Stub listenerBinder =
new ILowpanInterfaceListener.Stub() {
- public void onPropertiesChanged(Map<String, Object> properties) {
+ public void onPropertiesChanged(Map properties) {
Runnable runnable =
new Runnable() {
@Override
*/
public void unregisterCallback(Callback cb) {
int hashCode = System.identityHashCode(cb);
- ILowpanInterfaceListener listenerBinder = mListenerMap.get(hashCode);
+ synchronized (mListenerMap) {
+ ILowpanInterfaceListener listenerBinder = mListenerMap.get(hashCode);
- if (listenerBinder != null) {
- synchronized (mListenerMap) {
+ if (listenerBinder != null) {
mListenerMap.remove(hashCode);
- }
- try {
- mBinder.removeListener(listenerBinder);
- } catch (RemoteException x) {
- // Catch and ignore all binder exceptions
- Log.e(TAG, x.toString());
+
+ try {
+ mBinder.removeListener(listenerBinder);
+ } catch (RemoteException x) {
+ // Catch and ignore all binder exceptions
+ Log.e(TAG, x.toString());
+ }
}
}
}
- //////////////////////////////////////////////////////////////////////////
- // Active and Passive Scanning
+ // Active and Passive Scanning
- /**
- * Creates a new {@link android.net.lowpan.LowpanScanner} object for this interface.
- *
- * <p>This method allocates a new unique object for each call.
- *
- * @see android.net.lowpan.LowpanScanner
- */
- public @NonNull LowpanScanner createScanner() {
+ /**
+ * Creates a new {@link android.net.lowpan.LowpanScanner} object for this interface.
+ *
+
* <p>This method allocates a new unique object for each call.
+ *
+ * @see android.net.lowpan.LowpanScanner
+ */
+ public @NonNull LowpanScanner createScanner() {
return new LowpanScanner(mBinder);
}
- //////////////////////////////////////////////////////////////////////////
// Route Management
/**
*
* @hide
*/
-//@SystemApi
+// @SystemApi
public class LowpanManager {
private static final String TAG = LowpanManager.class.getSimpleName();
- //////////////////////////////////////////////////////////////////////////
- // Public Classes
-
/** @hide */
- //@SystemApi
+ // @SystemApi
public abstract static class Callback {
- public void onInterfaceAdded(LowpanInterface lowpan_interface) {}
+ public void onInterfaceAdded(LowpanInterface lowpanInterface) {}
- public void onInterfaceRemoved(LowpanInterface lowpan_interface) {}
+ public void onInterfaceRemoved(LowpanInterface lowpanInterface) {}
}
- //////////////////////////////////////////////////////////////////////////
- // Instance Variables
-
+ private Context mContext;
private ILowpanManager mManager;
private HashMap<Integer, ILowpanManagerListener> mListenerMap = new HashMap<>();
- //////////////////////////////////////////////////////////////////////////
-
private static LowpanManager sSingletonInstance;
- //////////////////////////////////////////////////////////////////////////
// Static Methods
/** Returns a reference to the LowpanManager object, allocating it if necessary. */
return sSingletonInstance;
}
- //////////////////////////////////////////////////////////////////////////
// Constructors
/**
*/
private LowpanManager() {}
- //////////////////////////////////////////////////////////////////////////
// Private Methods
/**
* Returns a reference to the ILowpanManager interface, provided by the LoWPAN Manager Service.
*/
@Nullable
- private ILowpanManager getILowpanManager() {
+ private synchronized ILowpanManager getILowpanManager() {
+ // Use a local reference of this object for thread safety.
ILowpanManager manager = mManager;
+
if (manager == null) {
IBinder serviceBinder =
new ServiceManager().getService(ILowpanManager.LOWPAN_SERVICE_NAME);
- mManager = manager = ILowpanManager.Stub.asInterface(serviceBinder);
+
+ manager = ILowpanManager.Stub.asInterface(serviceBinder);
+
+ mManager = manager;
// Add any listeners
synchronized (mListenerMap) {
- for (Integer hashObj : mListenerMap.keySet()) {
+ for (ILowpanManagerListener listener : mListenerMap.values()) {
try {
- manager.addListener(mListenerMap.get(hashObj));
+ manager.addListener(listener);
+
} catch (RemoteException x) {
// Consider any failure here as implying the manager is defunct
- mManager = manager = null;
+ mManager = null;
+ manager = null;
}
}
}
return manager;
}
- //////////////////////////////////////////////////////////////////////////
// Public Methods
/**
manager = getILowpanManager();
}
}
+
return ret;
}
@Nullable
public LowpanInterface getInterface() {
String[] ifaceList = getInterfaceList();
- if (ifaceList != null && ifaceList.length > 0) {
+ if (ifaceList.length > 0) {
return getInterface(ifaceList[0]);
}
return null;
public String[] getInterfaceList() {
ILowpanManager manager = getILowpanManager();
- if (manager != null) {
+ // Maximum number of tries is two. We should only try
+ // more than once if our manager has died or there
+ // was some sort of AIDL buffer full event.
+ for (int i = 0; i < 2 && manager != null; i++) {
try {
return manager.getInterfaceList();
-
} catch (RemoteException x) {
// In all of the cases when we get this exception, we reconnect and try again
mManager = null;
- try {
- manager = getILowpanManager();
- if (manager != null) {
- return manager.getInterfaceList();
- }
- } catch (RemoteException ex) {
- // Something weird is going on, so we log it
- // and fall back thru to returning an empty array.
- Log.e(TAG, ex.toString());
- mManager = null;
- }
+ manager = getILowpanManager();
}
}
throws LowpanException {
ILowpanManagerListener.Stub listenerBinder =
new ILowpanManagerListener.Stub() {
- public void onInterfaceAdded(ILowpanInterface lowpan_interface) {
+ public void onInterfaceAdded(ILowpanInterface lowpanInterface) {
Runnable runnable =
new Runnable() {
@Override
public void run() {
cb.onInterfaceAdded(
LowpanInterface.getInterfaceFromBinder(
- lowpan_interface.asBinder()));
+ lowpanInterface.asBinder()));
}
};
}
}
- public void onInterfaceRemoved(ILowpanInterface lowpan_interface) {
+ public void onInterfaceRemoved(ILowpanInterface lowpanInterface) {
Runnable runnable =
new Runnable() {
@Override
public void run() {
cb.onInterfaceRemoved(
LowpanInterface.getInterfaceFromBinder(
- lowpan_interface.asBinder()));
+ lowpanInterface.asBinder()));
}
};
*
* @hide
*/
-//@SystemApi
+// @SystemApi
public class LowpanProvision {
- //////////////////////////////////////////////////////////////////////////
// Builder
/** @hide */
- //@SystemApi
+ // @SystemApi
public static class Builder {
private final LowpanProvision provision = new LowpanProvision();
private LowpanProvision() {}
- //////////////////////////////////////////////////////////////////////////
// Instance Variables
private LowpanIdentity mIdentity = new LowpanIdentity();
private LowpanCredential mCredential = null;
- //////////////////////////////////////////////////////////////////////////
// Public Getters and Setters
@NonNull
return mCredential;
}
- //////////////////////////////////////////////////////////////////////////
// LoWPAN-Internal Methods
static void addToMap(Map<String, Object> parameters, LowpanProvision provision)
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
-import java.util.List;
import java.util.Map;
/**
* @see LowpanInterface
* @hide
*/
-//@SystemApi
+// @SystemApi
public class LowpanScanner {
private static final String TAG = LowpanInterface.class.getSimpleName();
- //////////////////////////////////////////////////////////////////////////
// Public Classes
/**
*
* @hide
*/
- //@SystemApi
+ // @SystemApi
public abstract static class Callback {
public void onNetScanBeacon(LowpanBeaconInfo beacon) {}
public void onScanFinished() {}
}
- //////////////////////////////////////////////////////////////////////////
// Instance Variables
private ILowpanInterface mBinder;
private Callback mCallback = null;
private Handler mHandler = null;
- private List<Integer> mChannelMask = null;
+ private ArrayList<Integer> mChannelMask = null;
private int mTxPower = Integer.MAX_VALUE;
- //////////////////////////////////////////////////////////////////////////
// Constructors/Accessors and Exception Glue
LowpanScanner(@NonNull ILowpanInterface binder) {
}
/** Sets an instance of {@link LowpanScanner.Callback} to receive events. */
- public void setCallback(@Nullable Callback cb, @Nullable Handler handler) {
+ public synchronized void setCallback(@Nullable Callback cb, @Nullable Handler handler) {
mCallback = cb;
mHandler = handler;
}
* @return the current channel mask, or <code>null</code> if no channel mask is currently set.
*/
public @Nullable Collection<Integer> getChannelMask() {
- return mChannelMask.clone();
+ return (Collection<Integer>) mChannelMask.clone();
}
/**
ILowpanNetScanCallback binderListener =
new ILowpanNetScanCallback.Stub() {
public void onNetScanBeacon(Map parameters) {
- Callback callback = mCallback;
- Handler handler = mHandler;
+ Callback callback;
+ Handler handler;
+
+ synchronized (LowpanScanner.this) {
+ callback = mCallback;
+ handler = mHandler;
+ }
if (callback == null) {
return;
}
- Runnable runnable = () -> callback.onNetScanBeacon(
- new LowpanBeaconInfo.Builder()
- .updateFromMap(parameters)
- .build());
+ Runnable runnable =
+ () ->
+ callback.onNetScanBeacon(
+ new LowpanBeaconInfo.Builder()
+ .updateFromMap(parameters)
+ .build());
if (handler != null) {
handler.post(runnable);
}
public void onNetScanFinished() {
- Callback callback = mCallback;
- Handler handler = mHandler;
+ Callback callback;
+ Handler handler;
+
+ synchronized (LowpanScanner.this) {
+ callback = mCallback;
+ handler = mHandler;
+ }
if (callback == null) {
return;
try {
mBinder.startNetScan(map, binderListener);
- } catch (ServiceSpecificException|RemoteException x) {
+ } catch (ServiceSpecificException | RemoteException x) {
LowpanException.throwAsPublicException(x);
}
}
return;
}
- Runnable runnable = () -> {
+ Runnable runnable =
+ () -> {
if (callback != null) {
LowpanEnergyScanResult result =
new LowpanEnergyScanResult();
import android.widget.ProgressBar;
import android.widget.TextView;
+import com.android.internal.logging.MetricsLogger;
+import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
+
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
private static final int SOCKET_TIMEOUT_MS = 10000;
- private enum Result { DISMISSED, UNWANTED, WANTED_AS_IS };
+ private enum Result {
+ DISMISSED(MetricsEvent.ACTION_CAPTIVE_PORTAL_LOGIN_RESULT_DISMISSED),
+ UNWANTED(MetricsEvent.ACTION_CAPTIVE_PORTAL_LOGIN_RESULT_UNWANTED),
+ WANTED_AS_IS(MetricsEvent.ACTION_CAPTIVE_PORTAL_LOGIN_RESULT_WANTED_AS_IS);
+
+ final int metricsEvent;
+ Result(int metricsEvent) { this.metricsEvent = metricsEvent; }
+ };
private URL mUrl;
private String mUserAgent;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
+
+ logMetricsEvent(MetricsEvent.ACTION_CAPTIVE_PORTAL_LOGIN_ACTIVITY);
+
mCm = ConnectivityManager.from(this);
mNetwork = getIntent().getParcelableExtra(ConnectivityManager.EXTRA_NETWORK);
mCaptivePortal = getIntent().getParcelableExtra(ConnectivityManager.EXTRA_CAPTIVE_PORTAL);
mCm.unregisterNetworkCallback(mNetworkCallback);
mNetworkCallback = null;
}
+ logMetricsEvent(result.metricsEvent);
switch (result) {
case DISMISSED:
mCaptivePortal.reportCaptivePortalDismissed();
@Override
public void onReceivedSslError(WebView view, SslErrorHandler handler, SslError error) {
+ logMetricsEvent(MetricsEvent.CAPTIVE_PORTAL_LOGIN_ACTIVITY_SSL_ERROR);
Log.w(TAG, "SSL error (error: " + error.getPrimaryError() + " host: " +
// Only show host to avoid leaking private info.
Uri.parse(error.getUrl()).getHost() + " certificate: " +
}
return url.getHost();
}
+
+ private void logMetricsEvent(int event) {
+ MetricsLogger.action(this, event, getPackageName());
+ }
}
package com.android.providers.settings;
+import android.annotation.Nullable;
import android.annotation.UserIdInt;
import android.app.backup.BackupAgentHelper;
import android.app.backup.BackupDataInput;
import android.net.Uri;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
-import android.os.Handler;
import android.os.ParcelFileDescriptor;
import android.os.UserHandle;
import android.provider.Settings;
Log.i(TAG, "restoreSettings: " + contentUri);
}
- // Figure out the white list and redirects to the global table.
+ // Figure out the white list and redirects to the global table. We restore anything
+ // in either the backup whitelist or the legacy-restore whitelist for this table.
final String[] whitelist;
if (contentUri.equals(Settings.Secure.CONTENT_URI)) {
- whitelist = Settings.Secure.SETTINGS_TO_BACKUP;
+ whitelist = concat(Settings.Secure.SETTINGS_TO_BACKUP,
+ Settings.Secure.LEGACY_RESTORE_SETTINGS);
} else if (contentUri.equals(Settings.System.CONTENT_URI)) {
- whitelist = Settings.System.SETTINGS_TO_BACKUP;
+ whitelist = concat(Settings.System.SETTINGS_TO_BACKUP,
+ Settings.System.LEGACY_RESTORE_SETTINGS);
} else if (contentUri.equals(Settings.Global.CONTENT_URI)) {
- whitelist = Settings.Global.SETTINGS_TO_BACKUP;
+ whitelist = concat(Settings.Global.SETTINGS_TO_BACKUP,
+ Settings.Global.LEGACY_RESTORE_SETTINGS);
} else {
throw new IllegalArgumentException("Unknown URI: " + contentUri);
}
}
}
+ private final String[] concat(String[] first, @Nullable String[] second) {
+ if (second == null || second.length == 0) {
+ return first;
+ }
+ final int firstLen = first.length;
+ final int secondLen = second.length;
+ String[] both = new String[firstLen + secondLen];
+ System.arraycopy(first, 0, both, 0, firstLen);
+ System.arraycopy(second, 0, both, firstLen, secondLen);
+ return both;
+ }
+
/**
* Restores the owner info enabled and other settings in LockSettings.
*
}
private final class UpgradeController {
- private static final int SETTINGS_VERSION = 145;
+ private static final int SETTINGS_VERSION = 146;
private final int mUserId;
}
if (currentVersion == 144) {
- // Version 145: Set the default value for WIFI_WAKEUP_AVAILABLE.
+ // Version 145: Removed
+ currentVersion = 145;
+ }
+
+ if (currentVersion == 145) {
+ // Version 146: Set the default value for WIFI_WAKEUP_AVAILABLE.
if (userId == UserHandle.USER_SYSTEM) {
final SettingsState globalSettings = getGlobalSettingsLocked();
final Setting currentSetting = globalSettings.getSettingLocked(
Settings.Global.WIFI_WAKEUP_AVAILABLE);
- if (currentSetting.isNull()) {
- final int defaultValue = getContext().getResources().getInteger(
- com.android.internal.R.integer.config_wifi_wakeup_available);
- globalSettings.insertSettingLocked(
- Settings.Global.WIFI_WAKEUP_AVAILABLE,
- String.valueOf(defaultValue),
- null, true, SettingsState.SYSTEM_PACKAGE_NAME);
- }
+ final int defaultValue = getContext().getResources().getInteger(
+ com.android.internal.R.integer.config_wifi_wakeup_available);
+ globalSettings.insertSettingLocked(
+ Settings.Global.WIFI_WAKEUP_AVAILABLE,
+ String.valueOf(defaultValue),
+ null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
- currentVersion = 145;
+ currentVersion = 146;
}
// vXXX: Add new settings above this point.
<dimen name="global_actions_top_padding">100dp</dimen>
+ <!-- the maximum offset in either direction that elements are moved horizontally to prevent
+ burn-in on AOD -->
+ <dimen name="burn_in_prevention_offset_x">8dp</dimen>
+
+ <!-- the maximum offset in either direction that elements are moved vertically to prevent
+ burn-in on AOD -->
+ <dimen name="burn_in_prevention_offset_y">50dp</dimen>
+
<dimen name="corner_size">16dp</dimen>
<dimen name="top_padding">0dp</dimen>
<dimen name="bottom_padding">48dp</dimen>
updateRelativeOffset();
}
+ public void setDarkOffsetX(int offsetX) {
+ mShelfIcons.setDarkOffsetX(offsetX);
+ }
+
private class ShelfState extends ExpandableViewState {
private float openedAmount;
private boolean hasItemsInStableShelf;
import com.android.systemui.statusbar.phone.StatusBar;
import com.android.systemui.statusbar.policy.BatteryController;
import com.android.systemui.statusbar.policy.UserSwitcherController;
-
+import com.android.keyguard.KeyguardUpdateMonitor;
+import com.android.systemui.classifier.FalsingLog;
+import com.android.systemui.classifier.FalsingManager;
+import com.android.systemui.Prefs;
+
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.util.Map;
/**
* A status bar (and navigation bar) tailored for the automotive use case.
*/
private ConnectedDeviceSignalController mConnectedDeviceSignalController;
private CarNavigationBarView mNavigationBarView;
+ private final Object mQueueLock = new Object();
@Override
public void start() {
super.start();
}
@Override
+ public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
+ //When executing dump() funciton simultaneously, we need to serialize them
+ //to get mStackScroller's position correctly.
+ synchronized (mQueueLock) {
+ pw.println(" mStackScroller: " + viewInfo(mStackScroller));
+ pw.println(" mStackScroller: " + viewInfo(mStackScroller)
+ + " scroll " + mStackScroller.getScrollX()
+ + "," + mStackScroller.getScrollY());
+ }
+
+ pw.print(" mTaskStackListener="); pw.println(mTaskStackListener);
+ pw.print(" mController=");
+ pw.println(mController);
+ pw.print(" mFullscreenUserSwitcher="); pw.println(mFullscreenUserSwitcher);
+ pw.print(" mCarBatteryController=");
+ pw.println(mCarBatteryController);
+ pw.print(" mBatteryMeterView=");
+ pw.println(mBatteryMeterView);
+ pw.print(" mConnectedDeviceSignalController=");
+ pw.println(mConnectedDeviceSignalController);
+ pw.print(" mNavigationBarView=");
+ pw.println(mNavigationBarView);
+
+ if (KeyguardUpdateMonitor.getInstance(mContext) != null) {
+ KeyguardUpdateMonitor.getInstance(mContext).dump(fd, pw, args);
+ }
+
+ FalsingManager.getInstance(mContext).dump(pw);
+ FalsingLog.dump(pw);
+
+ pw.println("SharedPreferences:");
+ for (Map.Entry<String, ?> entry : Prefs.getAll(mContext).entrySet()) {
+ pw.print(" "); pw.print(entry.getKey()); pw.print("="); pw.println(entry.getValue());
+ }
+ }
+
+ @Override
public NavigationBarView getNavigationBarView() {
return mNavigationBarView;
}
package com.android.systemui.statusbar.phone;
+import static com.android.systemui.statusbar.notification.NotificationUtils.interpolate;
+
import android.content.res.Resources;
import android.graphics.Path;
import android.view.animation.AccelerateInterpolator;
import android.view.animation.PathInterpolator;
import com.android.systemui.R;
-import com.android.systemui.statusbar.notification.NotificationUtils;
/**
* Utility class to calculate the clock position and top padding of notifications on Keyguard.
private static final float CLOCK_ADJ_TOP_PADDING_MULTIPLIER_MIN = 1.4f;
private static final float CLOCK_ADJ_TOP_PADDING_MULTIPLIER_MAX = 3.2f;
+ private static final long MILLIS_PER_MINUTES = 1000 * 60;
+ private static final float BURN_IN_PREVENTION_PERIOD_Y = 521;
+ private static final float BURN_IN_PREVENTION_PERIOD_X = 83;
+
private int mClockNotificationsMarginMin;
private int mClockNotificationsMarginMax;
private float mClockYFractionMin;
private int mKeyguardStatusHeight;
private float mEmptyDragAmount;
private float mDensity;
+ private int mBurnInPreventionOffsetX;
+ private int mBurnInPreventionOffsetY;
/**
* The number (fractional) of notifications the "more" card counts when calculating how many
(float) res.getDimensionPixelSize(R.dimen.notification_shelf_height) /
res.getDimensionPixelSize(R.dimen.notification_min_height);
mDensity = res.getDisplayMetrics().density;
+ mBurnInPreventionOffsetX = res.getDimensionPixelSize(
+ R.dimen.burn_in_prevention_offset_x);
+ mBurnInPreventionOffsetY = res.getDimensionPixelSize(
+ R.dimen.burn_in_prevention_offset_y);
}
public void setup(int maxKeyguardNotifications, int maxPanelHeight, float expandedHeight,
y + getClockNotificationsPadding() + mKeyguardStatusHeight);
result.clockAlpha = getClockAlpha(result.clockScale);
- result.stackScrollerPadding = (int) NotificationUtils.interpolate(
+ result.stackScrollerPadding = (int) interpolate(
result.stackScrollerPadding,
mClockBottom + y,
mDarkAmount);
+
+ result.clockX = (int) interpolate(0, burnInPreventionOffsetX(), mDarkAmount);
}
private float getClockScale(int notificationPadding, int clockY, int startPadding) {
private int getClockY() {
// Dark: Align the bottom edge of the clock at one third:
// clockBottomEdge = result - mKeyguardStatusHeight / 2 + mClockBottom
- float clockYDark = (0.33f * mHeight + (float) mKeyguardStatusHeight / 2 - mClockBottom);
+ float clockYDark = (0.33f * mHeight + (float) mKeyguardStatusHeight / 2 - mClockBottom)
+ + burnInPreventionOffsetY();
float clockYRegular = getClockYFraction() * mHeight;
- return (int) NotificationUtils.interpolate(clockYRegular, clockYDark, mDarkAmount);
+ return (int) interpolate(clockYRegular, clockYDark, mDarkAmount);
+ }
+
+ private float burnInPreventionOffsetY() {
+ return zigzag(System.currentTimeMillis() / MILLIS_PER_MINUTES,
+ mBurnInPreventionOffsetY * 2,
+ BURN_IN_PREVENTION_PERIOD_Y)
+ - mBurnInPreventionOffsetY;
+ }
+
+ private float burnInPreventionOffsetX() {
+ return zigzag(System.currentTimeMillis() / MILLIS_PER_MINUTES,
+ mBurnInPreventionOffsetX * 2,
+ BURN_IN_PREVENTION_PERIOD_X)
+ - mBurnInPreventionOffsetX;
+ }
+
+ /**
+ * Implements a continuous, piecewise linear, periodic zig-zag function
+ *
+ * Can be thought of as a linear approximation of abs(sin(x)))
+ *
+ * @param period period of the function, ie. zigzag(x + period) == zigzag(x)
+ * @param amplitude maximum value of the function
+ * @return a value between 0 and amplitude
+ */
+ private float zigzag(float x, float amplitude, float period) {
+ float xprime = (x % period) / (period / 2);
+ float interpolationAmount = (xprime <= 1) ? xprime : (2 - xprime);
+ return interpolate(0, amplitude, interpolationAmount);
}
private float getClockYExpansionAdjustment() {
* the padding, but not the overall panel size.
*/
public int stackScrollerPaddingAdjustment;
+
+ /** The x translation of the clock. */
+ public int clockX;
}
}
private boolean mDisallowNextAnimation;
private boolean mAnimationsEnabled = true;
private ArrayMap<String, ArrayList<StatusBarIcon>> mReplacingIcons;
+ private int mDarkOffsetX;
public NotificationIconContainer(Context context, AttributeSet attrs) {
super(context, attrs);
iconState.xTranslation = getWidth() - iconState.xTranslation - view.getWidth();
}
}
+
+ if (mDark && mDarkOffsetX != 0) {
+ for (int i = 0; i < childCount; i++) {
+ View view = getChildAt(i);
+ IconState iconState = mIconStates.get(view);
+ iconState.xTranslation += mDarkOffsetX;
+ }
+ }
}
private float getLayoutEnd() {
mAnimationsEnabled = enabled;
}
+ public void setDarkOffsetX(int offsetX) {
+ mDarkOffsetX = offsetX;
+ }
+
public void setReplacingIcons(ArrayMap<String, ArrayList<StatusBarIcon>> replacingIcons) {
mReplacingIcons = replacingIcons;
}
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
import android.animation.ObjectAnimator;
import android.animation.ValueAnimator;
import android.app.ActivityManager;
import android.view.WindowInsets;
import android.view.accessibility.AccessibilityEvent;
import android.widget.FrameLayout;
-import android.widget.TextView;
+
import com.android.internal.logging.MetricsLogger;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.keyguard.KeyguardStatusView;
import com.android.systemui.DejankUtils;
-import com.android.systemui.Dependency;
import com.android.systemui.Interpolators;
import com.android.systemui.R;
-import com.android.systemui.SystemUIFactory;
import com.android.systemui.classifier.FalsingManager;
import com.android.systemui.fragments.FragmentHostManager;
import com.android.systemui.fragments.FragmentHostManager.FragmentListener;
import com.android.systemui.statusbar.policy.HeadsUpManager;
import com.android.systemui.statusbar.policy.KeyguardUserSwitcher;
import com.android.systemui.statusbar.policy.OnHeadsUpChangedListener;
-import com.android.systemui.statusbar.policy.UserInfoController;
import com.android.systemui.statusbar.stack.NotificationStackScrollLayout;
import com.android.systemui.statusbar.stack.StackStateAnimator;
private int mUnlockMoveDistance;
private float mEmptyDragAmount;
- private ObjectAnimator mClockAnimator;
- private int mClockAnimationTarget = -1;
+ private Animator mClockAnimator;
+ private int mClockAnimationTargetX = Integer.MIN_VALUE;
+ private int mClockAnimationTargetY = Integer.MIN_VALUE;
private int mTopPaddingAdjustment;
private KeyguardClockPositionAlgorithm mClockPositionAlgorithm =
new KeyguardClockPositionAlgorithm();
mDarkAmount);
mClockPositionAlgorithm.run(mClockPositionResult);
if (animate || mClockAnimator != null) {
- startClockAnimation(mClockPositionResult.clockY);
+ startClockAnimation(mClockPositionResult.clockX, mClockPositionResult.clockY);
} else {
+ mKeyguardStatusView.setX(mClockPositionResult.clockX);
mKeyguardStatusView.setY(mClockPositionResult.clockY);
}
updateClock(mClockPositionResult.clockAlpha, mClockPositionResult.clockScale);
mTopPaddingAdjustment = mClockPositionResult.stackScrollerPaddingAdjustment;
}
mNotificationStackScroller.setIntrinsicPadding(stackScrollerPadding);
+ mNotificationStackScroller.setDarkShelfOffsetX(mClockPositionResult.clockX);
requestScrollerTopPaddingUpdate(animate);
}
return count;
}
- private void startClockAnimation(int y) {
- if (mClockAnimationTarget == y) {
+ private void startClockAnimation(int x, int y) {
+ if (mClockAnimationTargetX == x && mClockAnimationTargetY == y) {
return;
}
- mClockAnimationTarget = y;
+ mClockAnimationTargetX = x;
+ mClockAnimationTargetY = y;
getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
@Override
public boolean onPreDraw() {
mClockAnimator.removeAllListeners();
mClockAnimator.cancel();
}
- mClockAnimator = ObjectAnimator
- .ofFloat(mKeyguardStatusView, View.Y, mClockAnimationTarget);
+ AnimatorSet set = new AnimatorSet();
+ set.play(ObjectAnimator.ofFloat(
+ mKeyguardStatusView, View.Y, mClockAnimationTargetY))
+ .with(ObjectAnimator.ofFloat(
+ mKeyguardStatusView, View.X, mClockAnimationTargetX));
+ mClockAnimator = set;
mClockAnimator.setInterpolator(Interpolators.FAST_OUT_SLOW_IN);
mClockAnimator.setDuration(StackStateAnimator.ANIMATION_DURATION_STANDARD);
mClockAnimator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
mClockAnimator = null;
- mClockAnimationTarget = -1;
+ mClockAnimationTargetX = Integer.MIN_VALUE;
+ mClockAnimationTargetY = Integer.MIN_VALUE;
}
});
mClockAnimator.start();
public void refreshTime() {
mKeyguardStatusView.refreshTime();
+ if (mDarkAmount > 0) {
+ positionClockAndNotifications();
+ }
}
public void setStatusAccessibilityImportance(int mode) {
// If mAlwaysExpandNonGroupedNotification is false, then only expand the
// very first notification and if it's not a child of grouped notifications.
row.setSystemExpanded(mAlwaysExpandNonGroupedNotification
- || (visibleNotifications == 0 && !isChildNotification));
+ || (visibleNotifications == 0 && !isChildNotification
+ && !row.isLowPriority()));
}
entry.row.setShowAmbient(isDozing());
mHeadsUpGoingAwayAnimationsAllowed = headsUpGoingAwayAnimationsAllowed;
}
+ public void setDarkShelfOffsetX(int shelfOffsetX) {
+ mShelf.setDarkOffsetX(shelfOffsetX);
+ }
+
/**
* A listener that is notified when some child locations might have changed.
*/
// OS: O DR
SETTINGS_ASSIST_GESTURE_FIRST_TIME = 1012;
+ // CaptivePortalLoginActivity displays SSL error page
+ // CATEGORY: GLOBAL_SYSTEM_UI
+ // OS: O DR
+ CAPTIVE_PORTAL_LOGIN_ACTIVITY_SSL_ERROR = 1013;
+
// Add new aosp constants above this line.
// END OF AOSP CONSTANTS
}
@Override
public void setMainSession(IBinder sessionToken, int userId) {
+ if (mContext.checkCallingPermission(
+ android.Manifest.permission.CHANGE_HDMI_CEC_ACTIVE_SOURCE)
+ != PackageManager.PERMISSION_GRANTED) {
+ throw new SecurityException(
+ "The caller does not have CHANGE_HDMI_CEC_ACTIVE_SOURCE permission");
+ }
if (DEBUG) {
Slog.d(TAG, "setMainSession(sessionToken=" + sessionToken + ")");
}
static const char* sMajorVersion = "2";
// Update minor version whenever a feature or flag is added.
-static const char* sMinorVersion = "16";
+static const char* sMinorVersion = "17";
int PrintVersion() {
std::cerr << "Android Asset Packaging Tool (aapt) " << sMajorVersion << "."
# Android Asset Packaging Tool 2.0 (AAPT2) release notes
## Version 2.17
-### `aapt2 compile ...`
-- Fixed an issue where symlinks would not be followed when compiling PNGs. (bug 62144459)
+### `aapt2 ...`
+- Fixed issue where symlinks would not be followed when compiling PNGs. (bug 62144459)
- Fixed issue where overlays that declared `<add-resource>` did not compile. (bug 38355988)
+- Fixed issue where `%n` in a string resource was interpreted as a format argument. (bug 37132275)
+- Allow empty resources to compile, giving them a value of `""` or `@null`, depending on the
+ accepted formats. (bug 38425050)
+- Resources declared via `<item>` with no format attribute were changed to accept all
+ resource types. (bug 62260121)
+- Allow `<layout>` element under `<activity>` in AndroidManifest.xml. (bug 62189611)
+- Fix issue where `--no-version-vector` did not apply to `pathInterpolator` and `objectAnimator`.
+ (bug 62211148)
+- Fix issue where overlaid `<style>` would not be merged, and would replace the original resource
+ instead. This fix brings behavior in-line with AAPT. (bug 38355988)
## Version 2.16
### `aapt2 link ...`
OSDN Git Service
