Android Service和广播

前言：

我们都知道Android的四大基本组件：Activity、ContentProvider、Service以及BroadcastReceiver，前面的两个我们在前几篇已经具体讲解了，今天这一天我们就把后两者的使用具体说一下，由于Service和BroadcastReceiver常常一起使用，所以我们一起来学习。

一．Service的使用

Service是Android系统的后台服务组件，没有用户界面，但可以长时间的运行，比Activity的优先级高，可以用于进程间的通信。

Service也同Activity一样有自己的生命周期，但是Service有两种生命周期，也就是Service由两种启动以及对应的停止方式：

1.以启动方式使用的Service：

（1）特点：

A.通过Content.startService()启动，Content.stopService()或者Content.stopSelf()来停止；

（即只能通过其他组件启动，但可以自己停止）

B.不能与外部的组件进行交互；

（2）生命周期：

onCreate——>onStartCommand——>onDestroy

（3）示例代码：L0828_Service（记得注册）

MyService.java：

package com.example.l0828_service;
import java.util.Timer;
import java.util.TimerTask;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
public class MyService extends Service{
    //声明定时器，用于创建新的进程来计时
    private Timer timer;
    private TimerTask task;
    private static int i=0;
    //继承Service必须要重写的方法onBind
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
    /*Service的生命周期一：onCreate、onStartCommand、onDestroy方法构成*/
    //onCreate方法，启动服务，每次启动仅仅调用一次
    @Override
    public void onCreate() {
        System.out.println("onCreate");
        super.onCreate();
    }
    //onStartCommand方法，一般在其中完成Service的工作
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        System.out.println("onStartCommond");
        startTimer();
        return super.onStartCommand(intent, flags, startId);
    }
    //onDestroy方法，用来释放Service的资源
    @Override
    public void onDestroy() {
        System.out.println("onDestroy");
        stopTimer();
        super.onDestroy();
    }
    //开启定时器
    public void startTimer(){
        timer =new Timer();
        task=new TimerTask(){
            @Override
            public void run() {
                i++;
                System.out.println(i);
            }
        };
        timer.schedule(task, 1000, 1000);
    }
    //停止定时器
    public void stopTimer(){
        timer.cancel();
    }
}

Mainactivity.java：

package com.example.l0828_service;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
public class MainActivity extends Activity implements OnClickListener{
    private Button btn_start,btn_stop;
    //声明Intent用于Activity向Service的跳转
    private Intent intent;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn_start=(Button) findViewById(R.id.btn_start);
        btn_stop=(Button) findViewById(R.id.btn_stop);
        btn_start.setOnClickListener(this);
        btn_stop.setOnClickListener(this);
        //Activity组件向Service组件的跳转
        intent=new Intent(MainActivity.this,MyService.class);
    }
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
        case R.id.btn_start:
            //开启服务
            startService(intent);
            break;
        case R.id.btn_stop:
            //停止服务
            stopService(intent);
            break;
        }
    }
}

主配置文件.xml文件中注册：

<service android:name="MyService"></service>

运行效果：

起始界面

点击开始——停止的过程显示：

停止之后再次点击开始按钮又重新执行onCreate方法：

2.以绑定方式使用的Service：

（1）特点：

A.通过Content.bindService()绑定而建立与服务器的连接，通过Content.unbindService()方法解除绑定从而断开与服务器的连接；

B.如果没有调用startService直接通过调用bindService绑定服务器也会自动启动服务器；

C.能获得Service的对象，从而能够使得其他组件与Service的交互；

D.同一个Service可以绑定多个服务连接，同时与不同的组件交互；

（2）生命周期：

onCreate——>onBind——>onCommand——>onUnbind——>onRebind——>onDestroy

如果onUnbind方法返回true，则当取消绑定之后重写绑定服务时就直接调用onRebind方法了。

（3）示例代码：

MyService.java：

package com.example.l0828_service2;
import java.util.Timer;
import java.util.TimerTask;
import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
public class MyService extends Service{
    private Timer timer;
    private TimerTask task;
    private int i=0;
    private int j=0;
    //创建内部类，用于创建Binder对象，onBinder方法中使用
    class MyBinder extends Binder{
        public MyService getService(){
            return MyService.this;
        }
    }
    private MyBinder binder=new MyBinder();
    public int getI() {
        return i;
    }
    public void setI(int i) {
        this.i = i;
    } 

    public int getJ() {
        return j;
    }
    public void setJ(int j) {
        this.j = j;
    }
    //下面分别重写Service生命周期的方法
    @Override
    public IBinder onBind(Intent intent) {
        //绑定服务，开始于界面交互
        startTimer();
        System.out.println("onBind");
        return binder;
    }
    @Override
    public void onCreate() {
        System.out.println("onCreate");
        super.onCreate();
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        System.out.println("onStartCommand");
        return super.onStartCommand(intent, flags, startId);
    }
    @Override
    public boolean onUnbind(Intent intent) {
        //解除与服务器的绑定，停止与界面的交互
        stopTimer();
        System.out.println("onUnbind");
        //为了使onRebind能够调用到，使得onUnbind的返回值为true
        super.onDestroy();
        return true;
    }
    @Override
    public void onRebind(Intent intent) {
        System.out.println("onRebind");
        super.onRebind(intent);
    }
    @Override
    public void onDestroy() {
        System.out.println("onDestroy"); 

    }
    //创建定时器，即创建另一个线程负责计时
    public void startTimer(){
        timer=new Timer();
        task=new TimerTask() { 

            @Override
            public void run() {
                i++;
                if(i==j){
                    System.out.println("此时您输入的数据于服务数据相同："+j);
                }
                System.out.println(i);
            }
        };
        timer.schedule(task, 1000,1000);
    }
    //停止计时
    public void stopTimer(){
        timer.cancel();
    }
}

MainActivity.java：

package com.example.l0828_service2;
import com.example.l0828_service2.MyService.MyBinder;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
public class MainActivity extends Activity implements OnClickListener,ServiceConnection{
    private Button btn_bind,btn_unBind,btn_getService,btn_start,btn_stop;
    private Intent intent;
    private MyService myservice;
    private EditText et;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        et=(EditText) findViewById(R.id.et);
        btn_bind=(Button) findViewById(R.id.btn_bind);
        btn_unBind=(Button) findViewById(R.id.btn_unBind);
        btn_getService=(Button) findViewById(R.id.btn_getService);
        btn_start=(Button) findViewById(R.id.btn_start);
        btn_stop=(Button) findViewById(R.id.btn_stop);
        btn_bind.setOnClickListener(this);
        btn_unBind.setOnClickListener(this);
        btn_getService.setOnClickListener(this);
        btn_start.setOnClickListener(this);
        btn_stop.setOnClickListener(this);
        intent=new Intent(MainActivity.this, MyService.class);
    }
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
        case R.id.btn_bind:
            bindService(intent, this, BIND_AUTO_CREATE);
            break;
        case R.id.btn_unBind:
            unbindService(this);
            break;
        case R.id.btn_getService:
            String info=et.getText().toString();
            if("".equals(info)){
                Toast.makeText(MainActivity.this,"当前的i值："+myservice.getI() , Toast.LENGTH_SHORT).show();
            }
            myservice.setJ(Integer.parseInt(info));
            break;
        case R.id.btn_start:
            startService(intent);
            break;
        case R.id.btn_stop:
            stopService(intent);
            break;
        }
    }
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
        MyService.MyBinder binder=(MyBinder) service;
        myservice=binder.getService();
    }
    @Override
    public void onServiceDisconnected(ComponentName name) { 

    } 

}

运行效果：

初始界面：

依次点击start、bind、unbind、输入一个服务还未计时到的数、getService、stop的过程：

下图是上面执行过程的输出情况，可以清晰明了的看出整个执行的过程：

下面是这样的执行顺序的结果：

start、bind、输入及时数据、getService、unbind、（正是此时调用了onRebind方法）bind、unbind、stop的过程

二.BroadcastReceiver的使用

1.使用广播实现简单的数据接收功能：

（1）MainActivity.java：

package com.example.l0829_broadcastreceiver;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        findViewById(R.id.btn_send).setOnClickListener(new OnClickListener() { 

            @Override
            public void onClick(View v) {
                //仍然是使用Intent来实现组件之间的跳转
                Intent intent=new Intent(MainActivity.this, MyBroadCastReceiver.class);
                //把要向广播接收器发送的数据用Intent对象封装，注意键值要相同
                intent.putExtra("name", "我接收到了");
                //发送数据
                sendBroadcast(intent);
            }
        });
    }
}

（2）MyBroadcastReceiver.java：

package com.example.l0829_broadcastreceiver;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
//继承BroadcastReceiver
public class MyBroadCastReceiver extends BroadcastReceiver{
    //只需重写OnReceiver方法
    @Override
    public void onReceive(Context context, Intent intent) {
        //接收特定键值的数据，实现广播接收器的基本功能
        String str=intent.getStringExtra("name");
        System.out.println(str);
    }
}

（3）一定不要忘记注册啊（四大基本组件是都需要在主配置文件中注册的）：

<receiver android:name="MyBroadCastReceiver"></receiver>

2.再实现一个系统默认广播的例子——电量改变的广播：

（1）MainActivity.java

package com.example.l0829_system_broadcastreceiver;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.widget.TextView;
public class MainActivity extends Activity {
    //创建一个广播的实例，在其onReceive方法中实现接收的过程
    private  BroadcastReceiver myBR=new BroadcastReceiver(){
        @Override
        public void onReceive(Context context, Intent intent) {
                //if(Intent.ACTION_BATTERY_CHANGED.equals(intent.getAction()))这里也可以先判断一下，确保正确性
                //下面就是接收系统当前电量信息的过程，注意这里的键值level和scale是系统固定值，不能改变
                int level=intent.getIntExtra("level", 0);
                int scale=intent.getIntExtra("scale", 100);
                tv.setText("当前电量："+level*100/scale+"%");
            }
    };
    //声明一个TextView用来显示接受的当前电量值
    private TextView tv;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv=(TextView) findViewById(R.id.tv_receive);
        //动态注册广播的方法，在onCreate方法中
        registerReceiver(myBR, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
    }
    @Override
    protected void onStop() {
        //在onStop方法中取消广播的注册
        unregisterReceiver(myBR);
        super.onStop();
    }
}

（2）由于在代码中实现了Receiver的动态注册，那么主配置文件中就不用注册了

（3）运行效果：（有点小哈，凑合看看吧）

（另外有一个温馨提示：模拟器的电量值永远是50%，可以用真机测试）

3.最后算是来个总结吧:

我们实现一个Activity、Service、BroadcastReceiver三大组件结合使用的例子，完成Service始终在后台计时、BroadcastReceiver接收数据并及时更新主Activity的过程：

(1)MyService.java

package com.example.l0829_zujian_all;
import java.util.Timer;
import java.util.TimerTask;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
public class MyService extends Service{
    private Timer timer;
    private TimerTask task;
    private int i=0;
    private Intent intent;
    public int getI() {
        return i;
    }
    public void setI(int i) {
        this.i = i;
    }
    @Override
    public void onCreate() {
        //开始服务
        startTimer();
        super.onCreate();
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
    @Override
    public boolean onUnbind(Intent intent) {
        return super.onUnbind(intent);
    }
    @Override
    public void onRebind(Intent intent) {
        super.onRebind(intent);
    }
    @Override
    public void onDestroy() {
        //停止服务
        stopTimer();
        super.onDestroy();
    }
    public void startTimer(){
        timer=new Timer();
        task=new TimerTask() { 

            @Override
            public void run() {
                i++;
                //在计时器中及时向ACTION_MY的BroadcastReceiver接收器中发送键值为id的数据
                intent=new Intent();
                intent.setAction("ACTION_MY");
                intent.putExtra("id", i);
                sendBroadcast(intent);
            }
        };
        timer.schedule(task, 500,1000);
    }
    public void stopTimer(){
        timer.cancel();
    }
}

（2）MainActivity.java

package com.example.l0829_zujian_all;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends Activity implements OnClickListener{
    //创建接收器对象，并在onReceive方法中接收键值为id的数据
    private BroadcastReceiver br=new BroadcastReceiver() { 

        @Override
        public void onReceive(Context context, Intent intent) {
            int val=intent.getIntExtra("id", 0);
            System.out.println(intent.getIntExtra("id", 0));
            tv_show.setText(val+"");
        }
    };
    private Button btn_start,btn_stop;
    private TextView tv_show;
    private Intent intent;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv_show=(TextView) findViewById(R.id.tv_show);
        btn_start=(Button) findViewById(R.id.btn_start);
        btn_stop=(Button) findViewById(R.id.btn_stop);
        btn_start.setOnClickListener(this);
        btn_stop.setOnClickListener(this);
        intent=new Intent(MainActivity.this, MyService.class);
        //接收器的动态注册，Action必须与Service中的Action一致
        registerReceiver(br, new IntentFilter("ACTION_MY"));
    }
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
        case R.id.btn_start:
            startService(intent);
            break;
        case R.id.btn_stop:
            stopService(intent);
            break;
        }
    }
    @Override
    protected void onDestroy() {
        //取接收器的消注册
        unregisterReceiver(br);
        super.onDestroy();
    }
}

（3）注册Service，而BroadcastReceiver就不用再注册了

（4）运行效果：

即一个计时更新主页面的功能

时间： 2024-10-13 00:39:59

Android Service和广播的相关文章

Android入门：广播发送者与广播接收者

参考: Android入门:广播发送者与广播接收者 - xiazdong - CSDN博客http://blog.csdn.net/xiazdong/article/details/7768807 一.广播发送者&广播接收者介绍 1.广播接收者 广播接收者简单地说就是接收广播意图的Java类,此Java类继承BroadcastReceiver类,重写: public void onReceive(Context context,Intent intent),其中intent可以获得传递的数据:

Android Service 服务（一）—— Service

一. Service简单介绍 Service是android 系统中的四大组件之中的一个(Activity.Service.BroadcastReceiver.ContentProvider),它跟Activity的级别差点儿相同,但不能自己执行仅仅能后台执行,而且能够和其它组件进行交互.service能够在非常多场合的应用中使用,比方播放多媒体的时候用户启动了其它Activity这个时候程序要在后台继续播放,比方检測SD卡上文件的变化,再或者在后台记录你地理信息位置的改变等等,总之服务总是藏在

关于Android Service真正的完全详解，你需要知道的一切

转载请注明出处(万分感谢!): http://blog.csdn.net/javazejian/article/details/52709857 出自[zejian的博客] ??Service全部内容基本会在本篇涉及到,我们将围绕以下主要知识点进行分析: Service简单概述 Service在清单文件中的声明 Service启动服务实现方式及其详解 Service绑定服务的三种实现方式 关于启动服务与绑定服务间的转换问题 前台服务以及通知发送 服务Service与线程Thread的区别 管理服

Service和广播联合更新UI的例子

sa111111 于 2010-11-19 10:56 发表在 [Android实例] [复制链接] [只看楼主] [上一主题] [下一主题] 在Android中,异步更新UI,通常我们会选用Handler启动线程,或者sendMessage的方式,那么利用Service和广播也可以更新UI的,例子如下: 我们建立一个Service: package com.andy import android.app.Service;//引入相关包 import android.content.Broadc

Android Service使用详解

Service是Android系统中的四大组件之一,主要有两个应用场景:后台运行和跨进程访问.Service可以在后台执行长时间运行操作而不提供用户界面,除非系统必须回收内存资源,否则系统不会停止或销毁服务.服务可由其他应用组件启动,而且即使用户切换到其他应用,服务仍将在后台继续运行. 此外,组件可以绑定到服务,以与之进行交互,甚至是执行进程间通信 (IPC) 需要注意的是,Service是在主线程里执行操作的,可能会因为执行耗时操作而导致ANR 一.基础知识 Service可以分为以下三种形式

Android之旅---广播（BroadCast）

什么是广播 在Android中.Broadcast是一种广泛运用的在应用程序之间传输信息的机制. 我们拿广播电台来做个例如. 我们寻常使用收音机收音是这种:许很多多不同的广播电台通过特定的频率来发送他们的内容.而我们用户仅仅须要将频率调成和广播电台的一样就能够收听他们的内容了.Android中的广播机制就和这个差点儿相同的道理. 电台发送的内容是语音,而在Android中我们要发送的广播内容是一个Intent.这个Intent中能够携带我们要传送的数据. 电台通过大功率的发射器发送内容,而在An

Android service进程保护

应用进程保活基本就是围绕两个方面来展开: 1 尽量保证进程不被杀死. 2 进程被杀死后复活.细分如下: 1)Service重启 2)进程守护 3)Receiver触发 4) AlarmManager or JobScheduler循环触发 5)与系统Service捆绑-–可以不考虑,了解即可 下面将围绕这几点展开讨论. 一,基本概念 1.什么才叫应用进程保活 应用进程保活可以理解为应用位于后台永远不能被杀死.这里的可以简略地分为两种情况,第一种是当系统资源紧俏的时候或者基于某种系统自身的后台运行

Android之旅---广播（BroadCast）[转]

本文转自 http://www.cnblogs.com/qianlifeng/archive/2011/03/06/1972305.html 什么是广播 在Android中,Broadcast是一种广泛运用的在应用程序之间传输信息的机制.我们拿广播电台来做个比方.我们平常使用收音机收音是这样的:许许多多不同的广播电台通过特定的频率来发送他们的内容,而我们用户只需要将频率调成和广播电台的一样就可以收听他们的内容了.Android中的广播机制就和这个差不多的道理. 电台发送的内容是语音,而在Andr

Android service 服务

Android的服务: 1:已启动方式: startService()和bindService(): startService:启动后,如果Activity关闭了,服务依然运行,除非stopService: bindService:创建开启服务器,但是在程序关闭的时候,会自动关闭服务: 通过ServiceConnectionjava接口获取service的IBinder接口: 2:控制服务(绑定服务): (1)但是上述两个方式都是通过Intent创建启动服务的,没有通过new,所以没有直接控制s