Android 零碎知识点---2

android中TextView属性之autoText解析

（转载自：http://blog.csdn.net/muyi_amen/article/details/46911635）
如果没有时间看完全篇的同学们，可以直接看文章的最后第四点总结的内容。
一、看看Android官方文档的描述。

在这之前，需要说明一点autoText虽然是TextView的属性之一，但它实际是服务于EditText。EditText是TextView的子类。
如果在TextView中设置属性autoText，编译器会提示“TextView不建议使用autoText属性”—因为设置了也是无效的。

二、那autoText在EditText中到底在干什么呢。来看看android TextView源码片段。
[java] view plain copyprint?

1. //autotext对应的是android:autotext属性  
2. //autocap对应的是android:capitalize属性  
3. if (autotext || autocap != -1) {  
4.             TextKeyListener.Capitalize cap;  
5.   
6.             inputType = EditorInfo.TYPE_CLASS_TEXT;  
7.   
8.             switch (autocap) {  
9.             case 1:  
10.                 cap = TextKeyListener.Capitalize.SENTENCES;//每句的第一个单词首字母转为大写  
11.         //inputType对应的是android:inputType属性  
12.                 inputType |= EditorInfo.TYPE_TEXT_FLAG_CAP_SENTENCES;//每一句的第一个单词的首字母大写  
13.                 break;  
14.   
15.             case 2:  
16.                 cap = TextKeyListener.Capitalize.WORDS;//每个单词的首字母大写  
17.                 inputType |= EditorInfo.TYPE_TEXT_FLAG_CAP_WORDS;  
18.                 break;  
19.   
20.             case 3:  
21.                 cap = TextKeyListener.Capitalize.CHARACTERS;//所有字符大写  
22.                 inputType |= EditorInfo.TYPE_TEXT_FLAG_CAP_CHARACTERS;  
23.                 break;  
24.   
25.             default:  
26.                 cap = TextKeyListener.Capitalize.NONE;  
27.                 break;  
28.             }  
29.   
30.             createEditorIfNeeded();  
31.             mEditor.mKeyListener = TextKeyListener.getInstance(autotext, cap);  
32.             mEditor.mInputType = inputType;  
33.         }  

此段源码中可以发现，其实就是给inputType这个属性赋值。
第31行中，再次把autoText传递给了TextKeyListener。看看TextKeyListener的源码：
[java] view plain copyprint?

1. public class TextKeyListener extends BaseKeyListener implements SpanWatcher {  
2.     private static TextKeyListener[] sInstance =  
3.         new TextKeyListener[Capitalize.values().length * 2];  
4.   
5.     /* package */ static final Object ACTIVE = new NoCopySpan.Concrete();  
6.     /* package */ static final Object CAPPED = new NoCopySpan.Concrete();  
7.     /* package */ static final Object INHIBIT_REPLACEMENT = new NoCopySpan.Concrete();  
8.     /* package */ static final Object LAST_TYPED = new NoCopySpan.Concrete();  
9.   
10.     private Capitalize mAutoCap;  
11.     private boolean mAutoText;  
12.   
13.     private int mPrefs;  
14.     private boolean mPrefsInited;  
15.   
16.     /* package */ static final int AUTO_CAP = 1;  
17.     /* package */ static final int AUTO_TEXT = 2;  
18.     /* package */ static final int AUTO_PERIOD = 4;  
19.     /* package */ static final int SHOW_PASSWORD = 8;  
20.     private WeakReference<ContentResolver> mResolver;  
21.     private TextKeyListener.SettingsObserver mObserver;  
22.   
23.     /** 
24.      * Creates a new TextKeyListener with the specified capitalization 
25.      * and correction properties. 
26.      * 
27.      * @param cap when, if ever, to automatically capitalize. 
28.      * @param autotext whether to automatically do spelling corrections. 
29.      */  
30.     public TextKeyListener(Capitalize cap, boolean autotext) {  
31.         mAutoCap = cap;  
32.         mAutoText = autotext;  
33.     }  
34.   
35.     /** 
36.      * Returns a new or existing instance with the specified capitalization 
37.      * and correction properties. 
38.      * 
39.      * @param cap when, if ever, to automatically capitalize. 
40.      * @param autotext whether to automatically do spelling corrections. 
41.      */  
42.     public static TextKeyListener getInstance(boolean autotext,  
43.                                               Capitalize cap) {  
44.         int off = cap.ordinal() * 2 + (autotext ? 1 : 0);  
45.   
46.         if (sInstance[off] == null) {  
47.             sInstance[off] = new TextKeyListener(cap, autotext);  
48.         }  
49.   
50.         return sInstance[off];  
51.     }  
52.   
53.     /** 
54.      * Returns a new or existing instance with no automatic capitalization 
55.      * or correction. 
56.      */  
57.     public static TextKeyListener getInstance() {  
58.         return getInstance(false, Capitalize.NONE);  
59.     }  
60.   
61.     /** 
62.      * Returns whether it makes sense to automatically capitalize at the 
63.      * specified position in the specified text, with the specified rules. 
64.      * 
65.      * @param cap the capitalization rules to consider. 
66.      * @param cs the text in which an insertion is being made. 
67.      * @param off the offset into that text where the insertion is being made. 
68.      * 
69.      * @return whether the character being inserted should be capitalized. 
70.      */  
71.     public static boolean shouldCap(Capitalize cap, CharSequence cs, int off) {  
72.         int i;  
73.         char c;  
74.   
75.         if (cap == Capitalize.NONE) {  
76.             return false;  
77.         }  
78.         if (cap == Capitalize.CHARACTERS) {  
79.             return true;  
80.         }  
81.   
82.         return TextUtils.getCapsMode(cs, off, cap == Capitalize.WORDS  
83.                 ? TextUtils.CAP_MODE_WORDS : TextUtils.CAP_MODE_SENTENCES)  
84.                 != 0;  
85.     }  
86.   
87.     public int getInputType() {  
88.         return makeTextContentType(mAutoCap, mAutoText);  
89.     }  
90.       
91.     @Override  
92.     public boolean onKeyDown(View view, Editable content,  
93.                              int keyCode, KeyEvent event) {  
94.         KeyListener im = getKeyListener(event);  
95.   
96.         return im.onKeyDown(view, content, keyCode, event);  
97.     }  
98.   
99.     @Override  
100.     public boolean onKeyUp(View view, Editable content,  
101.                            int keyCode, KeyEvent event) {  
102.         KeyListener im = getKeyListener(event);  
103.   
104.         return im.onKeyUp(view, content, keyCode, event);  
105.     }  
106.   
107.     @Override  
108.     public boolean onKeyOther(View view, Editable content, KeyEvent event) {  
109.         KeyListener im = getKeyListener(event);  
110.   
111.         return im.onKeyOther(view, content, event);  
112.     }  
113.   
114.     /** 
115.      * Clear all the input state (autotext, autocap, multitap, undo) 
116.      * from the specified Editable, going beyond Editable.clear(), which 
117.      * just clears the text but not the input state. 
118.      * 
119.      * @param e the buffer whose text and state are to be cleared. 
120.      */  
121.     public static void clear(Editable e) {  
122.         e.clear();  
123.         e.removeSpan(ACTIVE);  
124.         e.removeSpan(CAPPED);  
125.         e.removeSpan(INHIBIT_REPLACEMENT);  
126.         e.removeSpan(LAST_TYPED);  
127.   
128.         QwertyKeyListener.Replaced[] repl = e.getSpans(0, e.length(),  
129.                                    QwertyKeyListener.Replaced.class);  
130.         final int count = repl.length;  
131.         for (int i = 0; i < count; i++) {  
132.             e.removeSpan(repl[i]);  
133.         }  
134.     }  
135.   
136.     public void onSpanAdded(Spannable s, Object what, int start, int end) { }  
137.     public void onSpanRemoved(Spannable s, Object what, int start, int end) { }  
138.   
139.     public void onSpanChanged(Spannable s, Object what, int start, int end,  
140.                               int st, int en) {  
141.         if (what == Selection.SELECTION_END) {  
142.             s.removeSpan(ACTIVE);  
143.         }  
144.     }  
145.   
146.     private KeyListener getKeyListener(KeyEvent event) {  
147.         KeyCharacterMap kmap = event.getKeyCharacterMap();  
148.         int kind = kmap.getKeyboardType();  
149.   
150.         if (kind == KeyCharacterMap.ALPHA) {  
151.             return QwertyKeyListener.getInstance(mAutoText, mAutoCap);  
152.         } else if (kind == KeyCharacterMap.NUMERIC) {  
153.             return MultiTapKeyListener.getInstance(mAutoText, mAutoCap);  
154.         } else if (kind == KeyCharacterMap.FULL  
155.                 || kind == KeyCharacterMap.SPECIAL_FUNCTION) {  
156.             // We consider special function keyboards full keyboards as a workaround for  
157.             // devices that do not have built-in keyboards.  Applications may try to inject  
158.             // key events using the built-in keyboard device id which may be configured as  
159.             // a special function keyboard using a default key map.  Ideally, as of Honeycomb,  
160.             // these applications should be modified to use KeyCharacterMap.VIRTUAL_KEYBOARD.  
161.             return QwertyKeyListener.getInstanceForFullKeyboard();  
162.         }  
163.   
164.         return NullKeyListener.getInstance();  
165.     }  
166.   
167.     public enum Capitalize {  
168.         NONE, SENTENCES, WORDS, CHARACTERS,  
169.     }  
170.   
171.     private static class NullKeyListener implements KeyListener  
172.     {  
173.         public int getInputType() {  
174.             return InputType.TYPE_NULL;  
175.         }  
176.           
177.         public boolean onKeyDown(View view, Editable content,  
178.                                  int keyCode, KeyEvent event) {  
179.             return false;  
180.         }  
181.   
182.         public boolean onKeyUp(View view, Editable content, int keyCode,  
183.                                         KeyEvent event) {  
184.             return false;  
185.         }  
186.   
187.         public boolean onKeyOther(View view, Editable content, KeyEvent event) {  
188.             return false;  
189.         }  
190.   
191.         public void clearMetaKeyState(View view, Editable content, int states) {  
192.         }  
193.           
194.         public static NullKeyListener getInstance() {  
195.             if (sInstance != null)  
196.                 return sInstance;  
197.   
198.             sInstance = new NullKeyListener();  
199.             return sInstance;  
200.         }  
201.   
202.         private static NullKeyListener sInstance;  
203.     }  
204.   
205.     public void release() {  
206.         if (mResolver != null) {  
207.             final ContentResolver contentResolver = mResolver.get();  
208.             if (contentResolver != null) {  
209.                 contentResolver.unregisterContentObserver(mObserver);  
210.                 mResolver.clear();  
211.             }  
212.             mObserver = null;  
213.             mResolver = null;  
214.             mPrefsInited = false;  
215.         }  
216.     }  
217.   
218.     private void initPrefs(Context context) {  
219.         final ContentResolver contentResolver = context.getContentResolver();  
220.         mResolver = new WeakReference<ContentResolver>(contentResolver);  
221.         if (mObserver == null) {  
222.             mObserver = new SettingsObserver();  
223.             contentResolver.registerContentObserver(Settings.System.CONTENT_URI, true, mObserver);  
224.         }  
225.   
226.         updatePrefs(contentResolver);  
227.         mPrefsInited = true;  
228.     }  
229.   
230.     private class SettingsObserver extends ContentObserver {  
231.         public SettingsObserver() {  
232.             super(new Handler());  
233.         }  
234.   
235.         @Override  
236.         public void onChange(boolean selfChange) {  
237.             if (mResolver != null) {  
238.                 final ContentResolver contentResolver = mResolver.get();  
239.                 if (contentResolver == null) {  
240.                     mPrefsInited = false;  
241.                 } else {  
242.                     updatePrefs(contentResolver);  
243.                 }  
244.             } else {  
245.                 mPrefsInited = false;  
246.             }  
247.         }  
248.     }  
249.   
250.     private void updatePrefs(ContentResolver resolver) {  
251.         boolean cap = System.getInt(resolver, System.TEXT_AUTO_CAPS, 1) > 0;  
252.         boolean text = System.getInt(resolver, System.TEXT_AUTO_REPLACE, 1) > 0;  
253.         boolean period = System.getInt(resolver, System.TEXT_AUTO_PUNCTUATE, 1) > 0;  
254.         boolean pw = System.getInt(resolver, System.TEXT_SHOW_PASSWORD, 1) > 0;  
255.   
256.         mPrefs = (cap ? AUTO_CAP : 0) |  
257.                  (text ? AUTO_TEXT : 0) |  
258.                  (period ? AUTO_PERIOD : 0) |  
259.                  (pw ? SHOW_PASSWORD : 0);  
260.     }  
261.   
262.     /* package */ int getPrefs(Context context) {  
263.         synchronized (this) {  
264.             if (!mPrefsInited || mResolver.get() == null) {  
265.                 initPrefs(context);  
266.             }  
267.         }  
268.   
269.         return mPrefs;  
270.     }  

以上源码中真正使用到autoText的是getInputType()这个方法。在看此方法调用的是makeTextContentType(mAutoCap, mAutoText),这个方法中其实还是在进行inputType的赋值。

三、看到这里，发现autoText和capitalize属性如影随形。而且感觉autoText没有什么用，真正跟autoText有关系的就是下面这句
[java] view plain copyprint?

1. if (autoText) {  
2.             contentType |= InputType.TYPE_TEXT_FLAG_AUTO_CORRECT;//自动更正文本输入  
3.         }  

官方描述为“自动更正文本输入”。既然是更正，所以必须要有规则。没有规则就不知道什么是正确的。所以单独使用autoText是不起任何作用的。需要和capitalize配合使用。

四、最后，总结一下。
1、autoText是作用在EditText上的属性。
2、即使autoText和capitalize配合使用，他们也是在给inputType赋值。那我们为什么不直接使用inputType这个属性呢—–其实android官方也是建议直接使用inputType这个属性的。不管是使用autoText和capitalize或者inputType,其实只是对手机输入法软键盘有一些影响。EditText本身不会对setText的内容做什么调整。
如果你还是在使用autoText和capitalize这2个属性，最好使用inputType替换。不然出现如下警告：
Deprecated views, attributes and so on are deprecated because there is a better way to do something. Do it that new way. You’ve been warned
通过警告也可以看到，autoText和capitalize已经过时了。

去记录一个过时的方法，感觉有点“然而这并没有什么卵用”的感觉。只是自己在看到这个属性时，不知道这个属性在干什么。所以当我弄明白的时候，就记录于此

Android - 控件android:ems属性

（转载自：http://blog.csdn.net/caroline_wendy/article/details/41684255）
xml中android:ems属性，作为EditText默认生成的属性，其含义是需要编辑的字符串长度。
设置为10时，最多编辑10个em，一个em单位是两个inch，但是随着自动调整，在Android中em代表‘M’的数量。
但是EditText的属性，只有在android:layout_width=“wrap_content”时，才会显示；
如果是android:layout_width=“match_parent”时，则不会有变化。

em参考：
http://www.w3.org/Style/Examples/007/units
“The em is simply the font size. In an element with a 2in font, 1em thus means 2in. Expressing sizes, such as margins and paddings, in em means they are related to the font size, and if the user has a big font (e.g., on a big screen) or a small font (e.g., on a handheld device), the sizes will be in proportion. Declarations such as ‘text-indent: 1.5em’ and ‘margin: 1em’ are extremely common in CSS.”

ems属性参考：
参考：http://stackoverflow.com/questions/7053738/what-is-meant-by-ems-android-textview
android:ems or setEms(n) sets the width of a TextView to fit a text of n ‘M’ letters regardless of the actual text extension and text size. See wikipedia Em unit. but only when the layout_width is set to “wrap_content”. Other layout_width values override the ems width setting.
Adding an android:textSize attribute determines the physical width of the view to the textSize * length of a text of n ‘M’s set above.

我的Android进阶之旅——>Android 标签的用法

(转载自：http://blog.csdn.net/ouyang_peng/article/details/46957281)
布局资源文件的根节点可以使用容器控件（如LinearLayout、FrameLayout等），也可以使用非容器控件(如：EditText、TextView等)。对于非容器控件，只能在非容器控件标签中放< requestFocus />标签，表示将当前控件设为焦点。如下代码：

1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
2.     android:layout_width="match_parent"  
3.     android:layout_height="match_parent"  
4.     android:orientation="vertical" >  
5.   
6.     <Button  
7.         android:id="@+id/buttonRingtone"  
8.         android:layout_width="wrap_content"  
9.         android:layout_height="wrap_content"  
10.         android:text="设置来电铃声" />  
11.   
12.     <Button  
13.         android:id="@+id/buttonAlarm"  
14.         android:layout_width="wrap_content"  
15.         android:layout_height="wrap_content"  
16.         android:text="设置闹钟铃声" />  
17.   
18.     <Button  
19.         android:id="@+id/buttonNotification"  
20.         android:layout_width="wrap_content"  
21.         android:layout_height="wrap_content"  
22.         android:text="设置通知铃声" />  
23.   
24.     <EditText  
25.         android:id="@+id/text"  
26.         android:layout_width="match_parent"  
27.         android:layout_height="wrap_content" >  
28.         <!-- 当前控件处于焦点状态 -->  
29.         <requestFocus />  
30.     </EditText>  
31. </LinearLayout>  

运行后，EditText控件处于焦点状态，光标一直在动，