1、概述

众所周知，Activity在不明确指定屏幕方向和configChanges时，当用户旋转屏幕会重新启动。当然了，应对这种情况，Android给出了几种方案：

a、如果是少量数据，可以通过onSaveInstanceState()和onRestoreInstanceState()进行保存与恢复。

Android会在销毁你的Activity之前调用onSaveInstanceState()方法，于是，你可以在此方法中存储关于应用状态的数据。然后你可以在onCreate()或onRestoreInstanceState()方法中恢复。

b、如果是大量数据，使用Fragment保持需要恢复的对象。

c、自已处理配置变化。

注:getLastNonConfigurationInstance()已经被弃用，被上述方法二替代。

2、难点

假设当前Activity在onCreate中启动一个异步线程去夹在数据，当然为了给用户一个很好的体验，会有一个ProgressDialog，当数据加载完成，ProgressDialog消失，设置数据。

这里，如果在异步数据完成加载之后，旋转屏幕，使用上述a、b两种方法都不会很难，无非是保存数据和恢复数据。

但是，如果正在线程加载的时候，进行旋转，会存在以下问题：

a)此时数据没有完成加载，onCreate重新启动时，会再次启动线程；而上个线程可能还在运行，并且可能会更新已经不存在的控件，造成错误。

b)关闭ProgressDialog的代码在线程的onPostExecutez中，但是上个线程如果已经杀死，无法关闭之前ProgressDialog。

c)谷歌的官方不建议使用ProgressDialog，这里我们会使用官方推荐的DialogFragment来创建我的加载框，如果你不了解：请看Android 官方推荐 : DialogFragment 创建对话框。这样，其实给我们带来一个很大的问题，DialogFragment说白了是Fragment，和当前的Activity的生命周期会发生绑定，我们旋转屏幕会造成Activity的销毁，当然也会对DialogFragment造成影响。

下面我将使用几个例子，分别使用上面的3种方式，和如何最好的解决上述的问题。

3、使用onSaveInstanceState()和onRestoreInstanceState()进行数据保存与恢复

代码：

[java] view plain copy

1. packagecom.example.zhy_handle_runtime_change;
3. importjava.util.ArrayList;
4. importjava.util.Arrays;
6. importandroid.app.DialogFragment;
7. importandroid.app.ListActivity;
8. importandroid.os.AsyncTask;
9. importandroid.os.Bundle;
10. importandroid.util.Log;
11. importandroid.widget.ArrayAdapter;
12. importandroid.widget.ListAdapter;
13. /**
14. *不考虑加载时，进行旋转的情况，有意的避开这种情况，后面例子会介绍解决方案
15. *@authorzhy
16. *
17. */
18. publicclassSavedInstanceStateUsingActivityextendsListActivity
19. {
20. privatestaticfinalStringTAG="MainActivity";
21. privateListAdaptermAdapter;
22. privateArrayList<String>mDatas;
23. privateDialogFragmentmLoadingDialog;
24. privateLoadDataAsyncTaskmLoadDataAsyncTask;
26. @Override
27. publicvoidonCreate(BundlesavedInstanceState)
28. {
29. super.onCreate(savedInstanceState);
30. Log.e(TAG,"onCreate");
31. initData(savedInstanceState);
32. }
34. /**
35. *初始化数据
36. */
37. privatevoidinitData(BundlesavedInstanceState)
38. {
39. if(savedInstanceState!=null)
40. mDatas=savedInstanceState.getStringArrayList("mDatas");
42. if(mDatas==null)
43. {
44. mLoadingDialog=newLoadingDialog();
45. mLoadingDialog.show(getFragmentManager(),"LoadingDialog");
46. mLoadDataAsyncTask=newLoadDataAsyncTask();
47. mLoadDataAsyncTask.execute();
49. }else
50. {
51. initAdapter();
52. }
54. }
56. /**
57. *初始化适配器
58. */
59. privatevoidinitAdapter()
60. {
61. mAdapter=newArrayAdapter<String>(
62. SavedInstanceStateUsingActivity.this,
63. android.R.layout.simple_list_item_1,mDatas);
64. setListAdapter(mAdapter);
65. }
67. @Override
68. protectedvoidonRestoreInstanceState(Bundlestate)
69. {
70. super.onRestoreInstanceState(state);
71. Log.e(TAG,"onRestoreInstanceState");
72. }
74. @Override
75. protectedvoidonSaveInstanceState(BundleoutState)
76. {
77. super.onSaveInstanceState(outState);
78. Log.e(TAG,"onSaveInstanceState");
79. outState.putSerializable("mDatas",mDatas);
81. }
83. /**
84. *模拟耗时操作
85. *
86. *@return
87. */
88. privateArrayList<String>generateTimeConsumingDatas()
89. {
90. try
91. {
92. Thread.sleep(2000);
93. }catch(InterruptedExceptione)
94. {
95. }
96. returnnewArrayList<String>(Arrays.asList("通过Fragment保存大量数据",
97. "onSaveInstanceState保存数据",
98. "getLastNonConfigurationInstance已经被弃用","RabbitMQ","Hadoop",
99. "Spark"));
100. }
102. privateclassLoadDataAsyncTaskextendsAsyncTask<Void,Void,Void>
103. {
104. @Override
105. protectedVoiddoInBackground(Void...params)
106. {
107. mDatas=generateTimeConsumingDatas();
108. returnnull;
109. }
111. @Override
112. protectedvoidonPostExecute(Voidresult)
113. {
114. mLoadingDialog.dismiss();
115. initAdapter();
116. }
117. }
119. @Override
120. protectedvoidonDestroy()
121. {
122. Log.e(TAG,"onDestroy");
123. super.onDestroy();
124. }
126. }

界面为一个ListView，onCreate中启动一个异步任务去加载数据，这里使用Thread.sleep模拟了一个耗时操作；当用户旋转屏幕发生重新启动时，会onSaveInstanceState中进行数据的存储，在onCreate中对数据进行恢复，免去了不必要的再加载一遍。

运行结果：

当正常加载数据完成之后，用户不断进行旋转屏幕，log会不断打出：onSaveInstanceState->onDestroy->onCreate->onRestoreInstanceState，验证我们的确是重新启动了，但是我们没有再次去进行数据加载。

如果在加载的时候，进行旋转，则会发生错误，异常退出（退出原因：dialog.dismiss()时发生NullPointException，因为与当前对话框绑定的FragmentManager为null，又有兴趣的可以去Debug，这个不是关键）。

效果图：

4、使用Fragment来保存对象，用于恢复数据

如果重新启动你的Activity需要恢复大量的数据，重新建立网络连接，或者执行其他的密集型操作，这样因为配置发生变化而完全重新启动可能会是一个慢的用户体验。并且，使用系统提供的onSaveIntanceState()的回调中，使用Bundle来完全恢复你Activity的状态是可能是不现实的（Bundle不是设计用来携带大量数据的（例如bitmap），并且Bundle中的数据必须能够被序列化和反序列化），这样会消耗大量的内存和导致配置变化缓慢。在这样的情况下，当你的Activity因为配置发生改变而重启，你可以通过保持一个Fragment来缓解重新启动带来的负担。这个Fragment可以包含你想要保持的有状态的对象的引用。

当Android系统因为配置变化关闭你的Activity的时候，你的Activity中被标识保持的fragments不会被销毁。你可以在你的Activity中添加这样的fragements来保存有状态的对象。

在运行时配置发生变化时，在Fragment中保存有状态的对象
a) 继承Fragment，声明引用指向你的有状态的对象
b) 当Fragment创建时调用setRetainInstance(boolean)
c) 把Fragment实例添加到Activity中
d) 当Activity重新启动后，使用FragmentManager对Fragment进行恢复
代码：

首先是Fragment:

[java] view plain copy

1. packagecom.example.zhy_handle_runtime_change;
3. importandroid.app.Fragment;
4. importandroid.graphics.Bitmap;
5. importandroid.os.Bundle;
7. publicclassRetainedFragmentextendsFragment
8. {
9. //dataobjectwewanttoretain
10. privateBitmapdata;
11. //thismethodisonlycalledonceforthisfragment
12. @Override
13. publicvoidonCreate(BundlesavedInstanceState)
14. {
15. super.onCreate(savedInstanceState);
16. //retainthisfragment
17. setRetainInstance(true);
18. }
20. publicvoidsetData(Bitmapdata)
21. {
22. this.data=data;
23. }
25. publicBitmapgetData()
26. {
27. returndata;
28. }
29. }

比较简单，只需要声明需要保存的数据对象，然后提供getter和setter，注意，一定要在onCreate调用setRetainInstance(true);

然后是：FragmentRetainDataActivity

[java] view plain copy

1. packagecom.example.zhy_handle_runtime_change;
3. importandroid.app.Activity;
4. importandroid.app.DialogFragment;
5. importandroid.app.FragmentManager;
6. importandroid.graphics.Bitmap;
7. importandroid.graphics.Bitmap.Config;
8. importandroid.os.Bundle;
9. importandroid.util.Log;
10. importandroid.widget.ImageView;
12. importcom.android.volley.RequestQueue;
13. importcom.android.volley.Response;
14. importcom.android.volley.toolbox.ImageRequest;
15. importcom.android.volley.toolbox.Volley;
17. publicclassFragmentRetainDataActivityextendsActivity
18. {
20. privatestaticfinalStringTAG="FragmentRetainDataActivity";
21. privateRetainedFragmentdataFragment;
22. privateDialogFragmentmLoadingDialog;
23. privateImageViewmImageView;
24. privateBitmapmBitmap;
26. @Override
27. publicvoidonCreate(BundlesavedInstanceState)
28. {
29. super.onCreate(savedInstanceState);
30. setContentView(R.layout.activity_main);
31. Log.e(TAG,"onCreate");
33. //findtheretainedfragmentonactivityrestarts
34. FragmentManagerfm=getFragmentManager();
35. dataFragment=(RetainedFragment)fm.findFragmentByTag("data");
36. //createthefragmentanddatathefirsttime
37. if(dataFragment==null)
38. {
39. //addthefragment
40. dataFragment=newRetainedFragment();
41. fm.beginTransaction().add(dataFragment,"data").commit();
42. }
43. mBitmap=collectMyLoadedData();
44. initData();
46. //thedataisavailableindataFragment.getData()
47. }
49. /**
50. *初始化数据
51. */
52. privatevoidinitData()
53. {
54. mImageView=(ImageView)findViewById(R.id.id_imageView);
55. if(mBitmap==null)
56. {
57. mLoadingDialog=newLoadingDialog();
58. mLoadingDialog.show(getFragmentManager(),"LOADING_DIALOG");
59. RequestQueuenewRequestQueue=Volley
60. .newRequestQueue(FragmentRetainDataActivity.this);
61. ImageRequestimageRequest=newImageRequest(
62. "http://img.my.csdn.net/uploads/201407/18/1405652589_5125.jpg",
63. newResponse.Listener<Bitmap>()
64. {
65. @Override
66. publicvoidonResponse(Bitmapresponse)
67. {
68. mBitmap=response;
69. mImageView.setImageBitmap(mBitmap);
70. //loadthedatafromtheweb
71. dataFragment.setData(mBitmap);
72. mLoadingDialog.dismiss();
73. }
74. },0,0,Config.RGB_565,null);
75. newRequestQueue.add(imageRequest);
76. }else
77. {
78. mImageView.setImageBitmap(mBitmap);
79. }
81. }
83. @Override
84. publicvoidonDestroy()
85. {
86. Log.e(TAG,"onDestroy");
87. super.onDestroy();
88. //storethedatainthefragment
89. dataFragment.setData(mBitmap);
90. }
92. privateBitmapcollectMyLoadedData()
93. {
94. returndataFragment.getData();
95. }
97. }

这里在onCreate总使用了Volley去加载 了一张美女照片，然后在onDestroy中对Bitmap进行存储，在onCreate添加一个或者恢复一个Fragment的引用，然后对Bitmap进行读取和设置。这种方式适用于比较大的数据的存储与恢复。

注：这里也没有考虑加载时旋转屏幕，问题与上面的一致。

效果图：

5、配置configChanges，自己对屏幕旋转的变化进行处理

在menifest中进行属性设置：

[html] view plain copy

1. <activity
2. android:name=".ConfigChangesTestActivity"
3. android:configChanges="screenSize|orientation">
4. </activity>

低版本的API只需要加入orientation，而高版本的则需要加入screenSize。

ConfigChangesTestActivity

[java] view plain copy

1. packagecom.example.zhy_handle_runtime_change;
3. importjava.util.ArrayList;
4. importjava.util.Arrays;
6. importandroid.app.DialogFragment;
7. importandroid.app.ListActivity;
8. importandroid.content.res.Configuration;
9. importandroid.os.AsyncTask;
10. importandroid.os.Bundle;
11. importandroid.util.Log;
12. importandroid.widget.ArrayAdapter;
13. importandroid.widget.ListAdapter;
14. importandroid.widget.Toast;
16. /**
17. *@authorzhy
18. *
19. */
20. publicclassConfigChangesTestActivityextendsListActivity
21. {
22. privatestaticfinalStringTAG="MainActivity";
23. privateListAdaptermAdapter;
24. privateArrayList<String>mDatas;
25. privateDialogFragmentmLoadingDialog;
26. privateLoadDataAsyncTaskmLoadDataAsyncTask;
28. @Override
29. publicvoidonCreate(BundlesavedInstanceState)
30. {
31. super.onCreate(savedInstanceState);
32. Log.e(TAG,"onCreate");
33. initData(savedInstanceState);
34. }
36. /**
37. *初始化数据
38. */
39. privatevoidinitData(BundlesavedInstanceState)
40. {
42. mLoadingDialog=newLoadingDialog();
43. mLoadingDialog.show(getFragmentManager(),"LoadingDialog");
44. mLoadDataAsyncTask=newLoadDataAsyncTask();
45. mLoadDataAsyncTask.execute();
47. }
49. /**
50. *初始化适配器
51. */
52. privatevoidinitAdapter()
53. {
54. mAdapter=newArrayAdapter<String>(ConfigChangesTestActivity.this,
55. android.R.layout.simple_list_item_1,mDatas);
56. setListAdapter(mAdapter);
57. }
59. /**
60. *模拟耗时操作
61. *
62. *@return
63. */
64. privateArrayList<String>generateTimeConsumingDatas()
65. {
66. try
67. {
68. Thread.sleep(2000);
69. }catch(InterruptedExceptione)
70. {
71. }
72. returnnewArrayList<String>(Arrays.asList("通过Fragment保存大量数据",
73. "onSaveInstanceState保存数据",
74. "getLastNonConfigurationInstance已经被弃用","RabbitMQ","Hadoop",
75. "Spark"));
76. }
78. /**
79. *当配置发生变化时，不会重新启动Activity。但是会回调此方法，用户自行进行对屏幕旋转后进行处理
80. */
81. @Override
82. publicvoidonConfigurationChanged(ConfigurationnewConfig)
83. {
84. super.onConfigurationChanged(newConfig);
86. if(newConfig.orientation==Configuration.ORIENTATION_LANDSCAPE)
87. {
88. Toast.makeText(this,"landscape",Toast.LENGTH_SHORT).show();
89. }elseif(newConfig.orientation==Configuration.ORIENTATION_PORTRAIT)
90. {
91. Toast.makeText(this,"portrait",Toast.LENGTH_SHORT).show();
92. }
94. }
96. privateclassLoadDataAsyncTaskextendsAsyncTask<Void,Void,Void>
97. {
98. @Override
99. protectedVoiddoInBackground(Void...params)
100. {
101. mDatas=generateTimeConsumingDatas();
102. returnnull;
103. }
105. @Override
106. protectedvoidonPostExecute(Voidresult)
107. {
108. mLoadingDialog.dismiss();
109. initAdapter();
110. }
111. }
113. @Override
114. protectedvoidonDestroy()
115. {
116. Log.e(TAG,"onDestroy");
117. super.onDestroy();
118. }
120. }

对第一种方式的代码进行了修改，去掉了保存与恢复的代码，重写了onConfigurationChanged；此时，无论用户何时旋转屏幕都不会重新启动Activity，并且onConfigurationChanged中的代码可以得到调用。从效果图可以看到，无论如何旋转不会重启Activity.

效果图：

6、旋转屏幕的最佳实践

下面要开始今天的难点了，就是处理文章开始时所说的，当异步任务在执行时，进行旋转，如果解决上面的问题。

首先说一下探索过程：

起初，我认为此时旋转无非是再启动一次线程，并不会造成异常，我只要即使的在onDestroy里面关闭上一个异步任务就可以了。事实上，如果我关闭了，上一次的对话框会一直存在；如果我不关闭，但是activity是一定会被销毁的，对话框的dismiss也会出异常。真心很蛋疼，并且即使对话框关闭了，任务关闭了；用户旋转还是会造成重新创建任务，从头开始加载数据。

下面我们希望有一种解决方案：在加载数据时旋转屏幕，不会对加载任务进行中断，且对用户而言，等待框在加载完成之前都正常显示：

当然我们还使用Fragment进行数据保存，毕竟这是官方推荐的：

OtherRetainedFragment

[java] view plain copy

1. packagecom.example.zhy_handle_runtime_change;
3. importandroid.app.Fragment;
4. importandroid.os.Bundle;
6. /**
7. *保存对象的Fragment
8. *
9. *@authorzhy
10. *
11. */
12. publicclassOtherRetainedFragmentextendsFragment
13. {
15. //dataobjectwewanttoretain
16. //保存一个异步的任务
17. privateMyAsyncTaskdata;
19. //thismethodisonlycalledonceforthisfragment
20. @Override
21. publicvoidonCreate(BundlesavedInstanceState)
22. {
23. super.onCreate(savedInstanceState);
24. //retainthisfragment
25. setRetainInstance(true);
26. }
28. publicvoidsetData(MyAsyncTaskdata)
29. {
30. this.data=data;
31. }
33. publicMyAsyncTaskgetData()
34. {
35. returndata;
36. }
39. }

和上面的差别不大，唯一不同的就是它要保存的对象编程一个异步的任务了，相信看到这，已经知道经常上述问题的一个核心了，保存一个异步任务，在重启时，继续这个任务。

[java] view plain copy

1. packagecom.example.zhy_handle_runtime_change;
3. importjava.util.ArrayList;
4. importjava.util.Arrays;
5. importjava.util.List;
7. importandroid.os.AsyncTask;
9. publicclassMyAsyncTaskextendsAsyncTask<Void,Void,Void>
10. {
11. privateFixProblemsActivityactivity;
12. /**
13. *是否完成
14. */
15. privatebooleanisCompleted;
16. /**
17. *进度框
18. */
19. privateLoadingDialogmLoadingDialog;
20. privateList<String>items;
22. publicMyAsyncTask(FixProblemsActivityactivity)
23. {
24. this.activity=activity;
25. }
27. /**
28. *开始时，显示加载框
29. */
30. @Override
31. protectedvoidonPreExecute()
32. {
33. mLoadingDialog=newLoadingDialog();
34. mLoadingDialog.show(activity.getFragmentManager(),"LOADING");
35. }
37. /**
38. *加载数据
39. */
40. @Override
41. protectedVoiddoInBackground(Void...params)
42. {
43. items=loadingData();
44. returnnull;
45. }
47. /**
48. *加载完成回调当前的Activity
49. */
50. @Override
51. protectedvoidonPostExecute(Voidunused)
52. {
53. isCompleted=true;
54. notifyActivityTaskCompleted();
55. if(mLoadingDialog!=null)
56. mLoadingDialog.dismiss();
57. }
59. publicList<String>getItems()
60. {
61. returnitems;
62. }
64. privateList<String>loadingData()
65. {
66. try
67. {
68. Thread.sleep(5000);
69. }catch(InterruptedExceptione)
70. {
71. }
72. returnnewArrayList<String>(Arrays.asList("通过Fragment保存大量数据",
73. "onSaveInstanceState保存数据",
74. "getLastNonConfigurationInstance已经被弃用","RabbitMQ","Hadoop",
75. "Spark"));
76. }
78. /**
79. *设置Activity，因为Activity会一直变化
80. *
81. *@paramactivity
82. */
83. publicvoidsetActivity(FixProblemsActivityactivity)
84. {
85. //如果上一个Activity销毁，将与上一个Activity绑定的DialogFragment销毁
86. if(activity==null)
87. {
88. mLoadingDialog.dismiss();
89. }
90. //设置为当前的Activity
91. this.activity=activity;
92. //开启一个与当前Activity绑定的等待框
93. if(activity!=null&&!isCompleted)
94. {
95. mLoadingDialog=newLoadingDialog();
96. mLoadingDialog.show(activity.getFragmentManager(),"LOADING");
97. }
98. //如果完成，通知Activity
99. if(isCompleted)
100. {
101. notifyActivityTaskCompleted();
102. }
103. }
105. privatevoidnotifyActivityTaskCompleted()
106. {
107. if(null!=activity)
108. {
109. activity.onTaskCompleted();
110. }
111. }
113. }

异步任务中，管理一个对话框，当开始下载前，进度框显示，下载结束进度框消失，并为Activity提供回调。当然了，运行过程中Activity不断的重启，我们也提供了setActivity方法，onDestory时，会setActivity（null）防止内存泄漏，同时我们也会关闭与其绑定的加载框；当onCreate传入新的Activity时，我们会在再次打开一个加载框，当然了因为屏幕的旋转并不影响加载的数据，所有后台的数据一直继续在加载。是不是很完美~~

主Activity:

[java] view plain copy

1. packagecom.example.zhy_handle_runtime_change;
3. importjava.util.List;
5. importandroid.app.FragmentManager;
6. importandroid.app.ListActivity;
7. importandroid.os.Bundle;
8. importandroid.util.Log;
9. importandroid.widget.ArrayAdapter;
10. importandroid.widget.ListAdapter;
12. publicclassFixProblemsActivityextendsListActivity
13. {
14. privatestaticfinalStringTAG="MainActivity";
15. privateListAdaptermAdapter;
16. privateList<String>mDatas;
17. privateOtherRetainedFragmentdataFragment;
18. privateMyAsyncTaskmMyTask;
20. @Override
21. publicvoidonCreate(BundlesavedInstanceState)
22. {
23. super.onCreate(savedInstanceState);
24. Log.e(TAG,"onCreate");
26. //findtheretainedfragmentonactivityrestarts
27. FragmentManagerfm=getFragmentManager();
28. dataFragment=(OtherRetainedFragment)fm.findFragmentByTag("data");
30. //createthefragmentanddatathefirsttime
31. if(dataFragment==null)
32. {
33. //addthefragment
34. dataFragment=newOtherRetainedFragment();
35. fm.beginTransaction().add(dataFragment,"data").commit();
36. }
37. mMyTask=dataFragment.getData();
38. if(mMyTask!=null)
39. {
40. mMyTask.setActivity(this);
41. }else
42. {
43. mMyTask=newMyAsyncTask(this);
44. dataFragment.setData(mMyTask);
45. mMyTask.execute();
46. }
47. //thedataisavailableindataFragment.getData()
48. }
51. @Override
52. protectedvoidonRestoreInstanceState(Bundlestate)
53. {
54. super.onRestoreInstanceState(state);
55. Log.e(TAG,"onRestoreInstanceState");
56. }
59. @Override
60. protectedvoidonSaveInstanceState(BundleoutState)
61. {
62. mMyTask.setActivity(null);
63. super.onSaveInstanceState(outState);
64. Log.e(TAG,"onSaveInstanceState");
65. }
67. @Override
68. protectedvoidonDestroy()
69. {
70. Log.e(TAG,"onDestroy");
71. super.onDestroy();
73. }
74. /**
75. *回调
76. */
77. publicvoidonTaskCompleted()
78. {
79. mDatas=mMyTask.getItems();
80. mAdapter=newArrayAdapter<String>(FixProblemsActivity.this,
81. android.R.layout.simple_list_item_1,mDatas);
82. setListAdapter(mAdapter);
83. }
85. }

在onCreate中，如果没有开启任务（第一次进入），开启任务；如果已经开启了，调用setActivity（this）;

在onSaveInstanceState把当前任务加入Fragment

我设置了等待5秒，足够旋转三四个来回了~~~~可以看到虽然在不断的重启，但是丝毫不影响加载数据任务的运行和加载框的显示~~~~

效果图：

可以看到我在加载的时候就三心病狂的旋转屏幕~~但是丝毫不影响显示效果与任务的加载~~

最后，说明一下，其实不仅是屏幕旋转需要保存数据，当用户在使用你的app时，忽然接到一个来电，长时间没有回到你的app界面也会造成Activity的销毁与重建，所以一个行为良好的App，是有必要拥有恢复数据的能力的~~。

查阅资料时的一些参考文档：

http://developer.android.com/guide/topics/resources/runtime-changes.html

http://blog.doityourselfandroid.com/2010/11/14/handling-progress-dialogs-and-screen-orientation-changes/

转载自：http://blog.csdn.net/lmj623565791/article/details/37936275

更多相关文章

1. mybatisplus的坑 insert标签insert into select无参数问题的解决
2. python起点网月票榜字体反爬案例
3. android中使用sqlite、复制assets下的数据库到SD卡、支持大于1M
4. Android青翼蝠王之ContentProvider
5. Android(安卓)异步加载解决方案
6. 关于Android连接远程数据库（mysql、oracle）
7. Android(安卓)Contact分析（一）：Data, RawContact, Contact之间的关
8. Android(安卓)camera 默认显示黑白的问题
9. 在Android中查看和管理sqlite数据库

随机推荐

1. Android(安卓)进度条功能实现
2. Android(安卓)DNS之DNS参数设置
3. android 绘图
4. android 模拟器手机如何添加文件到sd卡
5. Android(安卓)Handler 异步消息处理机制
6. Android(安卓)使用SVG
7. android SDK包引用了java SDK哪些包
8. android UI进阶之弹窗的使用
9. Android(安卓)中需要掌握的高级技巧
10. Android百度地图——定位SDK（版本v3.1）（二）