android 系统开发资料汇总

来源：互联网发布：lacoste淘宝是正品吗编辑：程序博客网时间：2024/05/17 18:11

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中添加如下代码：

public class FirstActivity extends AppCompatActivity {

                  // 重写方法：
                     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 ) ; //加载了新的布局

}

}

如何启动这个第二个活动：由 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文件：

在 AndroidManifest.xml 中修改代码<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 " />

接着修改 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文档：

接着修改 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 中的消息。

0 0