Merge changes I59b6e04f,I55694d89 (9009eabb) · Commits · e / os / android_frameworks_base

core/java/android/net/metrics/DefaultNetworkEvent.java

+19 −60

Original line number	Diff line number	Diff line
		@@ -16,56 +16,26 @@

		package android.net.metrics;

		import static android.net.ConnectivityManager.NETID_UNSET;

		import android.net.NetworkCapabilities;
		import android.os.Parcel;
		import android.os.Parcelable;

		/**
		* An event recorded by ConnectivityService when there is a change in the default network.
		* {@hide}
		*/
		public final class DefaultNetworkEvent implements Parcelable {
		public class DefaultNetworkEvent {

		// The ID of the network that has become the new default or NETID_UNSET if none.
		public final int netId;
		public int netId = NETID_UNSET;
		// The list of transport types of the new default network, for example TRANSPORT_WIFI, as
		// defined in NetworkCapabilities.java.
		public final int[] transportTypes;
		public int[] transportTypes = new int[0];
		// The ID of the network that was the default before or NETID_UNSET if none.
		public final int prevNetId;
		public int prevNetId = NETID_UNSET;
		// Whether the previous network had IPv4/IPv6 connectivity.
		public final boolean prevIPv4;
		public final boolean prevIPv6;

		public DefaultNetworkEvent(int netId, int[] transportTypes,
		int prevNetId, boolean prevIPv4, boolean prevIPv6) {
		this.netId = netId;
		this.transportTypes = transportTypes;
		this.prevNetId = prevNetId;
		this.prevIPv4 = prevIPv4;
		this.prevIPv6 = prevIPv6;
		}

		private DefaultNetworkEvent(Parcel in) {
		this.netId = in.readInt();
		this.transportTypes = in.createIntArray();
		this.prevNetId = in.readInt();
		this.prevIPv4 = (in.readByte() > 0);
		this.prevIPv6 = (in.readByte() > 0);
		}

		@Override
		public void writeToParcel(Parcel out, int flags) {
		out.writeInt(netId);
		out.writeIntArray(transportTypes);
		out.writeInt(prevNetId);
		out.writeByte(prevIPv4 ? (byte) 1 : (byte) 0);
		out.writeByte(prevIPv6 ? (byte) 1 : (byte) 0);
		}

		@Override
		public int describeContents() {
		return 0;
		}
		public boolean prevIPv4;
		public boolean prevIPv6;

		@Override
		public String toString() {
		@@ -82,7 +52,7 @@ public final class DefaultNetworkEvent implements Parcelable {

		private String ipSupport() {
		if (prevIPv4 && prevIPv6) {
		return "DUAL";
		return "IPv4v6";
		}
		if (prevIPv6) {
		return "IPv6";
		@@ -92,15 +62,4 @@ public final class DefaultNetworkEvent implements Parcelable {
		}
		return "NONE";
		}

		public static final Parcelable.Creator<DefaultNetworkEvent> CREATOR
		= new Parcelable.Creator<DefaultNetworkEvent>() {
		public DefaultNetworkEvent createFromParcel(Parcel in) {
		return new DefaultNetworkEvent(in);
		}

		public DefaultNetworkEvent[] newArray(int size) {
		return new DefaultNetworkEvent[size];
		}
		};
		}

services/core/java/com/android/server/ConnectivityService.java

+8 −22

Original line number	Diff line number	Diff line
		@@ -71,7 +71,6 @@ import android.net.ProxyInfo;
		import android.net.RouteInfo;
		import android.net.UidRange;
		import android.net.Uri;
		import android.net.metrics.DefaultNetworkEvent;
		import android.net.metrics.IpConnectivityLog;
		import android.net.metrics.NetworkEvent;
		import android.net.util.MultinetworkPolicyTracker;
		@@ -129,6 +128,7 @@ import com.android.internal.util.XmlUtils;
		import com.android.server.LocalServices;
		import com.android.server.am.BatteryStatsService;
		import com.android.server.connectivity.DataConnectionStats;
		import com.android.server.connectivity.IpConnectivityMetrics;
		import com.android.server.connectivity.KeepaliveTracker;
		import com.android.server.connectivity.LingerMonitor;
		import com.android.server.connectivity.MockableSystemProperties;
		@@ -2283,7 +2283,7 @@ public class ConnectivityService extends IConnectivityManager.Stub
		// Let rematchAllNetworksAndRequests() below record a new default network event
		// if there is a fallback. Taken together, the two form a X -> 0, 0 -> Y sequence
		// whose timestamps tell how long it takes to recover a default network.
		logDefaultNetworkEvent(null, nai);
		metricsLogger().defaultNetworkMetrics().logDefaultNetworkEvent(null, nai);
		}
		notifyIfacesChangedForNetworkStats();
		// TODO - we shouldn't send CALLBACK_LOST to requests that can be satisfied
		@@ -5012,7 +5012,8 @@ public class ConnectivityService extends IConnectivityManager.Stub
		// Notify system services that this network is up.
		makeDefault(newNetwork);
		// Log 0 -> X and Y -> X default network transitions, where X is the new default.
		logDefaultNetworkEvent(newNetwork, oldDefaultNetwork);
		metricsLogger().defaultNetworkMetrics().logDefaultNetworkEvent(
		newNetwork, oldDefaultNetwork);
		// Have a new default network, release the transition wakelock in
		scheduleReleaseNetworkTransitionWakelock();
		}
		@@ -5571,25 +5572,10 @@ public class ConnectivityService extends IConnectivityManager.Stub
		return ServiceManager.checkService(name) != null;
		}

		private void logDefaultNetworkEvent(NetworkAgentInfo newNai, NetworkAgentInfo prevNai) {
		int newNetid = NETID_UNSET;
		int prevNetid = NETID_UNSET;
		int[] transports = new int[0];
		boolean hadIPv4 = false;
		boolean hadIPv6 = false;

		if (newNai != null) {
		newNetid = newNai.network.netId;
		transports = newNai.networkCapabilities.getTransportTypes();
		}
		if (prevNai != null) {
		prevNetid = prevNai.network.netId;
		final LinkProperties lp = prevNai.linkProperties;
		hadIPv4 = lp.hasIPv4Address() && lp.hasIPv4DefaultRoute();
		hadIPv6 = lp.hasGlobalIPv6Address() && lp.hasIPv6DefaultRoute();
		}

		mMetricsLog.log(new DefaultNetworkEvent(newNetid, transports, prevNetid, hadIPv4, hadIPv6));
		@VisibleForTesting
		protected IpConnectivityMetrics.Logger metricsLogger() {
		return checkNotNull(LocalServices.getService(IpConnectivityMetrics.Logger.class),
		"no IpConnectivityMetrics service");
		}

		private void logNetworkEvent(NetworkAgentInfo nai, int evtype) {

services/core/java/com/android/server/connectivity/DefaultNetworkMetrics.java

0 → 100644

+78 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2017 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package com.android.server.connectivity;

		import android.net.LinkProperties;
		import android.net.metrics.DefaultNetworkEvent;
		import android.net.metrics.IpConnectivityLog;

		import com.android.internal.annotations.GuardedBy;
		import com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.IpConnectivityEvent;

		import java.io.PrintWriter;
		import java.util.ArrayList;
		import java.util.List;

		/**
		* Tracks events related to the default network for the purpose of default network metrics.
		* {@hide}
		*/
		public class DefaultNetworkMetrics {

		private static final int ROLLING_LOG_SIZE = 64;

		// Event buffer used for metrics upload. The buffer is cleared when events are collected.
		@GuardedBy("this")
		private final List<DefaultNetworkEvent> mEvents = new ArrayList<>();

		public synchronized void listEvents(PrintWriter pw) {
		long localTimeMs = System.currentTimeMillis();
		for (DefaultNetworkEvent ev : mEvents) {
		pw.println(ev);
		}
		}

		public synchronized void listEventsAsProto(PrintWriter pw) {
		for (DefaultNetworkEvent ev : mEvents) {
		pw.print(IpConnectivityEventBuilder.toProto(ev));
		}
		}

		public synchronized void flushEvents(List<IpConnectivityEvent> out) {
		for (DefaultNetworkEvent ev : mEvents) {
		out.add(IpConnectivityEventBuilder.toProto(ev));
		}
		mEvents.clear();
		}

		public synchronized void logDefaultNetworkEvent(
		NetworkAgentInfo newNai, NetworkAgentInfo prevNai) {
		DefaultNetworkEvent ev = new DefaultNetworkEvent();
		if (newNai != null) {
		ev.netId = newNai.network().netId;
		ev.transportTypes = newNai.networkCapabilities.getTransportTypes();
		}
		if (prevNai != null) {
		ev.prevNetId = prevNai.network().netId;
		final LinkProperties lp = prevNai.linkProperties;
		ev.prevIPv4 = lp.hasIPv4Address() && lp.hasIPv4DefaultRoute();
		ev.prevIPv6 = lp.hasGlobalIPv6Address() && lp.hasIPv6DefaultRoute();
		}

		mEvents.add(ev);
		}
		}

services/core/java/com/android/server/connectivity/IpConnectivityEventBuilder.java

+12 −15

Original line number	Diff line number	Diff line
		@@ -132,6 +132,18 @@ final public class IpConnectivityEventBuilder {
		return out;
		}

		public static IpConnectivityEvent toProto(DefaultNetworkEvent in) {
		IpConnectivityLogClass.DefaultNetworkEvent ev =
		new IpConnectivityLogClass.DefaultNetworkEvent();
		ev.networkId = netIdOf(in.netId);
		ev.previousNetworkId = netIdOf(in.prevNetId);
		ev.transportTypes = in.transportTypes;
		ev.previousNetworkIpSupport = ipSupportOf(in);
		final IpConnectivityEvent out = buildEvent(in.netId, 0, null);
		out.setDefaultNetworkEvent(ev);
		return out;
		}

		private static IpConnectivityEvent buildEvent(int netId, long transports, String ifname) {
		final IpConnectivityEvent ev = new IpConnectivityEvent();
		ev.networkId = netId;
		@@ -164,11 +176,6 @@ final public class IpConnectivityEventBuilder {
		return true;
		}

		if (in instanceof DefaultNetworkEvent) {
		setDefaultNetworkEvent(out, (DefaultNetworkEvent) in);
		return true;
		}

		if (in instanceof NetworkEvent) {
		setNetworkEvent(out, (NetworkEvent) in);
		return true;
		@@ -225,16 +232,6 @@ final public class IpConnectivityEventBuilder {
		out.setIpReachabilityEvent(ipReachabilityEvent);
		}

		private static void setDefaultNetworkEvent(IpConnectivityEvent out, DefaultNetworkEvent in) {
		IpConnectivityLogClass.DefaultNetworkEvent defaultNetworkEvent =
		new IpConnectivityLogClass.DefaultNetworkEvent();
		defaultNetworkEvent.networkId = netIdOf(in.netId);
		defaultNetworkEvent.previousNetworkId = netIdOf(in.prevNetId);
		defaultNetworkEvent.transportTypes = in.transportTypes;
		defaultNetworkEvent.previousNetworkIpSupport = ipSupportOf(in);
		out.setDefaultNetworkEvent(defaultNetworkEvent);
		}

		private static void setNetworkEvent(IpConnectivityEvent out, NetworkEvent in) {
		IpConnectivityLogClass.NetworkEvent networkEvent =
		new IpConnectivityLogClass.NetworkEvent();

services/core/java/com/android/server/connectivity/IpConnectivityMetrics.java

+24 −0

Original line number	Diff line number	Diff line
		@@ -32,12 +32,15 @@ import android.text.format.DateUtils;
		import android.util.ArrayMap;
		import android.util.Base64;
		import android.util.Log;

		import com.android.internal.annotations.GuardedBy;
		import com.android.internal.annotations.VisibleForTesting;
		import com.android.internal.util.RingBuffer;
		import com.android.internal.util.TokenBucket;
		import com.android.server.LocalServices;
		import com.android.server.SystemService;
		import com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.IpConnectivityEvent;

		import java.io.FileDescriptor;
		import java.io.IOException;
		import java.io.PrintWriter;
		@@ -112,6 +115,9 @@ final public class IpConnectivityMetrics extends SystemService {

		private final ToIntFunction<Context> mCapacityGetter;

		@VisibleForTesting
		final DefaultNetworkMetrics mDefaultNetworkMetrics = new DefaultNetworkMetrics();

		public IpConnectivityMetrics(Context ctx, ToIntFunction<Context> capacityGetter) {
		super(ctx);
		mCapacityGetter = capacityGetter;
		@@ -135,6 +141,8 @@ final public class IpConnectivityMetrics extends SystemService {

		publishBinderService(SERVICE_NAME, impl);
		publishBinderService(mNetdListener.SERVICE_NAME, mNetdListener);

		LocalServices.addService(Logger.class, new LoggerImpl());
		}
		}

		@@ -188,6 +196,8 @@ final public class IpConnectivityMetrics extends SystemService {

		final List<IpConnectivityEvent> protoEvents = IpConnectivityEventBuilder.toProto(events);

		mDefaultNetworkMetrics.flushEvents(protoEvents);

		if (mNetdListener != null) {
		mNetdListener.flushStatistics(protoEvents);
		}
		@@ -228,6 +238,7 @@ final public class IpConnectivityMetrics extends SystemService {
		if (mNetdListener != null) {
		mNetdListener.listAsProtos(pw);
		}
		mDefaultNetworkMetrics.listEventsAsProto(pw);
		return;
		}

		@@ -237,6 +248,7 @@ final public class IpConnectivityMetrics extends SystemService {
		if (mNetdListener != null) {
		mNetdListener.list(pw);
		}
		mDefaultNetworkMetrics.listEvents(pw);
		}

		/**
		@@ -254,6 +266,7 @@ final public class IpConnectivityMetrics extends SystemService {
		if (mNetdListener != null) {
		mNetdListener.list(pw);
		}
		mDefaultNetworkMetrics.listEvents(pw);
		}

		private void cmdStats(FileDescriptor fd, PrintWriter pw, String[] args) {
		@@ -366,4 +379,15 @@ final public class IpConnectivityMetrics extends SystemService {
		map.put(ApfProgramEvent.class, new TokenBucket((int)DateUtils.MINUTE_IN_MILLIS, 50));
		return map;
		}

		/** Direct non-Binder interface for event producer clients within the system servers. */
		public interface Logger {
		DefaultNetworkMetrics defaultNetworkMetrics();
		}

		private class LoggerImpl implements Logger {
		public DefaultNetworkMetrics defaultNetworkMetrics() {
		return mDefaultNetworkMetrics;
		}
		}
		}