Android Service与Activity的交互

最新推荐文章于 2020-04-24 10:12:03 发布
最新推荐文章于 2020-04-24 10:12:03 发布
阅读量223 收藏 1
点赞数
CC 4.0 BY-SA版权
文章标签： 移动开发 ui
原文链接：http://www.cnblogs.com/kkrs/p/10172331.html
本文深入探讨了Android中Service与Activity间通信的三种方法：接口回调、广播和观察者模式，详细解析了每种方法的实现过程及应用场景。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Android中有时候需要在Service中改变Activity的UI，或者在Activity中修改Service中的数值。首先必须使用与Activity绑定的Service，有三种方式可以实现。第一，是使用接口回调的方式在Activty中实现Service中的接口；第二，使用广播的方式传递；第三，则是用观察者模式，在Activity中实现update方法。

使用接口回调的方式在Activty中实现Service中的接口

package com.kkrs.serivce;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.util.Log;

/**
 * Created by zd on 2018/12/20.
 */

//绑定的service
public class LocalService extends Service {

    private final static String TAG = "LocalService";
    private int count;
    private boolean quit;
    private Thread thread;
    private LocalBinder binder = new LocalBinder();


    /**
     * 回调
     */
    private Callback callback;

    /**
     * 提供接口回调方法
     * @param callback
     */
    public void setCallback(Callback callback) {
        this.callback = callback;
    }


    /**
     * 回调接口
     *
     * @author lenovo
     *
     */
    public static interface Callback {
        /**
         * 得到实时更新的数据
         *
         * @return
         */
        void getNum(int num);
    }


    @Override
    public void onCreate() {
        super.onCreate();
        Log.e(TAG, "Service is invoke Created");
        thread = new Thread(new Runnable() {
            @Override
            public void run() {
                // 每间隔一秒count加1 ，直到quit为true。
                while (!quit) {
                    try {
                        Thread.sleep(1000);

                        if(callback!=null){
                /*
                 * 得到最新数据
                 */
                            callback.getNum(count);
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count++;
                }
            }
        });
        thread.start();
    }

    public class LocalBinder extends Binder {
        // 声明一个方法，getService。（提供给客户端调用）
        LocalService getService() {
            // 返回当前对象LocalService,这样我们就可在客户端端调用Service的公共方法了
            return LocalService.this;
        }
    }

    /**
     * 公共方法
     * @return
     */
    public int getCount(){
        return count;
    }

    @Override
    public void onDestroy() {
        Log.e(TAG, "Service is onDestroy");

        this.quit = true;
        super.onDestroy();
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.e(TAG, "Service is onUnbind");
        return super.onUnbind(intent);
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.e(TAG, "Service is onBind");

        return binder;
    }
}

　　

   private ServiceConnection conn;
    private LocalService mService;
  @Override
    protected void onCreate(Bundle savedInstanceState) {
    
 conn = new ServiceConnection() {
            /**
             * 与服务器端交互的接口方法 绑定服务的时候被回调，在这个方法获取绑定Service传递过来的IBinder对象，
             * 通过这个IBinder对象，实现宿主和Service的交互。
             */
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                Log.e("MainActivity", "绑定成功调用：onServiceConnected");
                // 获取Binder
                LocalService.LocalBinder binder = (LocalService.LocalBinder) service;
                mService = binder.getService();
                mService.setCallback(new LocalService.Callback(){

                    @Override
                    public void getNum(int num) {
                        // TODO Auto-generated method stub
                        Log.e("num","====num===="+num);
                    }
                });
            }
            /**
             * 当取消绑定的时候被回调。但正常情况下是不被调用的，它的调用时机是当Service服务被意外销毁时，
             * 例如内存的资源不足时这个方法才被自动调用。
             */
            @Override
            public void onServiceDisconnected(ComponentName name) {
                mService=null;
            }
        };

        final Intent intent = new Intent(this, LocalService.class);

        btnBind.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Log.e("MainActivity", "绑定调用：bindService");

                bindService(intent, conn, Service.BIND_AUTO_CREATE);

            }
        });

        btnUnBind.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                // 解除绑定
                Log.e("MainActivity", "解除绑定：bindService");

                if(mService!=null) {
                    Log.e("MainActivity", "mService!=null");
                    mService = null;
                    unbindService(conn);
                }
            }
        });


        btnGetDatas.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if (mService != null) {
                    // 通过绑定服务传递的Binder对象，获取Service暴露出来的数据
                    Log.e("MainActivity", "从服务端获取数据：" + mService.getCount());
                } else {

                    Log.e("MainActivity", "还没绑定呢，先绑定,无法从服务端获取数据");
                }
            }
        });

}

　　使用广播的方式传递

package com.kkrs.serivce;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;

import static android.content.ContentValues.TAG;

/**
 * Created by zd on 2018/12/25.
 */

public class ContentService extends Service {

    private Thread thread;

    private boolean flag = true;

    @Override
    public IBinder onBind(Intent arg0) {
        // TODO Auto-generated method stub
        flag = true;
        return new LocalBinder();
    }

    @Override
    public void onCreate() {
        // TODO Auto-generated method stub
        super.onCreate();
        Log.e(TAG, "Service is invoke Created");
        thread = new Thread(new Runnable() {
            @Override
            public void run() {
                // 每间隔一秒count加1 ，直到quit为true。
                while (flag) {
                    try {
                        Thread.sleep(1000);
                        asyncSendPerson("ContentService");

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        thread.start();

    }

    public final class LocalBinder extends Binder {
        public ContentService getService() {
            return ContentService.this;
        }
    }

    public void asyncSendPerson(final String name) {
        // 休息5秒，模拟异步任务
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //可以在子线程中直接发送广播
                sendContentBroadcast(name);
            }
        }).start();
    }

    /**
     * 发送广播
     * @param name
     */
    protected void sendContentBroadcast(String name) {
        // TODO Auto-generated method stub
        Intent intent=new Intent();
        intent.setAction("com.example.servicecallback.content");
        intent.putExtra("name", name);
        sendBroadcast(intent);
    }

}

　　

 //广播

    private ServiceReConn connRe;
    private ContentReceiver mReceiver;

    public class ServiceReConn implements ServiceConnection {

        @Override
        public void onServiceConnected(ComponentName name, IBinder binder) {
            // service = ((LocalBinder) binder).getService();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            // TODO Auto-generated method stub
            // service = null;
        }
    }

    public class ContentReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            String name = intent.getStringExtra("name");
            Person person = new Person();
            person.setName(name);
            Log.e("ContentReceiver",person.toString());
        }
    }

    /**
     * 注册广播接收者
     */
    private void doRegisterReceiver() {
        mReceiver=new ContentReceiver();
        IntentFilter filter = new IntentFilter(
                "com.example.servicecallback.content");
        registerReceiver(mReceiver, filter);
    }

　　观察者模式

public class ObserviceService extends Service {
    //被观察者
    private MyObservable mObservable;
    private Thread thread;
    private boolean flag = true;

    @Override
    public IBinder onBind(Intent arg0) {
        flag = true;
        return new LocalBinder();
    }

    @Override
    public void onCreate() {
        super.onCreate();
        mObservable = new MyObservable();
        thread = new Thread(new Runnable() {
            @Override
            public void run() {
                // 每间隔一秒count加1 ，直到quit为true。
                while (true) {
                    try {
                        Thread.sleep(1000);
                        asyncSendPerson("ObserviceService");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        });
        thread.start();
    }

    public final class LocalBinder extends Binder {
        public ObserviceService getService() {
            return ObserviceService.this;
        }
    }

    public void asyncSendPerson(final String name) {
        // 休息5秒，模拟异步任务
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                handler.sendMessage(handler.obtainMessage(0, name));
            }
        }).start();
    }

    /**
     * 添加观察者
     * @param observer
     */
    public void addObserver(Observer observer) {
        mObservable.addObserver(observer);
    }

    private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            String name = (String) msg.obj;
            Person person = new Person();
            person.setName(name);
            //通知更新
            mObservable.notifyChanged(person);
        }
    };

    public class MyObservable extends Observable {

        public void notifyChanged(Object object) {
            this.setChanged();
            this.notifyObservers(object);
        }
    }

    @Override
    public boolean onUnbind(Intent intent) {
        flag = false;
        return super.onUnbind(intent);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        flag = false;
    }
}

　实现Observer

private ServiceConnection conn;
    private LocalService mService;


    //观察这模式
    private MyServiceConn connOb;
    private ObserviceService observiceService;
    public class MyServiceConn implements ServiceConnection {

        @Override
        public void onServiceConnected(ComponentName name, IBinder binder) {
            observiceService = ((ObserviceService.LocalBinder) binder).getService();
            //将当前activity添加为观察者
            observiceService.addObserver(MainActivity.this);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            observiceService = null;
        }
    }

    @Override
    public void update(Observable observable, Object o) {
        Log.e("update","观察这模式在这里修改UI");
        Person person = (Person) o;
        Log.e("update",person.toString());
    }


@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    context = this;
    setContentView(R.layout.activity_main);
    btnBindOb  = (Button)findViewById(R.id.btnBindOb);
    btnUnBindOb  = (Button)findViewById(R.id.btnUnBindOb);


    final Intent obIntent = new Intent(context, ObserviceService.class);
    connOb = new MyServiceConn();
    btnBindOb.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            bindService(obIntent, connOb, Service.BIND_AUTO_CREATE);

        }
    });

    btnUnBindOb.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            if(observiceService!=null) {
                Log.e("MainActivity", "observiceService!=null");
                observiceService = null;
                unbindService(connOb);
            }
        }
    });

}

　　

转载于:https://www.cnblogs.com/kkrs/p/10172331.html

android service交互,Android Activity与Service的交互方式
weixin_33190667的博客
05-27 1118
参考:http://blog.youkuaiyun.com/gebitan505/article/details/18151203实现更新下载进度的功能1. 通过广播交互Server端将目前的下载进度，通过广播的方式发送出来，Client端注册此广播的监听器，当获取到该广播后，将广播中当前的下载进度解析出来并更新到界面上。优缺点分析:通过广播的方式实现Activity与Service的交互操作简单且容易实现...
浅谈Android Activity与Service的交互方式
01-20
实现更新下载进度的功能 1. 通过广播交互 Server端将目前的下载进度，通过广播的方式发送出来，Client端注册此广播的监听器，当获取到该广播后，将广播中当前的下载进度解析出来并更新到界面上。 优缺点分析： 通过广播的方式实现Activity与Service的交互操作简单且容易实现，可以胜任简单级的应用。但缺点也十分明显，发送广播受到系统制约。系统会优先发送系统级广播，在某些特定的情况下，我们自定义的广播可能会延迟。同时在广播接收器中不能处理长耗时操作，否则系统会出现ANR即应用程序无响应 2. 共享文件交互 这里提到的共享文件指的是Activity和Service使用同一个文件来达到
Service和Activity之间的交互
Android
09-27 892
本地服务的交互 1.通过发送广播的方式进行消息传递 实现原理：    server端当有内容需要传递时，可以发送一条广播，而client端可以注册一个广播接收者去接收广播信息，    根据内容做相关的操作。 小结：    通过广播的方式来实现activity和service的交互是非常简单而且容易实现的，一般可以胜任轻量级的应用。  它的缺点也比较明显，发送的广播会受到系统的制约，系
Android Activity与Service的交互方式
weixin_33843409的博客
11-08 388
参考: http://blog.youkuaiyun.com/gebitan505/article/details/18151203   实现更新下载进度的功能   1. 通过广播交互  Server端将目前的下载进度，通过广播的方式发送出来，Client端注册此广播的监听器，当获取到该广播后，将广播中当前的下载进度解析出来并更新到界面上。 优缺点分析:     通过广播的方式实现Activ...
android activity和service的交互介绍
热门推荐
03-03 2万+
android开发中,实现activity和service的相互交互
Android 丨 Service与Activity的信息交互
听说android还不错。。
01-21 589
Android中信息交互大致有两种方式: 1.使用intent在service和activity之间不停地传递信息 2.使用bindService实现,这里有两种实现方式,在重写service当中的onBind方法是,一种方式是通过实现一个Binder接口,通过在这个接口中的实现一个getService方法返回service.this实现,另一种方法是使用aidl这种接口
Android Service与Activity交互
11-03
本示例"Android Service与Activity交互"旨在演示如何在Service启动后，通过线程进行异步操作，并在完成特定任务后，通过发送广播（Broadcast）通知Activity来更新用户界面。 首先，我们需要创建一个Service，通常在...
Android Activity 与Service进行数据交互详解
09-01
总结来说，理解Activity与Service的数据交互机制是Android开发中的重要技能。通过bindService，我们可以创建强大的、动态的数据同步机制，使得后台任务与用户界面能够无缝协作，提升用户体验。同时，正确地管理...
Android中Service与Activity之间通信的几种方式
08-31
在Android应用开发中，Service与Activity之间的通信是一个重要的主题，因为它们各自承担着不同的职责：Activity作为用户界面的载体，Service则用于执行后台任务。在本文中，我们将深入探讨两种常见的Service与...
android中activity和service的交互
03-03
一个很完整的activity和service的相互交互例子
activity service 数据交互
06-13
这个是我在网上看到一篇文章，作者给出了activity和service交互的代码，但是还是很多人找作者要，我觉得有代码很好，写写增加记忆，这里有吧我写的拿出来与大家分享下！！
利用BroadcastReceiver，使Service与Activity数据交互。
02-06 1232
最近在学习做个小demo，需要用到Service与Activity交互，经过上网和看书了解可以利用广播也就是 BroadcastReceive让Service与Activity交互数据。 这里我就是用GPS定位的demo举例。 //首先看Activity的类public class MainActivity extends Activity { private TextView Lati
Activity和Service的交互方式
zh175578809的博客
06-04 1万+
在开发过程中，经常会遇到Activity和Service进行相互通信、交换数据的需要，最常见的比如音乐播放器，使用Service在后台进行音乐播放，前台使用Activity显示界面，点击前台控件后需要告知Service，控制音乐的播放、暂停、切换下一首等，后台Service再将数据传给Activity来改变界面显示Activity和Service的交互方式主要有以下几种 通过广播进行交互 通过共享文
Service与Activity之间的数据传递
编程菜鸟进阶之路
09-15 7546
Service启动和数据传递 转自：http://www.cnblogs.com/blogljj/p/5067696.html Service是四大组件之一，Service是服务的意思，像Windows上面的服务一样，服务是在后台运行的，承担着静悄悄，默默的在后台付出的工作。 在开发过程中Service可以在很多地方使用，比如播放多媒体的时候用户启动了其他Activity ，这个
安卓Service组件使用系列5：service和activity之间的数据交互
luoshiwutai的博客
03-08 2554
service和activity之间的数据交互 (从activity传数据给service，又从service传数据给activity)，这样的使用在android开发中是比较有深度的使用方式。下面我们就来介绍一下它的使用。 整体思路：在xml文件中放置一个TextView控件，三个Button控件，定义一个MyService类，继承Service，在onBind方法中返回LocalBinder
Android中Service与Activity数据交互的简单理解
a516972602的博客
12-28 4045
Service跟Activity是最相似的组件，都代表可执行的程序，区别在于：Service一直在后台运行，没有跟用户交互的界面。 启动与停止Service有两种方法： 第一种通过startService()与stopService()启动和停止服务，Service与启动它的Activity无法进行通信和数据交换 第二种通过bindService()与unbindService()启动和停止服
Service 的两种启动方式和「Service 与 Activity 数据交互」
lk_123456的专栏
04-24 704
1. Service 的两种启动方式 Activity 中可以有两种方式启动 Service，不同方式启动时 Service 的生命周期也不一样，现在在 Activity 中定义四个 Button，分别是 startService、stopService、bindService、unbindService，Service 中各生命周期中分别打印 Log 日志，通过日志查看生命周期执行情况： // ...
Android Service与Activity交互完整示例
- **Activity**: Activity是Android应用中的一个基本单元，代表了用户与应用交互的一个界面。它有自己的生命周期，包括创建、启动、运行、暂停、恢复和销毁等。每个Activity通常都包含一个用户界面，展示给用户进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值