From 59091c08f4d0ad8f42013f58ce9bd23ac3306336 Mon Sep 17 00:00:00 2001 From: Jake Hamby Date: Thu, 16 Sep 2010 16:55:43 -0700 Subject: [PATCH] Fix Bluetooth device name max length checking. The Bluetooth device name has a maximum length of 248 bytes in UTF-8 encoding. The settings app previously limited the Bluetooth device name entered by the user based on the number of characters, which is incorrect when the name includes non-ASCII characters. Created a new Utf8ByteLengthFilter class for BluetoothNamePreference which counts UTF-8 bytes instead of Unicode characters, along with unit tests. We can move Utf8ByteLengthFilter into the framework in the future if it would be useful elsewhere in the system or for applications. Change-Id: I9debface09659f09d750f3bfe8ad6ddfd34c75c5 --- .../bluetooth/BluetoothNamePreference.java | 74 +++++++++++++- tests/AndroidManifest.xml | 5 + .../{ => tests}/SettingsLaunchPerformance.java | 2 +- .../settings/tests/Utf8ByteLengthFilterTest.java | 113 +++++++++++++++++++++ 4 files changed, 189 insertions(+), 5 deletions(-) rename tests/src/com/android/settings/{ => tests}/SettingsLaunchPerformance.java (99%) create mode 100644 tests/src/com/android/settings/tests/Utf8ByteLengthFilterTest.java diff --git a/src/com/android/settings/bluetooth/BluetoothNamePreference.java b/src/com/android/settings/bluetooth/BluetoothNamePreference.java index 7a9a0c1d88..c99ab4c998 100644 --- a/src/com/android/settings/bluetooth/BluetoothNamePreference.java +++ b/src/com/android/settings/bluetooth/BluetoothNamePreference.java @@ -27,8 +27,8 @@ import android.content.IntentFilter; import android.preference.EditTextPreference; import android.text.Editable; import android.text.InputFilter; +import android.text.Spanned; import android.text.TextWatcher; -import android.text.InputFilter.LengthFilter; import android.util.AttributeSet; import android.widget.Button; import android.widget.EditText; @@ -40,8 +40,7 @@ import android.widget.EditText; */ public class BluetoothNamePreference extends EditTextPreference implements TextWatcher { private static final String TAG = "BluetoothNamePreference"; - // TODO(): Investigate bluetoothd/dbus crash when length is set to 248, limit as per spec. - private static final int BLUETOOTH_NAME_MAX_LENGTH = 200; + private static final int BLUETOOTH_NAME_MAX_LENGTH_BYTES = 248; private LocalBluetoothManager mLocalManager; @@ -75,8 +74,11 @@ public class BluetoothNamePreference extends EditTextPreference implements TextW // Make sure the OK button is disabled (if necessary) after rotation EditText et = getEditText(); - et.setFilters(new InputFilter[] {new LengthFilter(BLUETOOTH_NAME_MAX_LENGTH)}); if (et != null) { + et.setFilters(new InputFilter[] { + new Utf8ByteLengthFilter(BLUETOOTH_NAME_MAX_LENGTH_BYTES) + }); + et.addTextChangedListener(this); Dialog d = getDialog(); if (d instanceof AlertDialog) { @@ -136,4 +138,68 @@ public class BluetoothNamePreference extends EditTextPreference implements TextW public void onTextChanged(CharSequence s, int start, int before, int count) { // not used } + + /** + * This filter will constrain edits so that the text length is not + * greater than the specified number of bytes using UTF-8 encoding. + *

The JNI method used by {@link android.server.BluetoothService} + * to convert UTF-16 to UTF-8 doesn't support surrogate pairs, + * therefore code points outside of the basic multilingual plane + * (0000-FFFF) will be encoded as a pair of 3-byte UTF-8 characters, + * rather than a single 4-byte UTF-8 encoding. Dalvik implements this + * conversion in {@code convertUtf16ToUtf8()} in + * {@code dalvik/vm/UtfString.c}. + *

This JNI method is unlikely to change in the future due to + * backwards compatibility requirements. It's also unclear whether + * the installed base of Bluetooth devices would correctly handle the + * encoding of surrogate pairs in UTF-8 as 4 bytes rather than 6. + * However, this filter will still work in scenarios where surrogate + * pairs are encoded as 4 bytes, with the caveat that the maximum + * length will be constrained more conservatively than necessary. + */ + public static class Utf8ByteLengthFilter implements InputFilter { + private int mMaxBytes; + + public Utf8ByteLengthFilter(int maxBytes) { + mMaxBytes = maxBytes; + } + + public CharSequence filter(CharSequence source, int start, int end, + Spanned dest, int dstart, int dend) { + int srcByteCount = 0; + // count UTF-8 bytes in source substring + for (int i = start; i < end; i++) { + char c = source.charAt(i); + srcByteCount += (c < 0x0080) ? 1 : (c < 0x0800 ? 2 : 3); + } + int destLen = dest.length(); + int destByteCount = 0; + // count UTF-8 bytes in destination excluding replaced section + for (int i = 0; i < destLen; i++) { + if (i < dstart || i >= dend) { + char c = dest.charAt(i); + destByteCount += (c < 0x0080) ? 1 : (c < 0x0800 ? 2 : 3); + } + } + int keepBytes = mMaxBytes - destByteCount; + if (keepBytes <= 0) { + return ""; + } else if (keepBytes >= srcByteCount) { + return null; // use original dest string + } else { + // find end position of largest sequence that fits in keepBytes + for (int i = start; i < end; i++) { + char c = source.charAt(i); + keepBytes -= (c < 0x0080) ? 1 : (c < 0x0800 ? 2 : 3); + if (keepBytes < 0) { + return source.subSequence(start, i); + } + } + // If the entire substring fits, we should have returned null + // above, so this line should not be reached. If for some + // reason it is, return null to use the original dest string. + return null; + } + } + } } diff --git a/tests/AndroidManifest.xml b/tests/AndroidManifest.xml index 6b9e0501d1..6f0b5ef3a9 100644 --- a/tests/AndroidManifest.xml +++ b/tests/AndroidManifest.xml @@ -37,4 +37,9 @@ android:label="Settings Launch Performance"> + + + diff --git a/tests/src/com/android/settings/SettingsLaunchPerformance.java b/tests/src/com/android/settings/tests/SettingsLaunchPerformance.java similarity index 99% rename from tests/src/com/android/settings/SettingsLaunchPerformance.java rename to tests/src/com/android/settings/tests/SettingsLaunchPerformance.java index 05154e29b2..225a60b630 100644 --- a/tests/src/com/android/settings/SettingsLaunchPerformance.java +++ b/tests/src/com/android/settings/tests/SettingsLaunchPerformance.java @@ -26,7 +26,7 @@ import java.util.Map; * Instrumentation class for Settings launch performance testing. */ public class SettingsLaunchPerformance extends LaunchPerformanceBase { - + public static final String LOG_TAG = "SettingsLaunchPerformance"; public SettingsLaunchPerformance() { diff --git a/tests/src/com/android/settings/tests/Utf8ByteLengthFilterTest.java b/tests/src/com/android/settings/tests/Utf8ByteLengthFilterTest.java new file mode 100644 index 0000000000..c03f9c0bf8 --- /dev/null +++ b/tests/src/com/android/settings/tests/Utf8ByteLengthFilterTest.java @@ -0,0 +1,113 @@ +/* + * Copyright (C) 2010 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.settings.tests; + +import android.test.AndroidTestCase; +import android.text.InputFilter; +import android.text.SpannableStringBuilder; + +import com.android.settings.bluetooth.BluetoothNamePreference; + +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargetNew; +import dalvik.annotation.TestTargets; + +@TestTargetClass(BluetoothNamePreference.Utf8ByteLengthFilter.class) +public class Utf8ByteLengthFilterTest extends AndroidTestCase { + + @TestTargets({ + @TestTargetNew( + level = TestLevel.COMPLETE, + method = "filter", + args = {java.lang.CharSequence.class, int.class, int.class, android.text.Spanned.class, + int.class, int.class} + ), + @TestTargetNew( + level = TestLevel.COMPLETE, + method = "BluetoothNamePreference.Utf8ByteLengthFilter", + args = {int.class} + ) + }) + public void testFilter() { + // Define the variables + CharSequence source; + SpannableStringBuilder dest; + // Constructor to create a LengthFilter + BluetoothNamePreference.Utf8ByteLengthFilter lengthFilter = new BluetoothNamePreference.Utf8ByteLengthFilter(10); + InputFilter[] filters = {lengthFilter}; + + // filter() implicitly invoked. If the total length > filter length, the filter will + // cut off the source CharSequence from beginning to fit the filter length. + source = "abc"; + dest = new SpannableStringBuilder("abcdefgh"); + dest.setFilters(filters); + + dest.insert(1, source); + String expectedString1 = "aabbcdefgh"; + assertEquals(expectedString1, dest.toString()); + + dest.replace(5, 8, source); + String expectedString2 = "aabbcabcgh"; + assertEquals(expectedString2, dest.toString()); + + dest.insert(2, source); + assertEquals(expectedString2, dest.toString()); + + dest.delete(1, 3); + String expectedString3 = "abcabcgh"; + assertEquals(expectedString3, dest.toString()); + + dest.append("12345"); + String expectedString4 = "abcabcgh12"; + assertEquals(expectedString4, dest.toString()); + + source = "\u60a8\u597d"; // 2 Chinese chars == 6 bytes in UTF-8 + dest.replace(8, 10, source); + assertEquals(expectedString3, dest.toString()); + + dest.replace(0, 1, source); + String expectedString5 = "\u60a8bcabcgh"; + assertEquals(expectedString5, dest.toString()); + + dest.replace(0, 4, source); + String expectedString6 = "\u60a8\u597dbcgh"; + assertEquals(expectedString6, dest.toString()); + + source = "\u00a3\u00a5"; // 2 Latin-1 chars == 4 bytes in UTF-8 + dest.delete(2, 6); + dest.insert(0, source); + String expectedString7 = "\u00a3\u00a5\u60a8\u597d"; + assertEquals(expectedString7, dest.toString()); + + dest.replace(2, 3, source); + String expectedString8 = "\u00a3\u00a5\u00a3\u597d"; + assertEquals(expectedString8, dest.toString()); + + dest.replace(3, 4, source); + String expectedString9 = "\u00a3\u00a5\u00a3\u00a3\u00a5"; + assertEquals(expectedString9, dest.toString()); + + // filter() explicitly invoked + dest = new SpannableStringBuilder("abcdefgh"); + CharSequence beforeFilterSource = "TestLengthFilter"; + String expectedAfterFilter = "TestLength"; + CharSequence actualAfterFilter = lengthFilter.filter(beforeFilterSource, 0, + beforeFilterSource.length(), dest, 0, dest.length()); + assertEquals(expectedAfterFilter, actualAfterFilter); + } +} -- 2.11.0