PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

am 59091c08: Fix Bluetooth device name max length checking.

Browse Source 
Merge commit '59091c08f4d0ad8f42013f58ce9bd23ac3306336' into gingerbread-plus-aosp

* commit '59091c08f4d0ad8f42013f58ce9bd23ac3306336':
  Fix Bluetooth device name max length checking.
This commit is contained in:
Jake Hamby
2010-09-22 16:26:02 -07:00
committed by Android Git Automerger
parent e2b102de67 59091c08f4
commit 5496db047d
4 changed files with 189 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
src/com/android/settings/bluetooth/BluetoothNamePreference.java
View File

@@ -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.
* <p>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}.
* <p>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;
}
}
}
}

5
tests/AndroidManifest.xml
View File

@@ -58,4 +58,9 @@
android:label="Settings Launch Performance">
</instrumentation>
<instrumentation android:name="android.test.InstrumentationTestRunner"
android:targetPackage="com.android.settings"
android:label="Settings Test Cases">
</instrumentation>
</manifest>

0
tests/src/com/android/settings/SettingsLaunchPerformance.java → tests/src/com/android/settings/tests/SettingsLaunchPerformance.java
View File

113
tests/src/com/android/settings/tests/Utf8ByteLengthFilterTest.java Normal file
View File

@@ -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);
}
}