linux系统运行一段时间后会发现/var/spool/clientmqueue/目录很大，甚至占满了不大的磁盘空间，这些文件是如何产生的，能否清除，如何清除呢？ 该目录下的文件是corntab操作产生的，这些文件一般要通过mail的形式发给对应的用户的，如果sendMail没有启动，这些文件就会长期保存在这里. 这些文件可以清除，但清除方法不能用一般的rm方法，会示显示参数列表过长（-bash: /bin/rm: Argument list too long）无法用rm直接删除. 正确的清除方法如下: 以root身份进入/var/spool/clientmqueue/，执行： ls|xargs rm -f 就能全部删除了 如何才能不产生这些文件呢？彻底的解决方法如下： 将crontab里面的命令后面加上 > /dev/null 2>&1。 如：ls -l / > /dev/null 2>&1 源自：http://blog.3gstdy.com

1、序列化 Volatile transient http://www.blogjava.net/fhtdy2004/archive/2009/06/20/286112.html 2、Math API http://hunter090730.iteye.com/blog/485770 public static void main(String args[]) { System.out.println(“result:”+11+1); System.out.println(“result:”+”12345”.valueOf(54321)); double d = -4.4999999; System.out.println(Math.ceil(d));//不小于参数的最小整数值. System.out.println(Math.floor(d));//不大于参数的最大整数值. System.out.println(Math.round(d));//四舍五入法最接近参数的int/long值. } 输出为: result:111 result:54321 -4.0 -5.0 -4 3、Android的Message,MessageQueue,Looper,Handler详解+实例 http://blog.csdn.net/zhangren07/article/details/6400845 4、HashTable ,HashMap 5、Android 主要组件Activity, Service, ContextProvider, BroadcastReceiver 6、android:screenOrientation

问题分析： 数据表损坏造成的。 解决方法： 1、通过论坛的 tool 工具进行修复 下载地址和使用说明见：http://www.discuz.net/thread-982699-1-1.html 2、myisamchk 修复 myisamchk 命令的格式如下： 1）myisamchk –recover tbl_name 2）myisamchk –recover /path/tbl_name 这种方法要指定数据表在磁盘上的位置。 3、使用 phpMyAdmin 修复数据的方法 进入论坛数据库，然后选择要修复的表，在页脚下拉框选择“修复”即可。 注意：如果需要修复数据库，修复前一定要做好备份。

SSH开发项目是目前十分流行的一个趋势。对于从事JavaEE项目开发多年的朋友来说，开发时使用SSH确实能带来不少的便利。SSH帮你做了一个规划，让你将不同的程序代码放到不同的地方。使整个工程看起来，更加工整，大家都采用这种模式开发程序，相互更容易沟通。新的成员也更容易融入到项目中。但对于刚入行的朋友来说，有点力不从心。有些朋友会说我只是实现一个很小的功能，为什么要写那么多的代码，建立那么多的类，还有一大堆的配置文件。出现一些问题还要花上半天去找原因，真是麻烦。所以在这里我想结合自己的体会、经历，对于初涉及到SSH项目的朋友，说说如何快速定位问题。 1、直接根据错误日志找到出错位置。(这种方法比较容易，大家常用的，不多说) 对一些不明错误（所谓不明错误是指编译没有问题，运行过程也不报错，但就是得不到预期的结果）用第一种方法是找不到原因的。要查找此类问题要根据SSH框架的结构，我们都知道： SSH框架是由三个框架有机组合而成的，它们分工明确，流水作业。从前台到后台，从Http请求到数据库,依次为Stucts->Spring->Hibernate。所以当出现错误时，我们可采用两种方法： 2、顺藤摸瓜： 从Stucts开始，看看是否能接收到正确的请求数据。如果正确，接着往下看看Spring中的业务操作是否正确，如果没有问题就接着往下找，到Hibernate层看看，操作数据库是否有问题。对于一般的问题通过这三个步骤都能找出问题的原因。但这种找原因方法破费太大了一些。对于那些隐蔽较好的错误。或者，开发者，过于疲劳没有思路时才如此全面检查。另外：这种方法对初涉及SSH项目的朋友比较有好处，多如此查找几次你就明白了SSH框架的运行机制。 3、大胆猜测，定点检查： 如果你从事SSH项目有一年半载了，对SSH比较熟悉了，并且对所做项目比较了解。遇到不明错误就可根据经验猜测什么地方出现了问题，就在那打上一个断点，或者多猜测几个位置，用一组测试数据测试，当运行到断点时，看看数据是否有异常。 转载请标明出处：3G Study :http://blog.3gstdy.com/archives/594

http://bbs.weiphone.com/read-htm-tid-812586-page-1.html 本来想在cydia store上买一个的，可以国内怎么也连不上。后来找了找，在国外一个网站上找到了displayout程序。版本低了点，不过我测试了可以正常使用，特意给大家分享一下。 DEB格式的，DEB的安装见网上有关贴子。我用的是下面的方法： 1、首先用WinSCP或iPhone Exlplorer或者其它软件将Deb包拷贝到 /var/root/Media/Cydia/AutoInstall（如果没有这个文件夹，就创建一个，注意大小写） 2、重新启动 iPad 后就会自动安装, 之后再重启 iPad 就完成安装了。 displayout安装包 displayout.deb (20 K) 下载次数:5491 =================================== 分量5条线，三条是信号，2条是音频，分量最高可传输与支持1080P的视频，AV三条线，一条是信号，2条是音频，AV是576 i的信号传输 =================================== 复合视频 =================================== 苹果视频线有5头和3头之分,5头的统称为色差线用于大多数液晶电视 输出图像更清晰,红色和白色插头为音频输出 红蓝绿为视频输出.所以 画面清晰度方面要好于3头AV线的很多.3头的统称为 AV 线 一般用于老式的电视 红色和白色插头为音频输出.黄色插头为视频输出.输出图像清晰度相对于5头线较差 ====================== 只要用机子进入设置-通用-关于本机,就可以看到Apple Composite AV Cable的字样就绝对假不了色差视频 发挥电视极致 卡登仕Wii极品色差分量线 ============================== 头视频线 可用型号：IPAD iphone 一代、iphone 3G、iphone 3Gs、touch 一代、touch 2代、touch 3代NANO 4、NANO5 iphone 4 touch 4代 ============================== http://www.shangpinjia.com/show.php?catid=1006&id=15186 客户最关心的问题来了 很多客户问这视频线 可以同步界面或者游戏吗？答：是可以的 ， 为了这个问题，店主自己测试了效果，前提是需要 越狱 你的IPAD iphone 4 3gs 等等需要越狱过 就可以同步游戏了 下面放上教程（越狱参考各大网站教程） 1：首先我们需要在手机上安装一个软件（TVOUT）有几个版本 都支持）可以自己到cydia下载 下面有cydia下载教程 自己也可以到各大网站下载 下面是在手机上cydia下载的 这个是越狱后的文件，我手机是中文版本的 因为我下了中文包， 自带是英文的 点最右边的搜索 输入 tvout 这时会弹出下面这个，我建议下载tvout 2 新版的嘛 比较好用 安装成功了 就是这个软件 我们的iphone 4 IPAD 有这个图标就OK乐 下面是这软件两种版本 但是都支持 接下来 是接线 接线问题 这个线是总长2米 客户总问的问题，还有带USB接口 可以边玩游戏边充电 本连接的视频线是五头的 所以直接按色在电视机上插上就可以了 电视机 后面插孔 是5个插头 不过我们这款是五头的 直接按色插上 绿色=绿色 蓝色=蓝牙 红色=红色 L和R 对应 视频线上的L线和R线 分别是红和白 已经成功插上 L和R 是下面两个 这时将苹果插头 插进iphone 或者 IPAD 然后电视选择 component输出 ，个人电视品牌不一样，请自己选择，图片仅供参考 电视自动转变为 你手机的界面 注意：旧版本的tvout 需要进入tvout 时才会帮你转变界面 我的电视是42寸的 ，个人电视尺寸不可以一样。可以自行到tvout里面设置尺寸，具体自己摸索 玩GT 赛车 系列 给力 斗地主 看优酷 大电视 弹琴 喷怒的小鸟 完成 注意问题： 1：玩大型游戏会出现卡屏时，直接拨掉线在插上 就可以恢复界面 2：看视频，玩游戏时，不横屏时，请将手机（横竖）摇晃几下就可以恢复横屏 http://bbs.weiphone.com/read-htm-tid-253530.html http://support.apple.com/kb/HT1454?viewlocale=zh_CN http://gogowiki.cn/?p=19807 Veency VNC Viewer http://www.happypda.com/read.php?107

我们之前曾向大家介绍了过《Android应用核心——Intent》。Intent可以算得上Android应用开发的重点之一，它负责对应用中各个组件之间的通讯与相互协调和调用。但是在Android开发中，对Android应用程序提速需要很多技巧和原则。首先， 我们要先明白“加快”是有两层意思的，第一层是代码执行所需要的时间，第二层意思是用户需要等待用户界面响应的时间。这两者有很大的不同，当然我们必须提高代码执行的效率，但是最重要的是用户所看到的东西。所以，如果不是必须的，就不要让用户等待。下面是提高Android应用程序运行速度的几条原则。 一、不要让UI线程等待 最基本的一个原则就是不要在用户界面线程中执行耗时的操作，如果这样做，用户界面将在操作完成前被锁定（界面卡死），这就给用户带来不好的使用体验。如果耗时超长，那么系统会删除该线程或提示用户是否中止该操作。 如果在UI线程中处理一些工作（业务操作），那么不管你的代码执行的是如何的流畅，其实都是一堆垃圾。 二、耗时操作 有哪些耗时的操作呢？最常见的是网络连接操作，网络状态随着环境的变化有很大差异，网络好的地方可能速度很快，但网络差的地方需要等待很长时间，所以一定不能在UI线程中执行网络操作。另外就是数据库操作和SD卡文件的读写操作，这些操作都尽量不要在UI线程中完成，对于数据库操作，我们可以建一些索引来提高程序运行速度。 三、模拟器和真实的设备 在模拟器和真实的设备上运行也有很大的差异，模拟器需要更好的CPU，如果你的电脑性能很差，你就会感觉到运行速度很慢，但如果在真实的设备上运行会很快，另外模拟器使用的是系统硬盘，访问速度会比真实的设备访问SD卡快很多。 四、通知用户 当需要用户等待时，一定要用进度条等告诉用户程序还在运行中，不要让用户界面卡死，使用一些正在载入的动画会让用户有更好的使用体验。

一、打开输入法窗口:

InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); // 接受软键盘输入的编辑文本或其它视图 imm.showSoftInput(submitBt,InputMethodManager.SHOW_FORCED);

二、关闭出入法窗口

InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);

inputMethodManager.hideSoftInputFromWindow(OpeListActivity.this.getCurrentFocus().getWindowToken(),

InputMethodManager.HIDE_NOT_ALWAYS);

//接受软键盘输入的编辑文本或其它视图

inputMethodManager

.showSoftInput(submitBt,InputMethodManager.SHOW_FORCED);

三、如果输入法打开则关闭，如果没打开则打开 InputMethodManager m=(InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); m.toggleSoftInput(0, InputMethodManager.HIDE_NOT_ALWAYS); 四、获取输入法打开的状态 InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); boolean isOpen=imm.isActive(); isOpen若返回true，则表示输入法打开

DataCross V1.3 新特性 1、支持SQLite数据库； 2、支持用SAX读写XML，之前版本只有用dom解析xml 3、在xml中增加对大文本字段的支持。文本字段中可以有换行. 4、增加了SimpleObjectWriter和SimpleObjectReader.可以对java对象进行读写操作。 下载请到： http://bbs.daahe.com/td-5443-1-1.html

http://blog.csdn.net/mayingcai1987/archive/2011/04/25/6362325.aspx

1. /*
2. • Copyright (C) 2008 The Android Open Source Project
3. *
4. • Licensed under the Apache License, Version 2.0 (the “License”);
5. • you may not use this file except in compliance with the License.
6. • You may obtain a copy of the License at
7. *
8. • http://www.apache.org/licenses/LICENSE-2.0
9. *
10. • Unless required by applicable law or agreed to in writing, software
11. • distributed under the License is distributed on an “AS IS” BASIS,
12. • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13. • See the License for the specific language governing permissions and
14. • limitations under the License.
15. */
16. package com.flora;
17. import android.content.Context;
18. import android.content.SharedPreferences;
19. import android.content.res.Resources;
20. import android.graphics.Bitmap;
21. import android.graphics.PixelFormat;
22. import android.graphics.Rect;
23. import android.graphics.drawable.Drawable;
24. import android.util.AttributeSet;
25. import android.view.GestureDetector;
26. import android.view.Gravity;
27. import android.view.MotionEvent;
28. import android.view.View;
29. import android.view.ViewConfiguration;
30. import android.view.ViewGroup;
31. import android.view.WindowManager;
32. import android.view.GestureDetector.SimpleOnGestureListener;
33. import android.widget.AdapterView;
34. import android.widget.ImageView;
35. import android.widget.ListView;
36. public class DragAndDropListView extends ListView {
37. private ImageView mDragView;
38. private WindowManager mWindowManager;
39. private WindowManager.LayoutParams mWindowParams;
40. /**
41. • At which position is the item currently being dragged. Note that this
42. • takes in to account header items.
43. */
44. private int mDragPos;
45. /**
46. • At which position was the item being dragged originally
47. */
48. private int mSrcDragPos;
49. private int mDragPointX; // at what x offset inside the item did the user grab it
50. private int mDragPointY; // at what y offset inside the item did the user grab it
51. private int mXOffset; // the difference between screen coordinates and coordinates in this view
52. private int mYOffset; // the difference between screen coordinates and coordinates in this view
53. private DragListener mDragListener;
54. private DropListener mDropListener;
55. private RemoveListener mRemoveListener;
56. private int mUpperBound;
57. private int mLowerBound;
58. private int mHeight;
59. private GestureDetector mGestureDetector;
60. private static final int FLING = 0;
61. private static final int SLIDE = 1;
62. private static final int TRASH = 2;
63. private int mRemoveMode = -1;
64. private Rect mTempRect = new Rect();
65. private Bitmap mDragBitmap;
66. private final int mTouchSlop;
67. private int mItemHeightNormal;
68. private int mItemHeightExpanded;
69. private int mItemHeightHalf;
70. private Drawable mTrashcan;
71. public DragAndDropListView(Context context, AttributeSet attrs) {
72. super(context, attrs);
73. SharedPreferences pref = context.getSharedPreferences(“Music”, 3);
74. mRemoveMode = pref.getInt(“deletemode”, -1);
75. mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
76. Resources res = getResources();
77. mItemHeightNormal = res.getDimensionPixelSize(R.dimen.normal_height);
78. mItemHeightHalf = mItemHeightNormal / 2;
79. mItemHeightExpanded = res.getDimensionPixelSize(R.dimen.expanded_height);
80. }
81. @Override
82. public boolean onInterceptTouchEvent(MotionEvent ev) {
83. if (mRemoveListener != null && mGestureDetector == null) {
84. if (mRemoveMode == FLING) {
85. mGestureDetector = new GestureDetector(getContext(), new SimpleOnGestureListener() {
86. @Override
87. public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
88. float velocityY) {
89. if (mDragView != null) {
90. if (velocityX > 1000) {
91. Rect r = mTempRect;
92. mDragView.getDrawingRect(r);
93. if ( e2.getX() > r.right * 2 / 3) {
94. // fast fling right with release near the right edge of the screen
95. stopDragging();
96. mRemoveListener.remove(mSrcDragPos);
97. unExpandViews(true);
98. }
99. }
100. // flinging while dragging should have no effect
101. return true;
102. }
103. return false;
104. }
105. });
106. }
107. }
108. if (mDragListener != null || mDropListener != null) {
109. switch (ev.getAction()) {
110. case MotionEvent.ACTION_DOWN:
111. int x = (int) ev.getX();

112. int y = (int) ev.getY();

113. int itemnum = pointToPosition(x, y);

114. if (itemnum == AdapterView.INVALID_POSITION) {
115. break;
116. }
117. ViewGroup item = (ViewGroup) getChildAt(itemnum - getFirstVisiblePosition());
118. mDragPointX = x - item.getLeft();
119. mDragPointY = y - item.getTop();
120. mXOffset = ((int)ev.getRawX()) - x;
121. mYOffset = ((int)ev.getRawY()) - y;
122. // The left side of the item is the grabber for dragging the item
123. if (x < 64) {
124. item.setDrawingCacheEnabled(true);
125. // Create a copy of the drawing cache so that it does not get recycled
126. // by the framework when the list tries to clean up memory
127. Bitmap bitmap = Bitmap.createBitmap(item.getDrawingCache());
128. startDragging(bitmap, x, y);
129. mDragPos = itemnum;
130. mSrcDragPos = mDragPos;
131. mHeight = getHeight();
132. int touchSlop = mTouchSlop;
133. mUpperBound = Math.min(y - touchSlop, mHeight / 3);
134. mLowerBound = Math.max(y + touchSlop, mHeight * 2 /3);
135. return false;
136. }
137. stopDragging();
138. break;
139. }
140. }
141. return super.onInterceptTouchEvent(ev);
142. }
143. /*
144. • pointToPosition() doesn’t consider invisible views, but we
145. • need to, so implement a slightly different version.
146. */
147. private int myPointToPosition(int x, int y) {
148. if (y < 0) {
149. // when dragging off the top of the screen, calculate position
150. // by going back from a visible item
151. int pos = myPointToPosition(x, y + mItemHeightNormal);
152. if (pos > 0) {
153. return pos - 1;
154. }
155. }
156. Rect frame = mTempRect;
157. final int count = getChildCount();
158. for (int i = count - 1; i >= 0; i–) {
159. final View child = getChildAt(i);
160. child.getHitRect(frame);
161. if (frame.contains(x, y)) {
162. return getFirstVisiblePosition() + i;
163. }
164. }
165. return INVALID_POSITION;
166. }
167. private int getItemForPosition(int y) {
168. int adjustedy = y - mDragPointY - mItemHeightHalf;
169. int pos = myPointToPosition(0, adjustedy);
170. if (pos >= 0) {
171. if (pos <= mSrcDragPos) {
172. pos += 1;
173. }
174. } else if (adjustedy < 0) {
175. // this shouldn’t happen anymore now that myPointToPosition deals
176. // with this situation
177. pos = 0;
178. }
179. return pos;
180. }
181. private void adjustScrollBounds(int y) {
182. if (y >= mHeight / 3) {
183. mUpperBound = mHeight / 3;
184. }
185. if (y <= mHeight * 2 / 3) {
186. mLowerBound = mHeight * 2 / 3;
187. }
188. }
189. /*
190. • Restore size and visibility for all listitems
191. */
192. private void unExpandViews(boolean deletion) {
193. for (int i = 0;; i++) {
194. View v = getChildAt(i);
195. if (v == null) {
196. if (deletion) {
197. // HACK force update of mItemCount
198. int position = getFirstVisiblePosition();
199. int y = getChildAt(0).getTop();
200. setAdapter(getAdapter());
201. setSelectionFromTop(position, y);
202. // end hack
203. }
204. try {
205. layoutChildren(); // force children to be recreated where needed
206. v = getChildAt(i);
207. } catch (IllegalStateException ex) {
208. // layoutChildren throws this sometimes, presumably because we’re
209. // in the process of being torn down but are still getting touch
210. // events
211. }
212. if (v == null) {
213. return;
214. }
215. }
216. ViewGroup.LayoutParams params = v.getLayoutParams();
217. params.height = mItemHeightNormal;
218. v.setLayoutParams(params);
219. v.setVisibility(View.VISIBLE);
220. }
221. }
222. /* Adjust visibility and size to make it appear as though
223. • an item is being dragged around and other items are making
224. • room for it:
225. • If dropping the item would result in it still being in the
226. • same place, then make the dragged listitem’s size normal,
227. • but make the item invisible.
228. • Otherwise, if the dragged listitem is still on screen, make
229. • it as small as possible and expand the item below the insert
230. • point.
231. • If the dragged item is not on screen, only expand the item
232. • below the current insertpoint.
233. */
234. private void doExpansion() {
235. int childnum = mDragPos - getFirstVisiblePosition();
236. if (mDragPos > mSrcDragPos) {
237. childnum++;
238. }
239. int numheaders = getHeaderViewsCount();
240. View first = getChildAt(mSrcDragPos - getFirstVisiblePosition());
241. for (int i = 0;; i++) {
242. View vv = getChildAt(i);
243. if (vv == null) {
244. break;
245. }
246. int height = mItemHeightNormal;
247. int visibility = View.VISIBLE;
248. if (mDragPos < numheaders && i == numheaders) {
249. // dragging on top of the header item, so adjust the item below
250. // instead
251. if (vv.equals(first)) {
252. visibility = View.INVISIBLE;
253. } else {
254. height = mItemHeightExpanded;
255. }
256. } else if (vv.equals(first)) {
257. // processing the item that is being dragged
258. if (mDragPos == mSrcDragPos || getPositionForView(vv) == getCount() - 1) {
259. // hovering over the original location
260. visibility = View.INVISIBLE;
261. } else {
262. // not hovering over it
263. // Ideally the item would be completely gone, but neither
264. // setting its size to 0 nor settings visibility to GONE
265. // has the desired effect.
266. height = 1;
267. }
268. } else if (i == childnum) {
269. if (mDragPos >= numheaders && mDragPos < getCount() - 1) {
270. height = mItemHeightExpanded;
271. }
272. }
273. ViewGroup.LayoutParams params = vv.getLayoutParams();
274. params.height = height;
275. vv.setLayoutParams(params);
276. vv.setVisibility(visibility);
277. }
278. }
279. @Override
280. public boolean onTouchEvent(MotionEvent ev) {
281. if (mGestureDetector != null) {
282. mGestureDetector.onTouchEvent(ev);
283. }
284. if ((mDragListener != null || mDropListener != null) && mDragView != null) {
285. int action = ev.getAction();
286. switch (action) {
287. case MotionEvent.ACTION_UP:
288. case MotionEvent.ACTION_CANCEL:
289. Rect r = mTempRect;
290. mDragView.getDrawingRect(r);
291. stopDragging();
292. if (mRemoveMode == SLIDE && ev.getX() > r.right * 3 / 4) {
293. if (mRemoveListener != null) {
294. mRemoveListener.remove(mSrcDragPos);
295. }
296. unExpandViews(true);
297. } else {
298. if (mDropListener != null && mDragPos >= 0 && mDragPos < getCount()) {
299. mDropListener.drop(mSrcDragPos, mDragPos);
300. }
301. unExpandViews(false);
302. }
303. break;
304. case MotionEvent.ACTION_DOWN:
305. case MotionEvent.ACTION_MOVE:
306. int x = (int) ev.getX();
307. int y = (int) ev.getY();
308. dragView(x, y);
309. int itemnum = getItemForPosition(y);
310. if (itemnum >= 0) {
311. if (action == MotionEvent.ACTION_DOWN || itemnum != mDragPos) {
312. if (mDragListener != null) {
313. mDragListener.drag(mDragPos, itemnum);
314. }
315. mDragPos = itemnum;
316. doExpansion();
317. }
318. int speed = 0;
319. adjustScrollBounds(y);
320. if (y > mLowerBound) {
321. // scroll the list up a bit
322. if (getLastVisiblePosition() < getCount() - 1) {
323. speed = y > (mHeight + mLowerBound) / 2 ? 16 : 4;
324. } else {
325. speed = 1;
326. }
327. } else if (y < mUpperBound) {
328. // scroll the list down a bit
329. speed = y < mUpperBound / 2 ? -16 : -4;
330. if (getFirstVisiblePosition() == 0
331. && getChildAt(0).getTop() >= getPaddingTop()) {
332. // if we’re already at the top, don’t try to scroll, because
333. // it causes the framework to do some extra drawing that messes
334. // up our animation
335. speed = 0;
336. }
337. }
338. if (speed != 0) {
339. smoothScrollBy(speed, 30);
340. }
341. }
342. break;
343. }
344. return true;
345. }
346. return super.onTouchEvent(ev);
347. }
348. private void startDragging(Bitmap bm, int x, int y) {
349. stopDragging();
350. mWindowParams = new WindowManager.LayoutParams();
351. mWindowParams.gravity = Gravity.TOP | Gravity.LEFT;
352. mWindowParams.x = x - mDragPointX + mXOffset;
353. mWindowParams.y = y - mDragPointY + mYOffset;
354. mWindowParams.height = WindowManager.LayoutParams.WRAP_CONTENT;
355. mWindowParams.width = WindowManager.LayoutParams.WRAP_CONTENT;
356. mWindowParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
357. | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
358. | WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
359. | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
360. | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS;
361. mWindowParams.format = PixelFormat.TRANSLUCENT;
362. mWindowParams.windowAnimations = 0;
363. Context context = getContext();
364. ImageView v = new ImageView(context);
365. v.setBackgroundResource(R.drawable.drag_and_drop_image);
366. v.setPadding(0, 0, 0, 0);
367. v.setImageBitmap(bm);
368. mDragBitmap = bm;
369. mWindowManager = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
370. mWindowManager.addView(v, mWindowParams);
371. mDragView = v;
372. }
373. private void dragView(int x, int y) {
374. if (mRemoveMode == SLIDE) {
375. float alpha = 1.0f;
376. int width = mDragView.getWidth();
377. if (x > width / 2) {
378. alpha = ((float)(width - x)) / (width / 2);
379. }
380. mWindowParams.alpha = alpha;
381. }
382. if (mRemoveMode == FLING || mRemoveMode == TRASH) {
383. mWindowParams.x = x - mDragPointX + mXOffset;
384. } else {
385. mWindowParams.x = 0;
386. }
387. mWindowParams.y = y - mDragPointY + mYOffset;
388. mWindowManager.updateViewLayout(mDragView, mWindowParams);
389. if (mTrashcan != null) {
390. int width = mDragView.getWidth();
391. if (y > getHeight() * 3 / 4) {
392. mTrashcan.setLevel(2);
393. } else if (width > 0 && x > width / 4) {
394. mTrashcan.setLevel(1);
395. } else {
396. mTrashcan.setLevel(0);
397. }
398. }
399. }
400. private void stopDragging() {
401. if (mDragView != null) {
402. mDragView.setVisibility(GONE);
403. WindowManager wm = (WindowManager)getContext().getSystemService(Context.WINDOW_SERVICE);
404. wm.removeView(mDragView);
405. mDragView.setImageDrawable(null);
406. mDragView = null;
407. }
408. if (mDragBitmap != null) {
409. mDragBitmap.recycle();
410. mDragBitmap = null;
411. }
412. if (mTrashcan != null) {
413. mTrashcan.setLevel(0);
414. }
415. }
416. public void setTrashcan(Drawable trash) {
417. mTrashcan = trash;
418. mRemoveMode = TRASH;
419. }
420. public void setDragListener(DragListener l) {
421. mDragListener = l;
422. }
423. public void setDropListener(DropListener l) {
424. mDropListener = l;
425. }
426. public void setRemoveListener(RemoveListener l) {
427. mRemoveListener = l;
428. }
429. public interface DragListener {
430. void drag(int from, int to);
431. }
432. public interface DropListener {
433. void drop(int from, int to);
434. }
435. public interface RemoveListener {
436. void remove(int which);
437. }
438. }

1. Screen size (屏幕尺寸):具体的屏幕物理长度,以对角线长度做为标识,平时我们说的3”屏,7”屏就是指这个,是物理尺寸
2. Resolution (分辨率):屏幕上总共的物理像素点,虽然经常被以800X600之类的来描述,但是在android中,他并不指代具体的屏幕宽高比例,注意,分辨率和屏幕大小没有任何联系,分辨率只是描述点的而已,所以相同分辨率下,屏幕越小,越清晰
3. density(密度) :表示每英寸有多少个显示点，density是以分辨率为基础,即指在固定分辨率上散开的像素点,也即是说屏幕的density越大,单位上分散的像素就越多,可以理解为点距就越小,这样如果某个元素是以px为单位的,那么在低密度的屏幕上就会变大,应用程序可以通过指定high-dpi等三种资源来实现平台的独立性 ASPECT RATIO (宽高比例):也就是平时我们说的4比3之流
4. Density-independent pixel(dip):dip是一种虚拟的像素单位,专门用来给程序定义UI用,Android高度推荐使用这个,可以为不同的dip设置不同的资源进行自动切换 pixels = dips (density / 160)即dip相当于屏幕density=160时的一个像素点，density=160时是一个点显示一个像素，而density=240时是3个点显示两个像素，图像看起来大一些，真实像素只有1280\2/3px,800*2/3px。
5. Dot per inch(DPI) :就是一英寸上显示的点，而这个点并不是意义上的像素。

一般来说，显示器是96DPI，也就是说96像素等于1inch，但实际上不应该是这样，因为显示器的分辨率可以调整。 对于你上面所说的显示器设置，96DPI可以理解为用96象素来表示一英寸，而变成120DPI的时候，是用120像素来表示一英寸，而系统的对象（字体，图像）的是用英寸数来表示的，所以120DPI时，图象和字体就变大了。 就是一英寸上显示的点，而这个点并不是意义上的像素。 一般来说，显示器是96DPI，也就是说96像素等于1inch，但实际上不应该是这样，因为显示器的分辨率可以调整。 对于你上面所说的显示器设置，96DPI可以理解为用96象素来表示一英寸，而变成120DPI的时候，是用120像素来表示一英寸，而系统的对象（字体，图像）的是用英寸数来表示的，所以120DPI时，图象和字体就变大了。 色阶 :也就是平时我们说的 65536色,26万色,1600万色并没有数字看起来差别那么大,这实际上只是表示相邻的三个色阶而已,当然,1600万色显示效果是最好的