程序博客网 > 网络机房整改方案

安卓面试题（1-4）

来源：互联网 发布：网络机房整改方案 编辑：程序博客网 时间：2024/06/05 20:06

  1. 注册广播有哪几种方式,有什么区别

BroadcastReceiver用于监听被广播的事件

必须被注册，有两种方法：

1、在应用程序的代码中注册

注册BroadcastReceiver：

registerReceiver（receiver，filter）；

取消注册BroadcastReceiver：

unregisterReceiver（receiver）；

当BroadcastReceiver更新UI，通常会使用这样的方法注册。启动Activity时候注册BroadcastReceiver，Activity不可见时候，取消注册。

2、在androidmanifest.xml当中注册

<receiver>

    <intent-filter>

     <action android:name = "android.intent.action.PICK"/>

    </intent-filter>

</receiver>

 

1)第一种不是常驻型广播，也就是说广播跟随程序的生命周期。

2)第二种是常驻型，也就是说当应用程序关闭后，如果有信息广播来，程序也会被系统调用自动运行。

 

使用这样的方法注册弊端：它会始终处于活动状态，毕竟是手机开发，cpu和电源资源比较少，一直处于活动耗费大，不利。

 

 

动态注册一个SD卡事件监听:

 

复制代码
  SdcardStateChanageReceiver sdcardStateReceiver;   @Override  protected void onCreate(Bundle savedInstanceState)   {    super.onCreate(savedInstanceState);    IntentFilter filter = new IntentFilter();    filter.addAction(Intent.ACTION_MEDIA_REMOVED);    filter.addAction(Intent.ACTION_MEDIA_EJECT);    filter.addAction(Intent.ACTION_MEDIA_MOUNTED);    filter.addDataScheme("file");    sdcardStateReceiver = new SdcardStateChanageReceiver();     registerReceiver(sdcardStateReceiver,filter);   }   @Override  protected void onDestroy(){    unregisterReceiver(sdcardStateReceiver);   }   class SdcardStateChanageReceiver  extends BroadcastReceiver{      @Override   public void onReceive(Context context, Intent intent)    {     String state=android.os.Environment.getExternalStorageState();     System.out.println("SDCard 发生改变! 状态："+state);     //checkSDCard();    }    public void checkSDCard(){     String state=android.os.Environment.getExternalStorageState();     System.out.println(state);     if(state.equals(android.os.Environment.MEDIA_REMOVED ) || state .equals(android.os.Environment.MEDIA_UNMOUNTED)){      System.out.println("SDCard 已卸载!");     }    }   }   
  1. 绘制 Activity 的生命流程图
我们来看一下这一张经典的生命周期流程图：
相信不少朋友也已经看过这个流程图了，也基本了解了Activity生命周期的几个过程，我们就来说一说这几个过程。
1.启动Activity：系统会先调用onCreate方法，然后调用onStart方法，最后调用onResume，Activity进入运行状态。
2.当前Activity被其他Activity覆盖其上或被锁屏：系统会调用onPause方法，暂停当前Activity的执行。
3.当前Activity由被覆盖状态回到前台或解锁屏：系统会调用onResume方法，再次进入运行状态。
4.当前Activity转到新的Activity界面或按Home键回到主屏，自身退居后台：系统会先调用onPause方法，然后调用onStop方法，进入停滞状态。
5.用户后退回到此Activity：系统会先调用onRestart方法，然后调用onStart方法，最后调用onResume方法，再次进入运行状态。
6.当前Activity处于被覆盖状态或者后台不可见状态，即第2步和第4步，系统内存不足，杀死当前Activity，而后用户退回当前Activity：再次调用onCreate方法、onStart方法、onResume方法，进入运行状态。
7.用户退出当前Activity：系统先调用onPause方法，然后调用onStop方法，最后调用onDestory方法，结束当前Activity。
但是知道这些还不够，我们必须亲自试验一下才能深刻体会，融会贯通。
下面我们就结合实例，来演示一下生命周期的几个过程的详细情况。我们新建一个名为lifecycle的项目，创建一个名为LifeCycleActivity的Activity，如下：
复制代码
public class LifeCycleActivity extends Activity {            private static final String TAG = "LifeCycleActivity";      private Context context = this;      private int param = 1;            //Activity创建时被调用      @Override      public void onCreate(Bundle savedInstanceState) {          super.onCreate(savedInstanceState);          Log.i(TAG, "onCreate called.");                    setContentView(R.layout.lifecycle);                    Button btn = (Button) findViewById(R.id.btn);          btn.setOnClickListener(new View.OnClickListener() {              @Override              public void onClick(View v) {                  Intent intent = new Intent(context, TargetActivity.class);                  startActivity(intent);              }          });      }            //Activity创建或者从后台重新回到前台时被调用      @Override      protected void onStart() {          super.onStart();          Log.i(TAG, "onStart called.");      }            //Activity从后台重新回到前台时被调用      @Override      protected void onRestart() {          super.onRestart();          Log.i(TAG, "onRestart called.");      }            //Activity创建或者从被覆盖、后台重新回到前台时被调用      @Override      protected void onResume() {          super.onResume();          Log.i(TAG, "onResume called.");      }            //Activity窗口获得或失去焦点时被调用,在onResume之后或onPause之后      /*@Override     public void onWindowFocusChanged(boolean hasFocus) {         super.onWindowFocusChanged(hasFocus);         Log.i(TAG, "onWindowFocusChanged called.");     }*/            //Activity被覆盖到下面或者锁屏时被调用      @Override      protected void onPause() {          super.onPause();          Log.i(TAG, "onPause called.");          //有可能在执行完onPause或onStop后,系统资源紧张将Activity杀死,所以有必要在此保存持久数据      }            //退出当前Activity或者跳转到新Activity时被调用      @Override      protected void onStop() {          super.onStop();          Log.i(TAG, "onStop called.");         }            //退出当前Activity时被调用,调用之后Activity就结束了      @Override      protected void onDestroy() {          super.onDestroy();          Log.i(TAG, "onDestory called.");      }            /**      * Activity被系统杀死时被调用.      * 例如:屏幕方向改变时,Activity被销毁再重建;当前Activity处于后台,系统资源紧张将其杀死.      * 另外,当跳转到其他Activity或者按Home键回到主屏时该方法也会被调用,系统是为了保存当前View组件的状态.      * 在onPause之前被调用.      */      @Override      protected void onSaveInstanceState(Bundle outState) {          outState.putInt("param", param);          Log.i(TAG, "onSaveInstanceState called. put param: " + param);          super.onSaveInstanceState(outState);      }            /**      * Activity被系统杀死后再重建时被调用.      * 例如:屏幕方向改变时,Activity被销毁再重建;当前Activity处于后台,系统资源紧张将其杀死,用户又启动该Activity.      * 这两种情况下onRestoreInstanceState都会被调用,在onStart之后.      */      @Override      protected void onRestoreInstanceState(Bundle savedInstanceState) {          param = savedInstanceState.getInt("param");          Log.i(TAG, "onRestoreInstanceState called. get param: " + param);          super.onRestoreInstanceState(savedInstanceState);      }  }  
复制代码
 
大家注意到，除了几个常见的方法外，我们还添加了onWindowFocusChanged、onSaveInstanceState、onRestoreInstanceState方法：
 
1.onWindowFocusChanged方法：在Activity窗口获得或失去焦点时被调用，例如创建时首次呈现在用户面前；当前Activity被其他Activity覆盖；当前Activity转到其他Activity或按Home键回到主屏，自身退居后台；用户退出当前Activity。以上几种情况都会调用onWindowFocusChanged，并且当Activity被创建时是在onResume之后被调用，当Activity被覆盖或者退居后台或者当前Activity退出时，它是在onPause之后被调用，如图所示：
这个方法在某种场合下还是很有用的，例如程序启动时想要获取视特定视图组件的尺寸大小，在onCreate中可能无法取到，因为窗口Window对象还没创建完成，这个时候我们就需要在onWindowFocusChanged里获取；如果大家已经看过我写的Android动画之Frame Animation这篇文章就会知道，当时试图在onCreate里加载frame动画失败的原因就是因为窗口Window对象没有初始化完成，所以最后我将加载动画的代码放到了onWindowFocusChanged中，问题迎刃而解。不过大家也许会有疑惑，为什么我在代码里将它注释掉了，因为对当前Activity每一个操作都有它的执行log，我担心这会影响到整个流程的清晰度，所以将它注掉，大家只要了解它应用的场合和执行的顺序就可以了。
2.onSaveInstanceState：(1)在Activity被覆盖或退居后台之后，系统资源不足将其杀死，此方法会被调用；(2)在用户改变屏幕方向时，此方法会被调用；(3)在当前Activity跳转到其他Activity或者按Home键回到主屏，自身退居后台时，此方法会被调用。第一种情况我们无法保证什么时候发生，系统根据资源紧张程度去调度；第二种是屏幕翻转方向时，系统先销毁当前的Activity，然后再重建一个新的，调用此方法时，我们可以保存一些临时数据；第三种情况系统调用此方法是为了保存当前窗口各个View组件的状态。onSaveInstanceState的调用顺序是在onPause之前。
3.onRestoreInstanceState：(1)在Activity被覆盖或退居后台之后，系统资源不足将其杀死，然后用户又回到了此Activity，此方法会被调用；(2)在用户改变屏幕方向时，重建的过程中，此方法会被调用。我们可以重写此方法，以便可以恢复一些临时数据。onRestoreInstanceState的调用顺序是在onStart之后。
以上着重介绍了三个相对陌生方法之后，下面我们就来操作一下这个Activity，看看它的生命周期到底是个什么样的过程：
1.启动Activity：
在系统调用了onCreate和onStart之后，调用了onResume，自此，Activity进入了运行状态。
2.跳转到其他Activity，或按下Home键回到主屏：
我们看到，此时onSaveInstanceState方法在onPause之前被调用了，并且注意，退居后台时，onPause后onStop相继被调用。
3.从后台回到前台：
当从后台会到前台时，系统先调用onRestart方法，然后调用onStart方法，最后调用onResume方法，Activity又进入了运行状态。
4.修改TargetActivity在AndroidManifest.xml中的配置，将android:theme属性设置为@android:style/Theme.Dialog，然后再点击LifeCycleActivity中的按钮，跳转行为就变为了TargetActivity覆盖到LifeCycleActivity之上了，此时调用的方法为：
注意还有一种情况就是，我们点击按钮，只是按下锁屏键，执行的效果也是如上。
我们注意到，此时LifeCycleActivity的OnPause方法被调用，并没有调用onStop方法，因为此时的LifeCycleActivity没有退居后台，只是被覆盖或被锁屏；onSaveInstanceState会在onPause之前被调用。
5.按回退键使LifeCycleActivity从被覆盖回到前面，或者按解锁键解锁屏幕：
此时只有onResume方法被调用，直接再次进入运行状态。
6.退出：
最后onDestory方法被调用，标志着LifeCycleActivity的终结。
大家似乎注意到，在所有的过程中，并没有onRestoreInstanceState的出现，这个并不奇怪，因为之前我们就说过，onRestoreInstanceState只有在杀死不在前台的Activity之后用户回到此Activity，或者用户改变屏幕方向的这两个重建过程中被调用。我们要演示第一种情况比较困难，我们可以结合第二种情况演示一下具体过程。顺便也向大家讲解一下屏幕方向改变的应对策略。
首先介绍一下关于Activity屏幕方向的相关知识。
我们可以为一个Activity指定一个特定的方向，指定之后即使转动屏幕方向，显示方向也不会跟着改变：
1.指定为竖屏：在AndroidManifest.xml中对指定的Activity设置android:screenOrientation="portrait"，或者在onCreate方法中指定：
 
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);  //竖屏  
  1. setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);  //竖屏  
2.指定为横屏：在AndroidManifest.xml中对指定的Activity设置android:screenOrientation="landscape"，或者在onCreate方法中指定：
  1. setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); //横屏  
 
 
为应用中的Activity设置特定的方向是经常用到的办法，可以为我们省去不少不必要的麻烦。不过，我们今天讲的是屏幕方向改变时的生命周期，所以我们并不采用固定屏幕方向这种办法。
 
下面我们就结合实例讲解一下屏幕转换的生命周期，我们新建一个Activity命名为OrientationActivity，如下：
 
复制代码
public class OrientationActivity extends Activity {            private static final String TAG = "OrientationActivity";      private int param = 1;            @Override      protected void onCreate(Bundle savedInstanceState) {          super.onCreate(savedInstanceState);          setContentView(R.layout.orientation_portrait);          Log.i(TAG, "onCreate called.");      }            @Override      protected void onStart() {          super.onStart();          Log.i(TAG, "onStart called.");      }            @Override      protected void onRestart() {          super.onRestart();          Log.i(TAG, "onRestart called.");      }            @Override      protected void onResume() {          super.onResume();          Log.i(TAG, "onResume called.");      }            @Override      protected void onPause() {          super.onPause();          Log.i(TAG, "onPause called.");      }            @Override      protected void onStop() {          super.onStop();          Log.i(TAG, "onStop called.");      }            @Override      protected void onDestroy() {          super.onDestroy();          Log.i(TAG, "onDestory called.");      }        @Override      protected void onSaveInstanceState(Bundle outState) {          outState.putInt("param", param);          Log.i(TAG, "onSaveInstanceState called. put param: " + param);          super.onSaveInstanceState(outState);      }            @Override      protected void onRestoreInstanceState(Bundle savedInstanceState) {          param = savedInstanceState.getInt("param");          Log.i(TAG, "onRestoreInstanceState called. get param: " + param);          super.onRestoreInstanceState(savedInstanceState);      }            //当指定了android:configChanges="orientation"后,方向改变时onConfigurationChanged被调用      @Override      public void onConfigurationChanged(Configuration newConfig) {          super.onConfigurationChanged(newConfig);          Log.i(TAG, "onConfigurationChanged called.");          switch (newConfig.orientation) {          case Configuration.ORIENTATION_PORTRAIT:              setContentView(R.layout.orientation_portrait);              break;          case Configuration.ORIENTATION_LANDSCAPE:              setContentView(R.layout.orientation_landscape);              break;          }      }  }  
复制代码
 
首先我们需要进入“Settings->Display”中，将“Auto-rotate Screen”一项选中，表明可以自动根据方向旋转屏幕，然后我们就可以测试流程了，当我们旋转屏幕时，我们发现系统会先将当前Activity销毁，然后重建一个新的：
 
系统先是调用onSaveInstanceState方法，我们保存了一个临时参数到Bundle对象里面，然后当Activity重建之后我们又成功的取出了这个参数。
为了避免这样销毁重建的过程，我们需要在AndroidMainfest.xml中对OrientationActivity对应的<activity>配置android:configChanges="orientation"，然后我们再测试一下，我试着做了四次的旋转，打印如下：
可以看到，每次旋转方向时，只有onConfigurationChanged方法被调用，没有了销毁重建的过程。
以下是需要注意的几点：
1.如果<activity>配置了android:screenOrientation属性，则会使android:configChanges="orientation"失效。
2.模拟器与真机差别很大：模拟器中如果不配置android:configChanges属性或配置值为orientation，切到横屏执行一次销毁->重建，切到竖屏执行两次。真机均为一次。模拟器中如果配置android:configChanges="orientation|keyboardHidden"（如果是Android4.0，则是"orientation|keyboardHidden|screenSize"），切竖屏执行一次onConfigurationChanged，切横屏执行两次。真机均为一次。
Activity的生命周期与程序的健壮性有着密不可分的关系，希望朋友们能够认真体会、熟练应用。
  1. 注册Service需要注意什么



Android中Service的使用详解和注意点（LocalService）

开始，先稍稍讲一点android中Service的概念和用途吧~
Service分为本地服务（LocalService）和远程服务（RemoteService）：
1、本地服务依附在主进程上而不是独立的进程，这样在一定程度上节约了资源，另外Local服务因为是在同一进程因此不需要IPC，也不需要AIDL。相应bindService会方便很多。主进程被Kill后，服务便会终止。
2、远程服务为独立的进程，对应进程名格式为所在包名加上你指定的android:process字符串。由于是独立的进程，因此在Activity所在进程被Kill的时候，该服务依然在运行，不受其他进程影响，有利于为多个进程提供服务具有较高的灵活性。该服务是独立的进程，会占用一定资源，并且使用AIDL进行IPC稍微麻烦一点。
按使用方式可以分为以下三种：
1、startService 启动的服务：主要用于启动一个服务执行后台任务，不进行通信。停止服务使用stopService；
2、bindService 启动的服务：该方法启动的服务可以进行通信。停止服务使用unbindService；
3、startService 同时也 bindService 启动的服务：停止服务应同时使用stepService与unbindService
Service 与 Thread 的区别
很多时候，你可能会问，为什么要用 Service，而不用 Thread 呢，因为用 Thread 是很方便的，比起 Service 也方便多了，下面我详细的来解释一下。
1). Thread：Thread 是程序执行的最小单元，它是分配CPU的基本单位。可以用 Thread 来执行一些异步的操作。
2). Service：Service 是android的一种机制，当它运行的时候如果是Local Service，那么对应的 Service 是运行在主进程的 main 线程上的。如：onCreate，onStart 这些函数在被系统调用的时候都是在主进程的 main 线程上运行的。如果是Remote Service，那么对应的 Service 则是运行在独立进程的 main 线程上。因此请不要把 Service 理解成线程，它跟线程半毛钱的关系都没有！
既然这样，那么我们为什么要用 Service 呢？其实这跟 android 的系统机制有关，我们先拿 Thread 来说。Thread 的运行是独立于 Activity 的，也就是说当一个 Activity 被 finish 之后，如果你没有主动停止 Thread 或者 Thread 里的 run 方法没有执行完毕的话，Thread 也会一直执行。因此这里会出现一个问题：当 Activity 被 finish 之后，你不再持有该 Thread 的引用。另一方面，你没有办法在不同的 Activity 中对同一 Thread 进行控制。
举个例子：如果你的 Thread 需要不停地隔一段时间就要连接服务器做某种同步的话，该 Thread 需要在 Activity 没有start的时候也在运行。这个时候当你 start 一个 Activity 就没有办法在该 Activity 里面控制之前创建的 Thread。因此你便需要创建并启动一个 Service ，在 Service 里面创建、运行并控制该 Thread，这样便解决了该问题（因为任何 Activity 都可以控制同一 Service，而系统也只会创建一个对应 Service 的实例）。
  
因此你可以把 Service 想象成一种消息服务，而你可以在任何有 Context 的地方调用 Context.startService、Context.stopService、Context.bindService，Context.unbindService，来控制它，你也可以在 Service 里注册 BroadcastReceiver，在其他地方通过发送 broadcast 来控制它，当然这些都是 Thread 做不到的。
Service的生命周期
onCreate　　onStart　　onDestroy　　onBind 
1). 被启动的服务的生命周期：如果一个Service被某个Activity 调用 Context.startService 方法启动，那么不管是否有Activity使用bindService绑定或unbindService解除绑定到该Service，该Service都在后台运行。如果一个Service被startService 方法多次启动，那么onCreate方法只会调用一次，onStart将会被调用多次（对应调用startService的次数），并且系统只会创建Service的一个实例（因此你应该知道只需要一次stopService调用）。该Service将会一直在后台运行，而不管对应程序的Activity是否在运行，直到被调用stopService，或自身的stopSelf方法。当然如果系统资源不足，android系统也可能结束服务。
2). 被绑定的服务的生命周期：如果一个Service被某个Activity 调用 Context.bindService 方法绑定启动，不管调用 bindService 调用几次，onCreate方法都只会调用一次，同时onStart方法始终不会被调用。当连接建立之后，Service将会一直运行，除非调用Context.unbindService 断开连接或者之前调用bindService 的 Context 不存在了（如Activity被finish的时候），系统将会自动停止Service，对应onDestroy将被调用。
3). 被启动又被绑定的服务的生命周期：如果一个Service又被启动又被绑定，则该Service将会一直在后台运行。并且不管如何调用，onCreate始终只会调用一次，对应startService调用多少次，Service的onStart便会调用多少次。调用unbindService将不会停止Service，而必须调用 stopService 或 Service的 stopSelf 来停止服务。
4). 当服务被停止时清除服务：当一个Service被终止（1、调用stopService；2、调用stopSelf；3、不再有绑定的连接（没有被启动））时，onDestroy方法将会被调用，在这里你应当做一些清除工作，如停止在Service中创建并运行的线程。
特别注意：
1、你应当知道在调用 bindService 绑定到Service的时候，你就应当保证在某处调用 unbindService 解除绑定（尽管 Activity 被 finish 的时候绑定会自　　　　　　动解除，并且Service会自动停止）；
2、你应当注意 使用 startService 启动服务之后，一定要使用 stopService停止服务，不管你是否使用bindService； 
3、同时使用 startService 与 bindService 要注意到，Service 的终止，需要unbindService与stopService同时调用，才能终止 Service，不管 startService 与 bindService 的调用顺序，如果先调用 unbindService 此时服务不会自动终止，再调用 stopService 之后服务才会停止，如果先调用 stopService 此时服务也不会终止，而再调用 unbindService 或者 之前调用 bindService 的 Context 不存在了（如Activity 被 finish 的时候）之后服务才会自动停止；
4、当在旋转手机屏幕的时候，当手机屏幕在“横”“竖”变换时，此时如果你的 Activity 如果会自动旋转的话，旋转其实是 Activity 的重新创建，因此旋转之前的使用 bindService 建立的连接便会断开（Context 不存在了），对应服务的生命周期与上述相同。
5、在 sdk 2.0 及其以后的版本中，对应的 onStart 已经被否决变为了 onStartCommand，不过之前的 onStart 任然有效。这意味着，如果你开发的应用程序用的 sdk 为 2.0 及其以后的版本，那么你应当使用 onStartCommand 而不是 onStart。

下面开始上一个很简单的代码哈~里头的注释也要注意哦，有在上面没有讲到的会在注释里提到哇（尤其适用Bind方法的时候的数据传输哇）~
首先，因为要再Manifest文件里对服务进行注册，所以就先来Manifest的代码吧~
[html] view plain copy
 print?
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     package="com.test.localservice" android:versionCode="1"  
  4.     android:versionName="1.0">  
  5.     <uses-sdk android:minSdkVersion="8" />  
  6.   
  7.     <application android:icon="@drawable/icon" android:label="@string/app_name">  
  8.         <activity android:name=".LocalServiceTestActivity"  
  9.             android:label="@string/app_name">  
  10.             <intent-filter>  
  11.                 <action android:name="android.intent.action.MAIN" />  
  12.                 <category android:name="android.intent.category.LAUNCHER" />  
  13.             </intent-filter>  
  14.         </activity>  
  15.         <service android:name=".MyService">  
  16.             <intent-filter>  
  17.                 <action android:name="com.test.SERVICE_TEST" />  
  18.                 <category android:name="android.intent.category.default" />  
  19.             </intent-filter>  
  20.         </service>  
  21.     </application>  
  22. </manifest>  

然后然后，是服务实现类~
[java] view plain copy
 print?
  1.   
[java] view plain copy
 print?
  1. package com.test.service;  
  2.   
  3. import android.app.Service;  
  4. import android.content.Intent;  
  5. import android.os.Binder;  
  6. import android.os.IBinder;  
  7. import android.util.Log;  
  8.   
  9. public class MyService extends Service {  
  10.   
  11.     public class LocalBinder extends Binder {  
  12.         String stringToSend = "I'm the test String";  
  13.         MyService getService() {  
  14.             Log.i("TAG", "getService ---> " + MyService.this);  
  15.             return MyService.this;  
  16.         }  
  17.     }  
  18.   
  19.     private final IBinder mBinder = new LocalBinder();  
  20.   
  21.     @Override  
  22.     public IBinder onBind(Intent intent) {  
  23.         // TODO Auto-generated method stub  
  24.         Log.i("TAG", "onBind~~~~~~~~~~~~");  
  25. //      IBinder myIBinder = null;  
  26. //      if ( null == myIBinder )   
  27. //          myIBinder = new LocalBinder() ;   
  28. //      return myIBinder;  
  29.         return mBinder;     //也可以像上面几个语句那样重新new一个IBinder  
  30.         //如果这边不返回一个IBinder的接口实例，那么ServiceConnection中的onServiceConnected就不会被调用  
  31.         //那么bind所具有的传递数据的功能也就体现不出来~\(≧▽≦)/~啦啦啦（这个返回值是被作为onServiceConnected中的第二个参数的）  
  32.     }  
  33.   
  34.     @Override  
  35.     public void onCreate() {  
  36.         // TODO Auto-generated method stub  
  37.         super.onCreate();  
  38.   
  39.         Log.i("TAG", "onCreate~~~~~~~~~~");  
  40.     }  
  41.   
  42.     @Override  
  43.     public void onDestroy() {  
  44.         // TODO Auto-generated method stub  
  45.         super.onDestroy();  
  46.         Log.i("TAG", "onDestroy~~~~~~~~~~~");  
  47.     }  
  48.   
  49.     @Override  
  50.     public void onStart(Intent intent, int startId) {  
  51.         // TODO Auto-generated method stub  
  52.         super.onStart(intent, startId);  
  53.         Log.i("TAG", "onStart~~~~~~");  
  54.     }  
  55.   
  56.     @Override  
  57.     public int onStartCommand(Intent intent, int flags, int startId) {  
  58.         // TODO Auto-generated method stub  
  59.         Log.i("TAG", "onStartCommand~~~~~~~~~~~~");  
  60.         return super.onStartCommand(intent, flags, startId);  
  61.     }  
  62.   
  63.     @Override  
  64.     public boolean onUnbind(Intent intent) {  
  65.         // TODO Auto-generated method stub  
  66.         Log.i("TAG", "onUnbind~~~~~~~~~~~~~~~~");  
  67.         return super.onUnbind(intent);  
  68.     }  
  69. }  


再来，就是我们的Activity的测试类啦~
[java] view plain copy
 print?
  1. <pre name="code" class="java">package com.test.service;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.ComponentName;  
  5. import android.content.Context;  
  6. import android.content.Intent;  
  7. import android.content.ServiceConnection;  
  8. import android.media.MediaPlayer;  
  9. import android.os.Bundle;  
  10. import android.os.IBinder;  
  11. import android.util.Log;  
  12. import android.view.View;  
  13. import android.view.View.OnClickListener;  
  14. import android.widget.Button;  
  15.   
  16. public class ServiceTestActivity extends Activity {  
  17.     private Button startButton, bindButton;  
  18.     private Button stopButton, unbindButton;  
  19.     private ServiceConnection sc;  
  20.     private MediaPlayer mediaPlayer = null;  
  21.     private MyService myService;// 类似于MediaPlayer mPlayer = new  
  22.                                 // MediaPlayer();只不过这边的服务是自定义的，不是系统提供好了的  
  23.   
  24.     /** Called when the activity is first created. */  
  25.     @Override  
  26.     public void onCreate(Bundle savedInstanceState) {  
  27.         super.onCreate(savedInstanceState);  
  28.         setContentView(R.layout.main);  
  29.   
  30.         startButton = (Button) findViewById(R.id.startbutton_id);  
  31.         stopButton = (Button) findViewById(R.id.stopbutton_id);  
  32.         bindButton = (Button) findViewById(R.id.bindbutton_id);  
  33.         unbindButton = (Button) findViewById(R.id.unbindbutton_id);  
  34.   
  35.         sc = new ServiceConnection() {  
  36.             /* 
  37.              * 只有在MyService中的onBind方法中返回一个IBinder实例才会在Bind的时候 
  38.              * 调用onServiceConnection回调方法 
  39.              * 第二个参数service就是MyService中onBind方法return的那个IBinder实例，可以利用这个来传递数据 
  40.              */  
  41.             @Override  
  42.             public void onServiceConnected(ComponentName name, IBinder service) {  
  43.                 // TODO Auto-generated method stub  
  44.                 myService = ((MyService.LocalBinder) service).getService();  
  45.                 String recStr = ((MyService.LocalBinder) service).stringToSend;  
  46.                 //利用IBinder对象传递过来的字符串数据（其他数据也可以啦，哪怕是一个对象也OK~~）  
  47.                 Log.i("TAG","The String is : " + recStr);  
  48.                 Log.i("TAG", "onServiceConnected : myService ---> " + myService);  
  49.             }  
  50.   
  51.             @Override  
  52.             public void onServiceDisconnected(ComponentName name) {  
  53.                 /* SDK上是这么说的： 
  54.                  * This is called when the connection with the service has been unexpectedly disconnected 
  55.                  * that is, its process crashed. Because it is running in our same process, we should never see this happen. 
  56.                  * 所以说，只有在service因异常而断开连接的时候，这个方法才会用到*/  
  57.                 // TODO Auto-generated method stub  
  58.                 sc = null;  
  59.                 Log.i("TAG", "onServiceDisconnected : ServiceConnection --->"  
  60.                         + sc);  
  61.             }  
  62.   
  63.         };  
  64.         startButton.setOnClickListener(new OnClickListener() {  
  65.   
  66.             @Override  
  67.             public void onClick(View v) {  
  68.                 // TODO Auto-generated method stub  
  69.                 Intent intent = new Intent(ServiceTestActivity.this,  
  70.                         MyService.class);  
  71.                 startService(intent);  
  72.                 Log.i("TAG", "Start button clicked");  
  73.             }  
  74.         });  
  75.   
  76.         stopButton.setOnClickListener(new OnClickListener() {  
  77.   
  78.             @Override  
  79.             public void onClick(View v) {  
  80.                 // TODO Auto-generated method stub  
  81.   
  82.                 /* 
  83.                  * Intent intent = new 
  84.                  * Intent(LocalServiceTestActivity.this,MyService.class); 
  85.                  * stopService(intent); 这种方法也是可以的哈~ 
  86.                  */  
  87.   
  88.                 Intent intent = new Intent();  
  89.                 intent.setAction("com.test.SERVICE_TEST");  
  90.                 stopService(intent);  
  91.                 Log.i("TAG", "Stop Button clicked");  
  92.             }  
  93.         });  
  94.   
  95.         bindButton.setOnClickListener(new OnClickListener() {  
  96.   
  97.             @Override  
  98.             public void onClick(View v) {  
  99.                 // TODO Auto-generated method stub  
  100. //              Intent intent = new Intent(LocalServiceTestActivity.this,  
  101. //                      MyService.class);//这样也可以的  
  102.                 Intent intent = new Intent();  
  103.                 intent.setAction("com.test.SERVICE_TEST");  
  104.                 bindService(intent, sc, Context.BIND_AUTO_CREATE);//bind多次也只会调用一次onBind方法  
  105.                 Log.i("TAG", "Bind button clicked");  
  106.             }  
  107.         });  
  108.   
  109.         unbindButton.setOnClickListener(new OnClickListener() {  
  110.   
  111.             @Override  
  112.             public void onClick(View v) {  
  113.                 // TODO Auto-generated method stub  
  114.                 unbindService(sc);  
  115.                 // 这边如果重复unBind会报错，提示该服务没有注册的错误——IllegalArgumentException:  
  116.                 // Service not registered: null  
  117.                 // 所以一般会设置一个flag去看这个service  
  118.                 // bind后有没有被unBind过，没有unBind过才能调用unBind方法(这边我就不设置了哈~\(≧▽≦)/~啦啦啦)  
  119.                 Log.i("TAG", "Unbind Button clicked");  
  120.             }  
  121.         });  
  122.     }  
  123. }</pre><br>  
  124. <br>  
  125. <pre></pre>  
  126. <br>  
  127. 相信开头的介绍和代码里的注释应该对大家理解和使用Service有所帮助哈~不过这边就先只讲LocalService吧，剩下的RemoteService就等下次在说喽~  
  128. <p></p>  
  129. <p><span style="white-space:pre"><span style="font-family:verdana,宋体,Arial; font-size:13px; line-height:24px"><span style="font-family:verdana,宋体,Arial; font-size:13px; line-height:24px"><span style="font-family:verdana,宋体,Arial; font-size:13px; line-height:24px"><span style="white-space:pre"><span style="font-family:verdana,宋体,Arial; font-size:13px; line-height:24px"><span style="font-family:verdana,宋体,Arial; font-size:13px; line-height:24px"><span style="font-family:verdana,宋体,Arial; font-size:13px; line-height:24px"><span style="white-space:pre"><span style="font-family:verdana,宋体,Arial; font-size:13px; line-height:24px"><span style="font-family:verdana,宋体,Arial; font-size:13px; line-height:24px"><span style="white-space:pre"><span style="font-family:verdana,宋体,Arial; font-size:13px; line-height:24px"><span style="color:rgb(51,51,51); font-family:verdana,宋体,Arial; font-size:13px; line-height:24px"><span style="white-space:pre"></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></p>  
  130.      
  1. Service与Activity怎么实现通信

转载请注明地址http://blog.csdn.net/xiaanming/article/details/9750689
在Android中，Activity主要负责前台页面的展示，Service主要负责需要长期运行的任务，所以在我们实际开发中，就会常常遇到Activity与Service之间的通信，我们一般在Activity中启动后台Service，通过Intent来启动，Intent中我们可以传递数据给Service，而当我们Service执行某些操作之后想要更新UI线程，我们应该怎么做呢？接下来我就介绍两种方式来实现Service与Activity之间的通信问题
  • 通过Binder对象
当Activity通过调用bindService(Intent service, ServiceConnection conn,int flags),我们可以得到一个Service的一个对象实例，然后我们就可以访问Service中的方法，我们还是通过一个例子来理解一下吧，一个模拟下载的小例子，带大家理解一下通过Binder通信的方式
首先我们新建一个工程Communication，然后新建一个Service类
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <span style="font-family:System;">package com.example.communication;  
  2.   
  3. import android.app.Service;  
  4. import android.content.Intent;  
  5. import android.os.Binder;  
  6. import android.os.IBinder;  
  7.   
  8. public class MsgService extends Service {  
  9.     /** 
  10.      * 进度条的最大值 
  11.      */  
  12.     public static final int MAX_PROGRESS = 100;  
  13.     /** 
  14.      * 进度条的进度值 
  15.      */  
  16.     private int progress = 0;  
  17.   
  18.     /** 
  19.      * 增加get()方法，供Activity调用 
  20.      * @return 下载进度 
  21.      */  
  22.     public int getProgress() {  
  23.         return progress;  
  24.     }  
  25.   
  26.     /** 
  27.      * 模拟下载任务，每秒钟更新一次 
  28.      */  
  29.     public void startDownLoad(){  
  30.         new Thread(new Runnable() {  
  31.               
  32.             @Override  
  33.             public void run() {  
  34.                 while(progress < MAX_PROGRESS){  
  35.                     progress += 5;  
  36.                     try {  
  37.                         Thread.sleep(1000);  
  38.                     } catch (InterruptedException e) {  
  39.                         e.printStackTrace();  
  40.                     }  
  41.                       
  42.                 }  
  43.             }  
  44.         }).start();  
  45.     }  
  46.   
  47.   
  48.     /** 
  49.      * 返回一个Binder对象 
  50.      */  
  51.     @Override  
  52.     public IBinder onBind(Intent intent) {  
  53.         return new MsgBinder();  
  54.     }  
  55.       
  56.     public class MsgBinder extends Binder{  
  57.         /** 
  58.          * 获取当前Service的实例 
  59.          * @return 
  60.          */  
  61.         public MsgService getService(){  
  62.             return MsgService.this;  
  63.         }  
  64.     }  
  65.   
  66. }</span>  
上面的代码比较简单，注释也比较详细，最基本的Service的应用了，相信你看得懂的，我们调用startDownLoad()方法来模拟下载任务，然后每秒更新一次进度，但这是在后台进行中，我们是看不到的，所以有时候我们需要他能在前台显示下载的进度问题，所以我们接下来就用到Activity了
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. Intent intent = new Intent("com.example.communication.MSG_ACTION");    
  2. bindService(intent, conn, Context.BIND_AUTO_CREATE);  
通过上面的代码我们就在Activity绑定了一个Service,上面需要一个ServiceConnection对象，它是一个接口，我们这里使用了匿名内部类
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <span style="font-family:System;">  ServiceConnection conn = new ServiceConnection() {  
  2.           
  3.         @Override  
  4.         public void onServiceDisconnected(ComponentName name) {  
  5.               
  6.         }  
  7.           
  8.         @Override  
  9.         public void onServiceConnected(ComponentName name, IBinder service) {  
  10.             //返回一个MsgService对象  
  11.             msgService = ((MsgService.MsgBinder)service).getService();  
  12.               
  13.         }  
  14.     };</span>  
在onServiceConnected(ComponentName name, IBinder service) 回调方法中，返回了一个MsgService中的Binder对象，我们可以通过getService()方法来得到一个MsgService对象，然后可以调用MsgService中的一些方法,Activity的代码如下
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <span style="font-family:System;">package com.example.communication;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.ComponentName;  
  5. import android.content.Context;  
  6. import android.content.Intent;  
  7. import android.content.ServiceConnection;  
  8. import android.os.Bundle;  
  9. import android.os.IBinder;  
  10. import android.view.View;  
  11. import android.view.View.OnClickListener;  
  12. import android.widget.Button;  
  13. import android.widget.ProgressBar;  
  14.   
  15. public class MainActivity extends Activity {  
  16.     private MsgService msgService;  
  17.     private int progress = 0;  
  18.     private ProgressBar mProgressBar;  
  19.       
  20.   
  21.     @Override  
  22.     protected void onCreate(Bundle savedInstanceState) {  
  23.         super.onCreate(savedInstanceState);  
  24.         setContentView(R.layout.activity_main);  
  25.           
  26.           
  27.         //绑定Service  
  28.         Intent intent = new Intent("com.example.communication.MSG_ACTION");  
  29.         bindService(intent, conn, Context.BIND_AUTO_CREATE);  
  30.           
  31.           
  32.         mProgressBar = (ProgressBar) findViewById(R.id.progressBar1);  
  33.         Button mButton = (Button) findViewById(R.id.button1);  
  34.         mButton.setOnClickListener(new OnClickListener() {  
  35.               
  36.             @Override  
  37.             public void onClick(View v) {  
  38.                 //开始下载  
  39.                 msgService.startDownLoad();  
  40.                 //监听进度  
  41.                 listenProgress();  
  42.             }  
  43.         });  
  44.           
  45.     }  
  46.       
  47.   
  48.     /** 
  49.      * 监听进度，每秒钟获取调用MsgService的getProgress()方法来获取进度，更新UI 
  50.      */  
  51.     public void listenProgress(){  
  52.         new Thread(new Runnable() {  
  53.               
  54.             @Override  
  55.             public void run() {  
  56.                 while(progress < MsgService.MAX_PROGRESS){  
  57.                     progress = msgService.getProgress();  
  58.                     mProgressBar.setProgress(progress);  
  59.                     try {  
  60.                         Thread.sleep(1000);  
  61.                     } catch (InterruptedException e) {  
  62.                         e.printStackTrace();  
  63.                     }  
  64.                 }  
  65.                   
  66.             }  
  67.         }).start();  
  68.     }  
  69.       
  70.     ServiceConnection conn = new ServiceConnection() {  
  71.         @Override  
  72.         public void onServiceDisconnected(ComponentName name) {  
  73.               
  74.         }  
  75.           
  76.         @Override  
  77.         public void onServiceConnected(ComponentName name, IBinder service) {  
  78.             //返回一个MsgService对象  
  79.             msgService = ((MsgService.MsgBinder)service).getService();  
  80.               
  81.         }  
  82.     };  
  83.   
  84.     @Override  
  85.     protected void onDestroy() {  
  86.         unbindService(conn);  
  87.         super.onDestroy();  
  88.     }  
  89.   
  90.   
  91. }</span><span style="font-family: simsun;">  
  92. </span>  
其实上面的代码我还是有点疑问，就是监听进度变化的那个方法我是直接在线程中更新UI的，不是说不能在其他线程更新UI操作吗，可能是ProgressBar比较特殊吧，我也没去研究它的源码，知道的朋友可以告诉我一声，谢谢！
上面的代码就完成了在Service更新UI的操作，可是你发现了没有，我们每次都要主动调用getProgress()来获取进度值，然后隔一秒在调用一次getProgress()方法，你会不会觉得很被动呢？可不可以有一种方法当Service中进度发生变化主动通知Activity，答案是肯定的，我们可以利用回调接口实现Service的主动通知，不理解回调方法的可以看看http://blog.csdn.net/xiaanming/article/details/8703708
新建一个回调接口
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public interface OnProgressListener {  
  2.     void onProgress(int progress);  
  3. }  
MsgService的代码有一些小小的改变，为了方便大家看懂，我还是将所有代码贴出来
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <span style="font-family:System;">package com.example.communication;  
  2.   
  3. import android.app.Service;  
  4. import android.content.Intent;  
  5. import android.os.Binder;  
  6. import android.os.IBinder;  
  7.   
  8. public class MsgService extends Service {  
  9.     /** 
  10.      * 进度条的最大值 
  11.      */  
  12.     public static final int MAX_PROGRESS = 100;  
  13.     /** 
  14.      * 进度条的进度值 
  15.      */  
  16.     private int progress = 0;  
  17.       
  18.     /** 
  19.      * 更新进度的回调接口 
  20.      */  
  21.     private OnProgressListener onProgressListener;  
  22.       
  23.       
  24.     /** 
  25.      * 注册回调接口的方法，供外部调用 
  26.      * @param onProgressListener 
  27.      */  
  28.     public void setOnProgressListener(OnProgressListener onProgressListener) {  
  29.         this.onProgressListener = onProgressListener;  
  30.     }  
  31.   
  32.     /** 
  33.      * 增加get()方法，供Activity调用 
  34.      * @return 下载进度 
  35.      */  
  36.     public int getProgress() {  
  37.         return progress;  
  38.     }  
  39.   
  40.     /** 
  41.      * 模拟下载任务，每秒钟更新一次 
  42.      */  
  43.     public void startDownLoad(){  
  44.         new Thread(new Runnable() {  
  45.               
  46.             @Override  
  47.             public void run() {  
  48.                 while(progress < MAX_PROGRESS){  
  49.                     progress += 5;  
  50.                       
  51.                     //进度发生变化通知调用方  
  52.                     if(onProgressListener != null){  
  53.                         onProgressListener.onProgress(progress);  
  54.                     }  
  55.                       
  56.                     try {  
  57.                         Thread.sleep(1000);  
  58.                     } catch (InterruptedException e) {  
  59.                         e.printStackTrace();  
  60.                     }  
  61.                       
  62.                 }  
  63.             }  
  64.         }).start();  
  65.     }  
  66.   
  67.   
  68.     /** 
  69.      * 返回一个Binder对象 
  70.      */  
  71.     @Override  
  72.     public IBinder onBind(Intent intent) {  
  73.         return new MsgBinder();  
  74.     }  
  75.       
  76.     public class MsgBinder extends Binder{  
  77.         /** 
  78.          * 获取当前Service的实例 
  79.          * @return 
  80.          */  
  81.         public MsgService getService(){  
  82.             return MsgService.this;  
  83.         }  
  84.     }  
  85.   
  86. }</span>  
Activity中的代码如下
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <span style="font-family:System;">package com.example.communication;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.ComponentName;  
  5. import android.content.Context;  
  6. import android.content.Intent;  
  7. import android.content.ServiceConnection;  
  8. import android.os.Bundle;  
  9. import android.os.IBinder;  
  10. import android.view.View;  
  11. import android.view.View.OnClickListener;  
  12. import android.widget.Button;  
  13. import android.widget.ProgressBar;  
  14.   
  15. public class MainActivity extends Activity {  
  16.     private MsgService msgService;  
  17.     private ProgressBar mProgressBar;  
  18.       
  19.   
  20.     @Override  
  21.     protected void onCreate(Bundle savedInstanceState) {  
  22.         super.onCreate(savedInstanceState);  
  23.         setContentView(R.layout.activity_main);  
  24.           
  25.           
  26.         //绑定Service  
  27.         Intent intent = new Intent("com.example.communication.MSG_ACTION");  
  28.         bindService(intent, conn, Context.BIND_AUTO_CREATE);  
  29.           
  30.           
  31.         mProgressBar = (ProgressBar) findViewById(R.id.progressBar1);  
  32.         Button mButton = (Button) findViewById(R.id.button1);  
  33.         mButton.setOnClickListener(new OnClickListener() {  
  34.               
  35.             @Override  
  36.             public void onClick(View v) {  
  37.                 //开始下载  
  38.                 msgService.startDownLoad();  
  39.             }  
  40.         });  
  41.           
  42.     }  
  43.       
  44.   
  45.     ServiceConnection conn = new ServiceConnection() {  
  46.         @Override  
  47.         public void onServiceDisconnected(ComponentName name) {  
  48.               
  49.         }  
  50.           
  51.         @Override  
  52.         public void onServiceConnected(ComponentName name, IBinder service) {  
  53.             //返回一个MsgService对象  
  54.             msgService = ((MsgService.MsgBinder)service).getService();  
  55.               
  56.             //注册回调接口来接收下载进度的变化  
  57.             msgService.setOnProgressListener(new OnProgressListener() {  
  58.                   
  59.                 @Override  
  60.                 public void onProgress(int progress) {  
  61.                     mProgressBar.setProgress(progress);  
  62.                       
  63.                 }  
  64.             });  
  65.               
  66.         }  
  67.     };  
  68.   
  69.     @Override  
  70.     protected void onDestroy() {  
  71.         unbindService(conn);  
  72.         super.onDestroy();  
  73.     }  
  74.   
  75.   
  76. }  
  77. </span>  
用回调接口是不是更加的方便呢，当进度发生变化的时候Service主动通知Activity，Activity就可以更新UI操作了

  • 通过broadcast(广播)的形式
当我们的进度发生变化的时候我们发送一条广播，然后在Activity的注册广播接收器，接收到广播之后更新ProgressBar,代码如下
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. package com.example.communication;  
  2. <span style="font-family:System;">  
  3. import android.app.Activity;  
  4. import android.content.BroadcastReceiver;  
  5. import android.content.Context;  
  6. import android.content.Intent;  
  7. import android.content.IntentFilter;  
  8. import android.os.Bundle;  
  9. import android.view.View;  
  10. import android.view.View.OnClickListener;  
  11. import android.widget.Button;  
  12. import android.widget.ProgressBar;  
  13.   
  14. public class MainActivity extends Activity {  
  15.     private ProgressBar mProgressBar;  
  16.     private Intent mIntent;  
  17.     private MsgReceiver msgReceiver;  
  18.       
  19.   
  20.     @Override  
  21.     protected void onCreate(Bundle savedInstanceState) {  
  22.         super.onCreate(savedInstanceState);  
  23.         setContentView(R.layout.activity_main);  
  24.           
  25.         //动态注册广播接收器  
  26.         msgReceiver = new MsgReceiver();  
  27.         IntentFilter intentFilter = new IntentFilter();  
  28.         intentFilter.addAction("com.example.communication.RECEIVER");  
  29.         registerReceiver(msgReceiver, intentFilter);  
  30.           
  31.           
  32.         mProgressBar = (ProgressBar) findViewById(R.id.progressBar1);  
  33.         Button mButton = (Button) findViewById(R.id.button1);  
  34.         mButton.setOnClickListener(new OnClickListener() {  
  35.               
  36.             @Override  
  37.             public void onClick(View v) {  
  38.                 //启动服务  
  39.                 mIntent = new Intent("com.example.communication.MSG_ACTION");  
  40.                 startService(mIntent);  
  41.             }  
  42.         });  
  43.           
  44.     }  
  45.   
  46.       
  47.     @Override  
  48.     protected void onDestroy() {  
  49.         //停止服务  
  50.         stopService(mIntent);  
  51.         //注销广播  
  52.         unregisterReceiver(msgReceiver);  
  53.         super.onDestroy();  
  54.     }  
  55.   
  56.   
  57.     /** 
  58.      * 广播接收器 
  59.      * @author len 
  60.      * 
  61.      */  
  62.     public class MsgReceiver extends BroadcastReceiver{  
  63.   
  64.         @Override  
  65.         public void onReceive(Context context, Intent intent) {  
  66.             //拿到进度，更新UI  
  67.             int progress = intent.getIntExtra("progress", 0);  
  68.             mProgressBar.setProgress(progress);  
  69.         }  
  70.           
  71.     }  
  72.   
  73. }  
  74. </span>  
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <span style="font-family:System;">package com.example.communication;  
  2.   
  3. import android.app.Service;  
  4. import android.content.Intent;  
  5. import android.os.IBinder;  
  6.   
  7. public class MsgService extends Service {  
  8.     /** 
  9.      * 进度条的最大值 
  10.      */  
  11.     public static final int MAX_PROGRESS = 100;  
  12.     /** 
  13.      * 进度条的进度值 
  14.      */  
  15.     private int progress = 0;  
  16.       
  17.     private Intent intent = new Intent("com.example.communication.RECEIVER");  
  18.       
  19.   
  20.     /** 
  21.      * 模拟下载任务，每秒钟更新一次 
  22.      */  
  23.     public void startDownLoad(){  
  24.         new Thread(new Runnable() {  
  25.               
  26.             @Override  
  27.             public void run() {  
  28.                 while(progress < MAX_PROGRESS){  
  29.                     progress += 5;  
  30.                       
  31.                     //发送Action为com.example.communication.RECEIVER的广播  
  32.                     intent.putExtra("progress", progress);  
  33.                     sendBroadcast(intent);  
  34.                       
  35.                     try {  
  36.                         Thread.sleep(1000);  
  37.                     } catch (InterruptedException e) {  
  38.                         e.printStackTrace();  
  39.                     }  
  40.                       
  41.                 }  
  42.             }  
  43.         }).start();  
  44.     }  
  45.   
  46.       
  47.   
  48.     @Override  
  49.     public int onStartCommand(Intent intent, int flags, int startId) {  
  50.         startDownLoad();  
  51.         return super.onStartCommand(intent, flags, startId);  
  52.     }  
  53.   
  54.   
  55.   
  56.     @Override  
  57.     public IBinder onBind(Intent intent) {  
  58.         return null;  
  59.     }  
  60.   
  61.   
  62. }</span>  
总结:
  1. Activity调用bindService (Intent service, ServiceConnection conn, int flags)方法，得到Service对象的一个引用，这样Activity可以直接调用到Service中的方法，如果要主动通知Activity，我们可以利用回调方法
  2.  Service向Activity发送消息，可以使用广播，当然Activity要注册相应的接收器。比如Service要向多个Activity发送同样的消息的话，用这种方法就更好
复制代码
0 0
网络机房整改方案 网络机房整改方案
原创粉丝点击
热门IT博客
粒子滤波算法及其应用粒子滤波算法及其应用
httpclient获取jsonhttpclient获取json
矩阵按列归一化
自动发卡程序源码
淘宝如何收藏店铺
淘宝售后客服怎么应聘
淘宝网装修的工作流程
blink sunshine 知乎
软件测试计划书模板
443端口漏洞
淘宝上怎么发布广告
视频音量放大软件
股票买入卖出实时数据
知乎 恶魔的奶爸
matlab导入多个txt数据
java 日期加三个月
卷积神经网络知乎
两个mac之间屏幕共享
声音放大器软件
五笔拼音混合输入 mac
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 客机 大型客机 客机时速 客机图片 幽灵客机 超音速客机 客机速度 波音客机 黑龙江客机 客机价格 支线客机 中国客机 客机坠毁 民航客机 737客机 肯尼亚客机坠毁 波音客机硬着陆起火 波音客机引擎起火 美客机7分钟骤降9000米 波音客机硬着陆起火x 哈尔滨客机卡在桥下 客机飞行高度 美国客机冲出跑道 中国大型客机 波音客机存在裂缝4 波音客机硬着陆起火0 肯尼亚客机坠毁我 客机遭海鸥撞击 客机遭鸟击返航 客机飞行速度 肯尼亚客机坠毁有没中国人 波音客机存在裂缝一 韩国客机起火事件 客机玻璃破裂返航 民航客机飞行速度 日航客机大连返航 飞机飞 飞机大全 飞机飞多高 飞机坠毁 印尼狮航波音客机坠毁

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里