android 系统开发资料汇总
2017-03-15 22:16
330 查看
http://bbs.csdn.net/forums/Android CSDN 安卓论坛
http://www.3g-edu.org/courses/content.htm 安卓学习路线
http://xm.tedu.cn/baidu/android/?XMJAVAqzs+xmjava20160302215243565&utm_term=android%E5%BC%80%E5%8F%91%E5%9F%B9%E8%AE%AD&ca_kid=49014333759&ca_cv=12198638955
http://blog.csdn.net/freemindhack/article/details/27109477
http://blog.csdn.net/freemindhack/article/details/27404417 安卓学习步骤
http://blog.csdn.net/happiness365/article/details/50451350 安卓大牛博客
http://www.cnblogs.com/zoupeiyang/p/4034517.html 安卓开发环境搭建
http://jobs.zhaopin.com/357186919250355.htm 安卓工作
http://jingyan.baidu.com/article/cb5d6105f1c1a9005c2fe084.html
安装2.2.2
http://blog.csdn.net/u011303443/article/details/51524439 http://blog.csdn.net/b2259909/article/details/50786597
http://blog.csdn.net/eebbhhn/article/details/52776648 http://www.tuicool.com/articles/AVjAva
安装注意事项
http://www.cnblogs.com/Kennytian/p/4449878.html 解决
Android Studio 乱码问题
http://blog.csdn.net/u010302764/article/details/42889731 http://jingyan.baidu.com/article/91f5db1b34d1871c7f05e3df.html
http://www.cnblogs.com/dongdong230/p/4184097.html studio创建项目
http://blog.csdn.net/eyu8874521/article/details/9125987
android webservice http://kb.cnblogs.com/page/98804/
http://blog.csdn.net/rankun1/article/details/52556162
http://blog.csdn.net/zml_2015/article/details/50626260/
http://blog.sina.com.cn/s/blog_b0f182290102v9ck.html http://www.cnblogs.com/hubcarl/p/4030884.html
===========================================
自己学习的知识总结：
创建 HelloWorld项目：
Application name : HelloWorld ,如果安装到手机上，在手机上显示此名称
域名：example.com
package name : 根据这个包名 区分不同的应用程序。
project location：项目代码存放的路径
创建空活动：Empty Activity 名字叫做 HelloWorldActivity
Layout Name:表示布局的名字：hello_world_layout
启动模拟器运行程序：create virtual device
app就是当前的主项目
分析你的上面第一个Android程序：
基于 Android模式的项目结构： 注意：可以切换到project模式结构
app:项目中的代码、资源等都放在这个目录下面，
build：不需要关心，
gradle:
.gitignore: 版本控制
其他内容略。
关注app目录：
libs:存放你用到的第三方jar包。
AndroidTest:编写test测试用例的，可以对项目进行自动化测试。
Java：存放Java代码的目录。
res: 该目录是存放 图片 布局 字符串等资源的。
AndroidManifest.xml:是整个Android项目的配置文件，程序中的4大组件都需要在这个文件里注册，
test： 用来编写测试用例的。
其他文件略.
分析HelloWorld项目是如何运行起来的：
首先打开：AndroidManifest.xml ，
<activity android:name=".HelloWorldActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
这段代码表示：对HelloWorldActivity活动进行注册，才可使用，intent-filter里面的2行代码
表示HelloWorldActivity活动是项目的主活动。在手机中点击应用图标，首先启动的就是这个活动。
活动是Android应用程序的门面，你在应用中看到的东东，都是放在活动中的。
查看HelloWorldActivity活动的代码：
public class HelloWorldActivity extends AppCompatActivity {
protected void onCreate( Bundle savedInstanceState ) {
super.onCreate( savedInstanceState ) ;
setContentView( R.layout.hello_world_layout ) ;
}
}
onCreate()方法是一个活动创建后必定要执行的方法。
Android程序讲究 逻辑和视图的分离。不在活动中编写界面，而是在布局文件中编写界面，然后再活动中引入进来（引入布局，需要调用setContentView（）方法， ）。布局文件都在res/layout 目录下，我们打开刚创建的布局文件 hello_world_layout.xml，看其中的代码：
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="hello world ! "
/>
</RelativeLayout>
TextView是文本控件，android:text="hello world ! " 是显示文字的。
res资源目录：
drawable开头的文件夹是用来存放图片的，
mipmap是用来存放应用图标的，
values开头的目录是用来存放 字符串、样式、颜色的，
layout目录是用来存放 布局文件 的。
定义了资源，接下来就可以使用资源了，打开res/values/strings.xml文件，内容如下：
<resources>
<string name="app_name"> HelloWorld </string>
</resources>
以上代码定义了一个应用程序名称的字符串，我们可以利用以下2种方式引用它：
在代码中引用：R.string.hello_world
在xml中引用：@/string/hello_world
( string 是可以被替换的)
例如：
打开：AndroidManifest.xml ，
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher" //指定了应用程序的图标
android:label="@string/app_name"
>
</application>
build.gradle 文件：
掌握日志工具使用：Log
它提供了5种级别的打印日志：Log.v() Log.d()
public class HelloWorldActivity extends AppCompatActivity {
protected void onCreate( Bundle savedInstanceState ) {
super.onCreate( savedInstanceState ) ;
setContentView( R.layout.hello_world_layout ) ;
Log.d( "HelloWorldActivity" , "onCreate execute " ) ;
}
}
--------------------------------------------------------------------------
探究 活动：
活动Activity是一种可以包含用户界面的组件，主要 用于和用户进行交互。
（一个活动最好对应一个布局）
活动的基本用法：
新建一个Activity项目，例如：ActivityTest ,选择 Add no Activity ,(手动创建活动)
在 app/src/main/java/默认域名/ 为空了，右击新建空活动，名称FirstActivity,并且不要
勾选 generate layout file 和 launcher Activity（变成主活动了） 这2项，勾选backwards
compatibility启用向下兼容，点击finish。
右击 app/src/main/res 新建目录 layout，右击新建布局文件 first_layout ，其他默认。
<LinearLayout>
......................
...........................
//进入布局元素，添加按钮 和属性，
<Button
android:id ="@+id/button_1" //定义算术的标识符，+去掉表示引用
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Button 1 "
</LinearLayout>
可以浏览布局了。R文件自动生成资源的id。
在FirstActivity活动中引入布局：
public class FirstActivity extends AppCompatActivity {
protected void onCreate( Bundle savedInstanceState ) {
super.onCreate( savedInstanceState ) ;
setContentView( R.layout.first_layout ) ; //加载了新的布局
}
}
所有的活动在 AndroidManifest.xml 中注册才能生效，做法：
在 <application>标签内，添加 <activity>标签进行注册，代码是：
<activity Android：name=".FirstActivity"> </activity>
把这个活动变成主活动：
<activity android：name=".FirstActivity"
android：label="this is FirstActivity" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
在活动中 使用 Toast ，在程序中使用它将一些短小的信息通知给用户，而信息会在很短的时间
内消失，不占用屏幕。
利用按钮弹出一个 定义的Toast 的 触发点，
public class FirstActivity extends AppCompatActivity {
protected void onCreate( Bundle savedInstanceState ) {
super.onCreate( savedInstanceState ) ;
setContentView( R.layout.first_layout ) ; //加载了新的布局
Button button1 = ( Button ) findViewById( R.id.button_1 );
button1.setOnClickListener( new View.OnClickListener( ) {
public void onClick( View v ){
Toast.makeText( FirstActivity.this , "you click Button 1",
Toast.LENGTH_SHORT).show();
}
} ) ;
}
在活动中使用 Menu :
在 res 目录下新建 menu 文件夹，在在其中建立一个 main的菜单文件（类型是 menu resource
file ），在main.xml中添加如下代码：
<menu xmlns:android:="" >
<item
android:id = "@+id/add_item"
android:title = "Add" />
<item
android:id = "@+id/remove_item"
android:title = "Remove" />
</>
public class FirstActivity extends AppCompatActivity {
protected void onCreate( Bundle savedInstanceState ) {
super.onCreate( savedInstanceState ) ;
setContentView( R.layout.first_layout ) ; //加载了新的布局
Button button1 = ( Button ) findViewById( R.id.button_1 );
button1.setOnClickListener( new View.OnClickListener( ) {
public void onClick( View v ){
Toast.makeText( FirstActivity.this , "you click Button 1",
Toast.LENGTH_SHORT).show();
}
} ) ;
// 重写方法：
public boolean onCreateOptionsMenu( Menu menu ) {
getMenuInflater().inflate( R.menu.main , menu );
return true; //显示菜单了
}
// 重写方法 添加菜单响应事件：
public boolean onOptionsItemSelected( MenuItem item ) {
switch ( item.getItemId( ) ) { //判断我们点击的是哪个菜单项
case R.id.add_item:
Toast.makeText( this, "you clicked Add"
,Toast.LENGTH_SHORT).show() ; break;
case R.id.remove_item:
Toast.makeText( this, "you clicked Remove"
,Toast.LENGTH_SHORT).show() ; break;
default:
}
return true; //菜单响应了
}
}
如何销毁一个活动：
修改按钮监听器中的代码：
button1.setOnClickListener( new View.OnClickListener( ) {
public void onClick( View v ){
finish（）；//等价于按下 back键，实现销毁活动。
}
} ) ;
使用 Intent 在活动之间 穿梭：
在 ActivityTest 项目中再创建一个活动：SecondActivity , 并勾选 generate layout file ， 布局文
件为 second_layout ， 但是不要勾选 launcher activity 选项，
开始编辑 second_layout.xml :
<LinearLayout>
......................
...........................
//进入布局元素，添加按钮 和属性，
<Button
android:id ="@+id/button_2" //定义算术的标识符，+去掉表示引用
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Button 2 "
</LinearLayout>
在SecondActivity活动中引入布局：
public class SecondActivity extends AppCompatActivity {
protected void onCreate( Bundle savedInstanceState ) {
super.onCreate( savedInstanceState ) ;
setContentView( R.layout.second_layout ) ; //加载了新的布局
}
}
所有的活动在 AndroidManifest.xml 中注册才能生效，做法：
在 <application>标签内，添加 <activity>标签进行注册，代码是：
<activity Android：name=".FirstActivity"> </activity>
把这个活动变成主活动：
<activity android：name=".FirstActivity"
android：label="this is FirstActivity" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android：name=".SecondActivity"></activity> //系统自动生成了
如何启动这个 第二个活动：由 Intent启动活动。
显示的Intent：
修改 FirstActivity 中按钮的点击事件：
button1.setOnClickListener( new View.OnClickListener( ) {
public void onClick( View v ){
Intent intent = new Intent(FirstActivity.this , SecondActivity.class )
//活动之间的跳转。
startActivity( intent );
}
} ) ;
隐式的Intent：由系统启动合适的活动。
在 AndroidManifest.xml 中修改代码：
<activity android：name=".FirstActivity"
android：label="this is FirstActivity" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android：name=".SecondActivity"> //系统自动生成了
<intent-filter>
<action android:name="com.example.activitytest.ACTION_START" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</activity>
在第一个活动中启动第二个活动：
修改 FirstActivity 中按钮的点击事件：
button1.setOnClickListener( new View.OnClickListener( ) {
public void onClick( View v ){
Intent intent = new Intent("com.example.activitytest.ACTION_START" )
//活动之间的跳转。
startActivity( intent );
}
} ) ;
每个Intent只能指定一个活动，但却可以指定多个category，默认只有一个，可以增加新的
。
修改 FirstActivity 中按钮的点击事件：
button1.setOnClickListener( new View.OnClickListener( ) {
public void onClick( View v ){
Intent intent = new Intent("com.example.activitytest.ACTION_START" )
intent.addCategory( "com.example.activitytest.MY_CATEGORY" );
startActivity( intent );
}
} ) ;
一旦你运行程序，程序就崩溃了，分析错误日志。
此时在第二个活动中继续添加代码：
<activity android：name=".SecondActivity"> //系统自动生成了
<intent-filter>
<action android:name="com.example.activitytest.ACTION_START" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="com.example.activitytest.MY_CATEGORY" />
</intent-filter>
</activity>
OK,程序可以正常运行了。
更多的 隐式的Intent 用法。暂时略去。
向下一个活动传递数据：
例如：第一个活动中有字符串 给第二个活动：
修改 FirstActivity 中按钮的点击事件：
button1.setOnClickListener( new View.OnClickListener( ) {
public void onClick( View v ){
String data = "Hello SecondActivity.";
Intent intent = new Intent("FirstActivity.this , SecondActivity.class" )
intent.putExtra( "extra_data" , data ); //准备好要传送的data
startActivity( intent );
}
} ) ;
第二个活动取出数据：
public class SecondActivity extends AppCompatActivity {
protected void onCreate( Bundle savedInstanceState ) {
super.onCreate( savedInstanceState ) ;
setContentView( R.layout.second_layout ) ; //加载了新的布局
Intent intent = getIntent();
String data = intent.getStringExtra("extra_data");
Log.d("SecondActivity", data );
}
}
返回数据给上一个活动：
当我们希望销毁活动 返回一个结果给上一个活动，可以调用startActivityForResult()
修改 FirstActivity 中按钮的点击事件：
button1.setOnClickListener( new View.OnClickListener( ) {
public void onClick( View v ){
Intent intent = new Intent("FirstActivity.this , SecondActivity.class" )
startActivityForResult( intent , 1 ); //也是启动第二个活动，逻辑值1
}
} ) ;
在第二个活动中添加按钮注册事件：
public class SecondActivity extends AppCompatActivity {
protected void onCreate( Bundle savedInstanceState ) {
super.onCreate( savedInstanceState ) ;
setContentView( R.layout.second_layout ) ; //加载了新的布局
Button button2 = ( Button ) findViewById( R.id.button_2 );
button2.setOnClickListener( new View.OnClickListener( ) {
public void onClick( View v ){
Intent intent = new Intent();
intent.putExtra( "data_return" , "hello FirstActivity" );
setResult( RESULT_OK, intent ); //向上一个活动返回数据
finish();
}
} ) ;
}
}
此时，系统会回调第一个活动的 方法，下面进行重写：
修改 FirstActivity
protected void onActivityResult( int requestCode , int resultCode , Intent data ){
switch( requestCode ){
case 1：
if(resultCode == RESULT_OK )
{ String returnedData = data.getStringExtra("data_return");
Log.d("FirstActivity", returnedData);
}
break;
default:
}
}
在SecondActivity中不通过单击按钮，而是通过按下back键回到FirstActivity ，处理的方式是
：
在SecondActivity中重写方法：
public void onBackPressed(){
Intent intent = new Intent();
intent.putExtra( "data_return" , "hello FirstActivity" );
setResult( RESULT_OK, intent ); //向上一个活动返回数据
finish();
}
活动的生命周期：
活动的结构：就是栈——返回栈（组成了任务来管理活动的）
活动状态：
运行状态: 位于栈顶的活动，
暂停状态：不在栈顶的活动，依然可见，完全存活着。
停止状态：不在栈顶，且完全不可见的 活动。
销毁状态：一个活动从返回栈中移除后，系统回收这种状态，保证手机的内存充足。
活动的生存期：定义了7个方法覆盖了活动的生命周期。
onCreate():活动被第一次创建的时候调用。
onStart()：活动从不可见到可见时被调用。
onResume():活动位于栈顶，运行状态，在活动准备好和用户交互的时候被调用。
onPause(): 系统准备去启动 或者 回复另一个活动的时候被调用。
onStop(): 在活动完全不可见的时候被调用。
onDestroy(): 在活动被销毁之前调用。
onRestart()：活动被重新启动。
开始体验 活动的生命周期：
新建项目：ActivityLifeCycleTest ， 允许自动创建和布局，勾选launcher activity 设置为主活
动，再创建2个子活动：NormalActivity normal_layout , DialogActivity dialog_layout。
第66页。
开始编辑 normal_layout.xml文件：
<LinearLayout>
......................
...........................
//进入布局元素，添加按钮 和属性，
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="this is a normal activity " />
</LinearLayout>
开始编辑 dialog_layout.xml文件：
<LinearLayout>
......................
...........................
//进入布局元素，添加按钮 和属性，
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="this is a dialog activity " />
</LinearLayout>
在 AndroidManifest.xml 中修改代码<activity>：
<activity android：name=".NormalActivity" >
</activity>
<activity android:name=". DialogActivity"
android：theme = "@android:style/Theme.Dialog" > //给当前活动指定主题
</activity>
接下来 修改 activity_main.xml ，重新定制主活动的布局，代码如下：
<LinearLayout>
......................
...........................
//进入布局元素，添加按钮 和属性，
<Button
android:id ="@+id/start_normal_activity" //定义算术的标识符，+去掉表示引用
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Start NormalActivity " />
<Button
android:id ="@+id/start_dialog_activity" //定义算术的标识符，+去掉表示引用
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Start DialogActivity " />
</LinearLayout>
接着修改 MainActivity 中的代码：
public class MainActivity extends AppCompatActivity {
ｐｕｂｌｉｃ static final String TAG = "MainActivity";
protected void onCreate( Bundle savedInstanceState ) {
super.onCreate( savedInstanceState ) ;
setContentView( R.layout.activity_main ) ; //加载了新的布局
Button startNormalActivity = ( Button ) findViewById( R.id.start_normal_activity );
Button startDialogActivity = ( Button ) findViewById( R.id.start_dialog_activity );
startNormalActivity.setOnClickListener( new View.OnClickListener( ) {
public void onClick( View v ){
Intent intent = new Intent(MainActivity.this , NormalActivity.class )
startActivity( intent ); //
}
} ) ;
startDialogActivity.setOnClickListener( new View.OnClickListener( ) {
public void onClick( View v ){
Intent intent = new Intent(MainActivity.this , DialogActivity.class )
startActivity( intent ); //
}
} ) ;
protected void onStart() {
super.onStart();
Log.d( TAG , "onStart"); //显示菜单了
}
protected void onResume() {
super.onResume();
Log.d( TAG , "onResume"); //显示菜单了
}
protected void onPause() {
super.onPause();
Log.d( TAG , "onPause"); //显示菜单了
}
protected void onStop() {
super.onStop();
Log.d( TAG , "onStop"); //显示菜单了
}
protected void onDestroy() {
super.onDestroy();
Log.d( TAG , "onDestroy"); //显示菜单了
}
protected void onRestart() {
super.onRestart();
Log.d( TAG , "onRestart"); //显示菜单了
}
}
-------------------------------------------------------复制到此；
活动被回收了怎么办？72
假设 MainActivity 中有文本框里面有信息数据，此时启动了 NormalActivity ，MainActivity活
动进入停止状态，很可能被收回了，当你再次返回到 MainActivity 活动，MainActivity会被再
次创建， 而 之前的临时数据没有了。解决的办法是：
MainActivity修改以下代码：
protected void onSaveInstanceState （Bundle outState）{
// 活动被收回前 ，该方法被调用，保存临时数据
super.onSaveInstanceState （ outState）;
String tempData = "something you just typed";
outState.putString("data_key", tempData );
}
MainActivity修改以下代码：
protected void onCreate( Bundle savedInstanceState ) {
super.onCreate( savedInstanceState ) ;
Log.d( TAG , "onCreate");
setContentView( R.layout.activity_main ) ; //加载了新的布局
if( savedInstanceState != null )
{
String tempData = savedInstanceState.getString("data_key");
Log.d( TAG , tempData ); //可以重新赋值，恢复数据
}
活动的启动模式： 73
共四种：standard(默认的)：启动活动就入栈，可以重复启动，重复入栈。back返回N此。
singleTop ：如果当前活动已经在栈顶了，就不再创建该活动的新实例了。可以直接使用
singleTask
singleInstance
可以在 AndroidManifest.xml 中 通过 <activity>标签指定 android:launchMode 启动模式。
在 ActivityTest项目中修改代码：修改 FirstActivity 中
protected void onCreate( Bundle savedInstanceState ) {
super.onCreate( savedInstanceState ) ;
Log.d( "FirstActivity" , this.toString() );
setContentView( R.layout.first_layout ) ; //加载了新的布局
Button button1 = ( Button ) findViewById( R.id.button_1 );
button1.setOnClickListener( new View.OnClickListener( ) {
public void onClick( View v ){
Intent intent = new Intent(FirstActivity.this , FirstActivity.class );
startActivity( intent );
}
} ) ;
其他模式知识略写了。
知晓当前是在哪个活动：
在 ActivityTest项目中修改代码：右击com.example.activitytest , 建立 BaseActivity类，(此类没
有注册哦) ，和普通的活动一样：代码如下：
public class BaseActivity extends AppCompatActivity {
protected void onCreate( Bundle savedInstanceState ) {
super.onCreate( savedInstanceState ) ;
Log.d( "BaseActivity" , getClass().getSimpleName() );
}
}
把 BaseActivity 变成父类，让 FirstActivity 等活动都继承 BaseActivity ，分别执行活动。
随时随地退出程序：设计集合类对所有活动进行管理。
代码： public class ActivityCollector {
public static List<Activity> activities = new ArrayList<>();
public static void addActivity( Activity activity ) {
activities.add(activity);
}
public static void removeActivity( Activity activity ) {
activities.remove(activity);
}
public static void finishAll( ) { //销毁所有的活动
for( Activity activity : activities )
{ if( !activity.isFinishing() )
activity.finish() ;
}
}
}
继续修改 BaseActivity 的代码：
public class BaseActivity extends AppCompatActivity {
protected void onCreate( Bundle savedInstanceState ) {
super.onCreate( savedInstanceState ) ;
Log.d( "BaseActivity" , getClass().getSimpleName() );
ActivityCollector.addActivity( this );
}
protected void onDestory( ) {
super.onDestory( );
ActivityCollector.removeActivity( this );
}
}
修改 ThirdActivity 的代码：
public class ThirdActivity extends BaseActivity {
protected void onCreate( Bundle savedInstanceState ) {
super.onCreate( savedInstanceState ) ;
Log.d( "ThirdActivity" , "task id is " + getTaskId() );
setContentView( R.layout.third_layout ) ; //加载了新的布局
Button button3 = ( Button ) findViewById( R.id.button_3 );
button3.setOnClickListener( new View.OnClickListener( ) {
public void onClick( View v ){
ActivityCollector.finishAll( );//程序的任何地方执行此方法退出程序
}
} ) ;
}
下面这种写法很牛逼。
启动活动的最佳写法：当前活动向 另一个活动 传递 参数 并启动 ，改进写法：
public class SecondActivity extends BaseActivity {
public static void actionStart( Context context , String data1 , String data2 ){
Intent intent = new Intent( context , SecondActivity.class );
intent.putExtra( "param1" , data1 );
intent.putExtra( "param2" , data2 );
context.startActivity( intent );
}
}
启动 SecondActivity ：
button1.setOnClickListener( new View.OnClickListener( ) {
public void onClick( View v ){
SecondActivity.actionStart( FirstActivity.this , "data1","data2");
}
} ) ;
-------------------------------------------------------复制到此；
第五章：
广播机制：
Android每个应用程序都可以对自己感兴趣的广播进行注册，这样该程序就只会接收到自己关心
的广播内容（可以来自于系统或者 其他程序）
广播接收器： Broadcast Receiver
广播的类型：
标准广播： 在标准广播发出之后，所有的广播接收器几乎都会在同一时刻接收到这条广播消息
。
有序广播：同步执行的广播，同一时刻，只有一个广播接收器接收广播。
应用程序通过监听这些广播来得到系统的状态信息。使用 广播接收器： Broadcast Receiver
注册后可以接受广播： 动态注册（在代码中） 和 静态注册（AndroidManifest.xml ）
创建一个 ：广播接收器 ，以动态注册的方式 监听网络变化的实现代码：
新建项目BroadcastTest，然后修改MainActivity中的代码：
public class MainActivity extends AppCompatActivity {
private IntentFilter intentFilter ;
private NetworkChangeReceiver networkChangeReceiver;
protected void onCreate( Bundle savedInstanceState ) {
super.onCreate( savedInstanceState ) ;
setContentView( R.layout.activity_main ) ; //加载了新的布局
intentFilter = new IntentFilter();
intentFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE");//监听哪种类型的广播
networkChangeReceiver = new NetworkChangeReceiver();
registerReceiver( networkChangeReceiver, intentFilter); //注册监听广播
}
protected void onDestroy(){
super.onDestroy();
unregisterReceiver( networkChangeReceiver );//必须取消注册哦
}
class NetworkChangeReceiver extends BroadcastReceiver {
public void onReceiver( Context context ,Intent intent ){// 网络变化就会执行本方法
Toast.makeText(context , "network changes", Toast.LENGTH_SHORT).show() ;
}
}
注意: 敏感操作声明权限：
在 AndroidManifest.xml 中 ，添加代码：
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
动态注册的话，需要程序驱动后才能接收到广播。
静态注册的话，程序未启动也可以接受广播。在 AndroidManifest.xml 中 系统自动添加注册代码
利用工具创建广播接收器 ： 右击com.example.broadcasttest , new一个 Broadcast Receiver
：名称为 BootCompleteReceiver ，都勾选属性，修改代码：
class BootCompleteReceiver extends BroadcastReceiver {
public void onReceiver( Context context ,Intent intent ){// 网络变化就会执行本方法
Toast.makeText(context , "Boot Complete", Toast.LENGTH_LONG).show() ;
}
}
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
发送自定义广播：
标准广播： 在标准广播发出之后，所有的广播接收器几乎都会在同一时刻接收到这条广播消息
。
有序广播：同步执行的广播，同一时刻，只有一个广播接收器接收广播。
class MyBroadcastReceiver extends BroadcastReceiver {
public void onReceiver( Context context ,Intent intent ){// 网络变化就会执行本
Toast.makeText(context , "received in MyBroadcastReceiver", Toast.LENGTH_SHORT).show() ;
}
}
在 AndroidManifest.xml 中修改广播器代码：
<receiver
android:name=".MyBroadcastReceiver"
android:enable = "true"
android:exported = "true" >
<intent-filter>
<action android:name="com.example.broadcasttest.MY_BROADCAST"/>
</intent-filter>
</receiver>
添加一个按钮测试：
public void onClick( View v ){
Intent intent = new Intent("com.example.broadcasttest.MY_BROADCAST");
sendBroadcast( intent );
}
使用本地广播 更安全：广播只会在程序的内部进行传递。广播接收器也只会接收来自本应用程
序发出来的广播。
public class MainActivity extends AppCompatActivity {
private IntentFilter intentFilter ;
private LocalReceiver localReceiver;
private LocalBroadcastManager localBroadcastManager;
// private NetworkChangeReceiver networkChangeReceiver;
protected void onCreate( Bundle savedInstanceState ) {
super.onCreate( savedInstanceState ) ;
setContentView( R.layout.activity_main ) ; //加载了新的布局
localBroadcastManager = LocalBroadcastManager.getInstance( this );
Button button = ( Button ) findViewById( R.id.button );
button.setOnClickListener( new View.OnClickListener( ) {
public void onClick( View v ){
Intent intent = new Intent("com.example.broadcasttest.LOCAL_BROADCAST");
localBroadcastManager.sendBroadcast( intent ); //发送本地广播
}
} ) ;
intentFilter = new IntentFilter();
intentFilter.addAction("com.example.broadcasttest.LOCAL_BROADCAST");//监听哪种类型的广播
localReceiver = new LocalReceiver();
localBroadcastManager.registerReceiver( localReceiver , intentFilter); //注册监听广播
}
protected void onDestroy(){
super.onDestroy();
localBroadcastManager.unregisterReceiver( localReceiver );//必须取消注册哦
}
class LocalReceiver extends BroadcastReceiver {
public void onReceiver( Context context ,Intent intent ){// 变化就会执行本方法
Toast.makeText(context , "receivde local broadcast", Toast.LENGTH_SHORT).show() ;
}
}
-------------------------------------------------------复制到此；
第10章 ： 服务
更新应用程序中的UI，必须在主线程中执行，在子线程中执行会出错。
验证案例：新建 AndroidThreadTest 项目，修改 activity_main.xml文档：
<TextView
android:id="@+id/text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerInParent="true"
android:text="hello world ! "
android:textSize="20sp" />
<Button
android:id ="@+id/change_text" //定义算术的标识符，+去掉表示引用
android:layout_width="wrap_parent"
android:layout_height="wrap_content"
android:text="Change Text"
/>
接着修改 MainActivity 中的代码：
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
private TextView text;
protected void onCreate( Bundle savedInstanceState ) {
super.onCreate( savedInstanceState ) ;
setContentView( R.layout.activity_main ) ; //加载了新的布局
text = ( TextView ) findViewById( R.id.text );
Button change_text = ( Button ) findViewById( R.id.change_text );
change_text .setOnClickListener( new View.OnClickListener( ) {
}
public void onClick( View v ){
switch( v.getId()) {
case R.id.change_text:
new Thread( new Runnable()
{ public void run(){ text.setText("Nice to meet you"); }
}
}).start(); break;
default: break;
}
}
}
上述程序崩溃了。
如果 我们要创建子线程，子线程执行完任务后把结果 更新UI控件，该如何实现呢？
可以 引入 异步消息处理机制。
接着修改 MainActivity 中的代码：
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
public static final int UPDATE_TEXT =1 ;
private TextView text;
private Handler handler = new Handler() {
public void handleMessage( Message msg ) {
switch( msg.what ) {
case UPDATE_TEXT : text.setText("Nice to meet you"); break;
default: break;
}
}
};
public void onClick( View v ){
switch( v.getId()) {
case R.id.change_text:
new Thread( new Runnable()
{ public void run(){
Message message = new Message();
message.what = UPDATE_TEXT;
handler.sendMessage(message);
}
}
}).start(); break;
default: break;
}
}
}
开始解释：
Message :用于在不同线程之间交换少量的信息数据（叫做消息），
Handler : 主要用于发送（sendMessage() ）和处理消息(handleMessage() )的。
MessageQueue : 是消息队列，用于存放来自于 Handler发送来的消息。
每个线程中只有一个这个对象。
Looper: 是每个线程中的MessageQueue的管家，调用Looper的loop（）后，就会进入到无线的循
环当中，去取出MessageQueue 中的消息。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- Android开发，系统通讯录功能开发扩展资料汇总
- android 系统开发资料汇总 2 高性能web服务 tomcat 集群 apache
- Android系统概述——底层开发的资料
- Android界面效果UI开发资料汇总
- 【绝对给力】Android开发免豆资料（教程+工具+源码）地址汇总
- android开发资料汇总
- 【绝对给力】Android开发免豆资料（教程+工具+源码）地址汇总 ...
- Android系统概述——底层开发的资料
- android 开发资料汇总
- 【绝对给力】Android开发免豆资料（教程+工具+源码）地址汇总
- Android系统开发常用shell命令汇总+vim中复制操作+adb logcat过滤
- Android开发必备资料之50例源码汇总
- Android开发免积分资料（教程+工具+源码）下载汇总
- 【绝对给力】Android开发免豆资料（教程+工具+源码）地址汇总 ...
- Android系统概述——底层开发的资料
- 【绝对给力】Android开发免豆资料（教程+工具+源码）下载地址汇总
- 【绝对给力】Android开发免豆资料（教程+工具+源码）地址汇总 ...
- Android界面效果UI开发资料汇总(附资料包)
- 【绝对给力】Android开发免豆资料（教程+工具+源码）下载地址汇总
- 【绝对给力】Android开发免豆资料（教程+工具+源码）地址汇总 ...