Merge "Move LogPersist to SettingsLib" (8dc5772c) · Commits · e / os / android_frameworks_base

packages/SettingsLib/src/com/android/settingslib/development/AbstractLogdSizePreferenceController.java

0 → 100644

+184 −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.settingslib.development;

		import android.content.Context;
		import android.content.Intent;
		import android.os.SystemProperties;
		import android.support.annotation.VisibleForTesting;
		import android.support.v4.content.LocalBroadcastManager;
		import android.support.v7.preference.ListPreference;
		import android.support.v7.preference.Preference;
		import android.support.v7.preference.PreferenceScreen;

		import com.android.settingslib.R;
		import com.android.settingslib.core.AbstractPreferenceController;

		public abstract class AbstractLogdSizePreferenceController extends AbstractPreferenceController
		implements Preference.OnPreferenceChangeListener {
		public static final String ACTION_LOGD_SIZE_UPDATED = "com.android.settingslib.development."
		+ "AbstractLogdSizePreferenceController.LOGD_SIZE_UPDATED";
		public static final String EXTRA_CURRENT_LOGD_VALUE = "CURRENT_LOGD_VALUE";

		private static final String SELECT_LOGD_SIZE_KEY = "select_logd_size";
		@VisibleForTesting
		static final String SELECT_LOGD_SIZE_PROPERTY = "persist.logd.size";
		static final String SELECT_LOGD_TAG_PROPERTY = "persist.log.tag";
		// Tricky, isLoggable only checks for first character, assumes silence
		static final String SELECT_LOGD_TAG_SILENCE = "Settings";
		private static final String SELECT_LOGD_SNET_TAG_PROPERTY = "persist.log.tag.snet_event_log";
		private static final String SELECT_LOGD_RUNTIME_SNET_TAG_PROPERTY = "log.tag.snet_event_log";
		private static final String SELECT_LOGD_DEFAULT_SIZE_PROPERTY = "ro.logd.size";
		@VisibleForTesting
		static final String SELECT_LOGD_DEFAULT_SIZE_VALUE = "262144";
		private static final String SELECT_LOGD_SVELTE_DEFAULT_SIZE_VALUE = "65536";
		// 32768 is merely a menu marker, 64K is our lowest log buffer size we replace it with.
		private static final String SELECT_LOGD_MINIMUM_SIZE_VALUE = "65536";
		static final String SELECT_LOGD_OFF_SIZE_MARKER_VALUE = "32768";

		private ListPreference mLogdSize;

		public AbstractLogdSizePreferenceController(Context context) {
		super(context);
		}

		@Override
		public boolean isAvailable() {
		return true;
		}

		@Override
		public String getPreferenceKey() {
		return SELECT_LOGD_SIZE_KEY;
		}

		@Override
		public void displayPreference(PreferenceScreen screen) {
		super.displayPreference(screen);
		if (isAvailable()) {
		mLogdSize = (ListPreference) screen.findPreference(SELECT_LOGD_SIZE_KEY);
		}
		}

		@Override
		public boolean onPreferenceChange(Preference preference, Object newValue) {
		if (preference == mLogdSize) {
		writeLogdSizeOption(newValue);
		return true;
		} else {
		return false;
		}
		}

		public void enablePreference(boolean enabled) {
		if (isAvailable()) {
		mLogdSize.setEnabled(enabled);
		}
		}

		private String defaultLogdSizeValue() {
		String defaultValue = SystemProperties.get(SELECT_LOGD_DEFAULT_SIZE_PROPERTY);
		if ((defaultValue == null) \|\| (defaultValue.length() == 0)) {
		if (SystemProperties.get("ro.config.low_ram").equals("true")) {
		defaultValue = SELECT_LOGD_SVELTE_DEFAULT_SIZE_VALUE;
		} else {
		defaultValue = SELECT_LOGD_DEFAULT_SIZE_VALUE;
		}
		}
		return defaultValue;
		}

		public void updateLogdSizeValues() {
		if (mLogdSize != null) {
		String currentTag = SystemProperties.get(SELECT_LOGD_TAG_PROPERTY);
		String currentValue = SystemProperties.get(SELECT_LOGD_SIZE_PROPERTY);
		if ((currentTag != null) && currentTag.startsWith(SELECT_LOGD_TAG_SILENCE)) {
		currentValue = SELECT_LOGD_OFF_SIZE_MARKER_VALUE;
		}
		LocalBroadcastManager.getInstance(mContext).sendBroadcastSync(
		new Intent(ACTION_LOGD_SIZE_UPDATED)
		.putExtra(EXTRA_CURRENT_LOGD_VALUE, currentValue));
		if ((currentValue == null) \|\| (currentValue.length() == 0)) {
		currentValue = defaultLogdSizeValue();
		}
		String[] values = mContext.getResources()
		.getStringArray(R.array.select_logd_size_values);
		String[] titles = mContext.getResources()
		.getStringArray(R.array.select_logd_size_titles);
		int index = 2; // punt to second entry if not found
		if (SystemProperties.get("ro.config.low_ram").equals("true")) {
		mLogdSize.setEntries(R.array.select_logd_size_lowram_titles);
		titles = mContext.getResources()
		.getStringArray(R.array.select_logd_size_lowram_titles);
		index = 1;
		}
		String[] summaries = mContext.getResources()
		.getStringArray(R.array.select_logd_size_summaries);
		for (int i = 0; i < titles.length; i++) {
		if (currentValue.equals(values[i])
		\|\| currentValue.equals(titles[i])) {
		index = i;
		break;
		}
		}
		mLogdSize.setValue(values[index]);
		mLogdSize.setSummary(summaries[index]);
		}
		}

		public void writeLogdSizeOption(Object newValue) {
		boolean disable = (newValue != null) &&
		(newValue.toString().equals(SELECT_LOGD_OFF_SIZE_MARKER_VALUE));
		String currentTag = SystemProperties.get(SELECT_LOGD_TAG_PROPERTY);
		if (currentTag == null) {
		currentTag = "";
		}
		// filter clean and unstack all references to our setting
		String newTag = currentTag.replaceAll(
		",+" + SELECT_LOGD_TAG_SILENCE, "").replaceFirst(
		"^" + SELECT_LOGD_TAG_SILENCE + ",*", "").replaceAll(
		",+", ",").replaceFirst(
		",+$", "");
		if (disable) {
		newValue = SELECT_LOGD_MINIMUM_SIZE_VALUE;
		// Make sure snet_event_log get through first, but do not override
		String snetValue = SystemProperties.get(SELECT_LOGD_SNET_TAG_PROPERTY);
		if ((snetValue == null) \|\| (snetValue.length() == 0)) {
		snetValue = SystemProperties.get(SELECT_LOGD_RUNTIME_SNET_TAG_PROPERTY);
		if ((snetValue == null) \|\| (snetValue.length() == 0)) {
		SystemProperties.set(SELECT_LOGD_SNET_TAG_PROPERTY, "I");
		}
		}
		// Silence all log sources, security logs notwithstanding
		if (newTag.length() != 0) {
		newTag = "," + newTag;
		}
		// Stack settings, stack to help preserve original value
		newTag = SELECT_LOGD_TAG_SILENCE + newTag;
		}
		if (!newTag.equals(currentTag)) {
		SystemProperties.set(SELECT_LOGD_TAG_PROPERTY, newTag);
		}
		String defaultValue = defaultLogdSizeValue();
		final String size = ((newValue != null) && (newValue.toString().length() != 0)) ?
		newValue.toString() : defaultValue;
		SystemProperties.set(SELECT_LOGD_SIZE_PROPERTY, defaultValue.equals(size) ? "" : size);
		SystemProperties.set("ctl.start", "logd-reinit");
		SystemPropPoker.getInstance().poke();
		updateLogdSizeValues();
		}
		}

packages/SettingsLib/src/com/android/settingslib/development/AbstractLogpersistPreferenceController.java

0 → 100644

+259 −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.settingslib.development;

		import android.content.BroadcastReceiver;
		import android.content.Context;
		import android.content.Intent;
		import android.content.IntentFilter;
		import android.os.Bundle;
		import android.os.SystemProperties;
		import android.support.annotation.VisibleForTesting;
		import android.support.v4.content.LocalBroadcastManager;
		import android.support.v7.preference.ListPreference;
		import android.support.v7.preference.Preference;
		import android.support.v7.preference.PreferenceScreen;
		import android.text.TextUtils;

		import com.android.settingslib.R;
		import com.android.settingslib.core.AbstractPreferenceController;
		import com.android.settingslib.core.lifecycle.Lifecycle;
		import com.android.settingslib.core.lifecycle.LifecycleObserver;
		import com.android.settingslib.core.lifecycle.events.OnCreate;
		import com.android.settingslib.core.lifecycle.events.OnDestroy;

		public abstract class AbstractLogpersistPreferenceController extends AbstractPreferenceController
		implements Preference.OnPreferenceChangeListener, LifecycleObserver, OnCreate, OnDestroy {

		private static final String SELECT_LOGPERSIST_KEY = "select_logpersist";
		private static final String SELECT_LOGPERSIST_PROPERTY = "persist.logd.logpersistd";
		@VisibleForTesting
		static final String ACTUAL_LOGPERSIST_PROPERTY = "logd.logpersistd";
		@VisibleForTesting
		static final String SELECT_LOGPERSIST_PROPERTY_SERVICE = "logcatd";
		private static final String SELECT_LOGPERSIST_PROPERTY_CLEAR = "clear";
		private static final String SELECT_LOGPERSIST_PROPERTY_STOP = "stop";
		private static final String SELECT_LOGPERSIST_PROPERTY_BUFFER =
		"persist.logd.logpersistd.buffer";
		@VisibleForTesting
		static final String ACTUAL_LOGPERSIST_PROPERTY_BUFFER = "logd.logpersistd.buffer";
		private static final String ACTUAL_LOGPERSIST_PROPERTY_ENABLE = "logd.logpersistd.enable";

		private ListPreference mLogpersist;
		private boolean mLogpersistCleared;

		private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
		final String currentValue = intent.getStringExtra(
		AbstractLogdSizePreferenceController.EXTRA_CURRENT_LOGD_VALUE);
		onLogdSizeSettingUpdate(currentValue);
		}
		};

		public AbstractLogpersistPreferenceController(Context context, Lifecycle lifecycle) {
		super(context);
		if (isAvailable()) {
		lifecycle.addObserver(this);
		}
		}

		@Override
		public boolean isAvailable() {
		return TextUtils.equals(SystemProperties.get("ro.debuggable", "0"), "1");
		}

		@Override
		public String getPreferenceKey() {
		return SELECT_LOGPERSIST_KEY;
		}

		@Override
		public void displayPreference(PreferenceScreen screen) {
		super.displayPreference(screen);
		if (isAvailable()) {
		mLogpersist = (ListPreference) screen.findPreference(SELECT_LOGPERSIST_KEY);
		}
		}

		@Override
		public boolean onPreferenceChange(Preference preference, Object newValue) {
		if (preference == mLogpersist) {
		writeLogpersistOption(newValue, false);
		return true;
		} else {
		return false;
		}
		}

		@Override
		public void onCreate(Bundle savedInstanceState) {
		LocalBroadcastManager.getInstance(mContext).registerReceiver(mReceiver,
		new IntentFilter(AbstractLogdSizePreferenceController.ACTION_LOGD_SIZE_UPDATED));
		}

		@Override
		public void onDestroy() {
		LocalBroadcastManager.getInstance(mContext).unregisterReceiver(mReceiver);
		}

		public void enablePreference(boolean enabled) {
		if (isAvailable()) {
		mLogpersist.setEnabled(enabled);
		}
		}

		private void onLogdSizeSettingUpdate(String currentValue) {
		if (mLogpersist != null) {
		String currentLogpersistEnable
		= SystemProperties.get(ACTUAL_LOGPERSIST_PROPERTY_ENABLE);
		if ((currentLogpersistEnable == null)
		\|\| !currentLogpersistEnable.equals("true")
		\|\| currentValue.equals(
		AbstractLogdSizePreferenceController.SELECT_LOGD_OFF_SIZE_MARKER_VALUE)) {
		writeLogpersistOption(null, true);
		mLogpersist.setEnabled(false);
		} else if (DevelopmentSettingsEnabler.isDevelopmentSettingsEnabled(mContext)) {
		mLogpersist.setEnabled(true);
		}
		}
		}

		public void updateLogpersistValues() {
		if (mLogpersist == null) {
		return;
		}
		String currentValue = SystemProperties.get(ACTUAL_LOGPERSIST_PROPERTY);
		if (currentValue == null) {
		currentValue = "";
		}
		String currentBuffers = SystemProperties.get(ACTUAL_LOGPERSIST_PROPERTY_BUFFER);
		if ((currentBuffers == null) \|\| (currentBuffers.length() == 0)) {
		currentBuffers = "all";
		}
		int index = 0;
		if (currentValue.equals(SELECT_LOGPERSIST_PROPERTY_SERVICE)) {
		index = 1;
		if (currentBuffers.equals("kernel")) {
		index = 3;
		} else if (!currentBuffers.equals("all") &&
		!currentBuffers.contains("radio") &&
		currentBuffers.contains("security") &&
		currentBuffers.contains("kernel")) {
		index = 2;
		if (!currentBuffers.contains("default")) {
		String[] contains = {"main", "events", "system", "crash"};
		for (String type : contains) {
		if (!currentBuffers.contains(type)) {
		index = 1;
		break;
		}
		}
		}
		}
		}
		mLogpersist.setValue(
		mContext.getResources().getStringArray(R.array.select_logpersist_values)[index]);
		mLogpersist.setSummary(
		mContext.getResources().getStringArray(R.array.select_logpersist_summaries)[index]);
		if (index != 0) {
		mLogpersistCleared = false;
		} else if (!mLogpersistCleared) {
		// would File.delete() directly but need to switch uid/gid to access
		SystemProperties.set(ACTUAL_LOGPERSIST_PROPERTY, SELECT_LOGPERSIST_PROPERTY_CLEAR);
		SystemPropPoker.getInstance().poke();
		mLogpersistCleared = true;
		}
		}

		protected void setLogpersistOff(boolean update) {
		SystemProperties.set(SELECT_LOGPERSIST_PROPERTY_BUFFER, "");
		// deal with trampoline of empty properties
		SystemProperties.set(ACTUAL_LOGPERSIST_PROPERTY_BUFFER, "");
		SystemProperties.set(SELECT_LOGPERSIST_PROPERTY, "");
		SystemProperties.set(ACTUAL_LOGPERSIST_PROPERTY,
		update ? "" : SELECT_LOGPERSIST_PROPERTY_STOP);
		SystemPropPoker.getInstance().poke();
		if (update) {
		updateLogpersistValues();
		} else {
		for (int i = 0; i < 3; i++) {
		String currentValue = SystemProperties.get(ACTUAL_LOGPERSIST_PROPERTY);
		if ((currentValue == null) \|\| currentValue.equals("")) {
		break;
		}
		try {
		Thread.sleep(100);
		} catch (InterruptedException e) {
		// Ignore
		}
		}
		}
		}

		public void writeLogpersistOption(Object newValue, boolean skipWarning) {
		if (mLogpersist == null) {
		return;
		}
		String currentTag = SystemProperties.get(
		AbstractLogdSizePreferenceController.SELECT_LOGD_TAG_PROPERTY);
		if ((currentTag != null) && currentTag.startsWith(
		AbstractLogdSizePreferenceController.SELECT_LOGD_TAG_SILENCE)) {
		newValue = null;
		skipWarning = true;
		}

		if ((newValue == null) \|\| newValue.toString().equals("")) {
		if (skipWarning) {
		mLogpersistCleared = false;
		} else if (!mLogpersistCleared) {
		// if transitioning from on to off, pop up an are you sure?
		String currentValue = SystemProperties.get(ACTUAL_LOGPERSIST_PROPERTY);
		if ((currentValue != null) &&
		currentValue.equals(SELECT_LOGPERSIST_PROPERTY_SERVICE)) {
		showConfirmationDialog(mLogpersist);
		return;
		}
		}
		setLogpersistOff(true);
		return;
		}

		String currentBuffer = SystemProperties.get(ACTUAL_LOGPERSIST_PROPERTY_BUFFER);
		if ((currentBuffer != null) && !currentBuffer.equals(newValue.toString())) {
		setLogpersistOff(false);
		}
		SystemProperties.set(SELECT_LOGPERSIST_PROPERTY_BUFFER, newValue.toString());
		SystemProperties.set(SELECT_LOGPERSIST_PROPERTY, SELECT_LOGPERSIST_PROPERTY_SERVICE);
		SystemPropPoker.getInstance().poke();
		for (int i = 0; i < 3; i++) {
		String currentValue = SystemProperties.get(ACTUAL_LOGPERSIST_PROPERTY);
		if ((currentValue != null)
		&& currentValue.equals(SELECT_LOGPERSIST_PROPERTY_SERVICE)) {
		break;
		}
		try {
		Thread.sleep(100);
		} catch (InterruptedException e) {
		// Ignore
		}
		}
		updateLogpersistValues();
		}

		public abstract void showConfirmationDialog(ListPreference preference);
		}

packages/SettingsLib/tests/robotests/src/com/android/settingslib/development/LogdSizePreferenceControllerTest.java

0 → 100644

+80 −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.settingslib.development;

		import static org.mockito.Mockito.doReturn;
		import static org.mockito.Mockito.verify;

		import android.os.SystemProperties;
		import android.support.v7.preference.ListPreference;
		import android.support.v7.preference.PreferenceScreen;

		import com.android.settingslib.R;
		import com.android.settingslib.SettingsLibRobolectricTestRunner;
		import com.android.settingslib.TestConfig;

		import org.junit.Before;
		import org.junit.Test;
		import org.junit.runner.RunWith;
		import org.mockito.Mock;
		import org.mockito.MockitoAnnotations;
		import org.robolectric.RuntimeEnvironment;
		import org.robolectric.annotation.Config;

		@RunWith(SettingsLibRobolectricTestRunner.class)
		@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION,
		shadows = SystemPropertiesTestImpl.class)
		public class LogdSizePreferenceControllerTest {

		@Mock
		private ListPreference mListPreference;
		@Mock
		private PreferenceScreen mPreferenceScreen;

		private AbstractLogdSizePreferenceController mController;

		@Before
		public void setUp() {
		MockitoAnnotations.initMocks(this);
		mController = new AbstractLogdSizePreferenceController(RuntimeEnvironment.application) {};

		doReturn(mListPreference).when(mPreferenceScreen)
		.findPreference(mController.getPreferenceKey());

		mController.displayPreference(mPreferenceScreen);
		}

		@Test
		public void testUpateLogdSizeValues_lowRamEntries() {
		SystemProperties.set("ro.config.low_ram", "true");
		mController.updateLogdSizeValues();
		verify(mListPreference).setEntries(R.array.select_logd_size_lowram_titles);
		}

		@Test
		public void testUpdateLogdSizeValues_silence() {
		SystemProperties.set(
		AbstractLogdSizePreferenceController.SELECT_LOGD_TAG_PROPERTY,
		AbstractLogdSizePreferenceController.SELECT_LOGD_TAG_SILENCE);
		SystemProperties.set(
		AbstractLogdSizePreferenceController.SELECT_LOGD_SIZE_PROPERTY,
		AbstractLogdSizePreferenceController.SELECT_LOGD_DEFAULT_SIZE_VALUE);
		mController.updateLogdSizeValues();
		verify(mListPreference).setValue(
		AbstractLogdSizePreferenceController.SELECT_LOGD_OFF_SIZE_MARKER_VALUE);
		}
		}

packages/SettingsLib/tests/robotests/src/com/android/settingslib/development/LogpersistPreferenceControllerTest.java

0 → 100644

+140 −0

File added.

Preview size limit exceeded, changes collapsed.

packages/SettingsLib/tests/robotests/src/com/android/settingslib/development/SystemPropertiesTestImpl.java

0 → 100644

+57 −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.settingslib.development;

		import android.text.TextUtils;
		import android.util.ArrayMap;

		import org.robolectric.annotation.Implementation;
		import org.robolectric.annotation.Implements;
		import org.robolectric.shadows.ShadowSystemProperties;

		import java.util.Map;

		@Implements(className = "android.os.SystemProperties")
		public class SystemPropertiesTestImpl extends ShadowSystemProperties {

		private static Map<String, String> sProperties = new ArrayMap<>();

		@Implementation
		public static String get(String key) {
		String value = sProperties.get(key);
		if (!TextUtils.isEmpty(value)) {
		return value;
		} else {
		return ShadowSystemProperties.get(key);
		}
		}

		@Implementation
		public static String get(String key, String def) {
		String value = sProperties.get(key);
		if (!TextUtils.isEmpty(value)) {
		return value;
		} else {
		return ShadowSystemProperties.get(key, def);
		}
		}

		@Implementation
		public static void set(String key, String val) {
		sProperties.put(key, val);
		}
		}