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);
}
}
}); }

  

Android Service与Activity的交互的更多相关文章

  1. Android—Service与Activity的交互

    service-Android的四大组件之一.人称"后台服务"指其本身的运行并不依赖于用户可视的UI界面 实际开发中我们经常需要service和activity之间可以相互传递数据 ...

  2. Android Service 通知Activity更新界面的方法研究

    Android Service 通知Activity更新界面的方法研究   Android的最重要的组件式service和activity,那么在使用的过程中,我们最常遇到的问题是他们之间的通信问题. ...

  3. Android Service与Activity之间通信的几种方式

    在Android中,Activity主要负责前台页面的展示,Service主要负责需要长期运行的任务,所以在我们实际开发中,就会常常遇到Activity与Service之间的通信,我们一般在Activ ...

  4. Android:Service通知Activity更新界面

    Android有四大组件,其中包括service和activity,那么在使用的过程中,我们最常遇到的问题是他们之间的通信问题. 1.首先Activity调用Service 这个是比较基础的,它有两种 ...

  5. Android Service与Activity之间通信

    主要分为: 通过Binder对象 通过broadcast(广播)的形式 Activity调用bindService (Intent service, ServiceConnection conn, i ...

  6. Android Fragment和Activity的交互介绍

    Fragment和Activity的交互 一个Fragment的实例总是和包括它的Activity直接相关. fragment能够通过getActivity() 方法来获得Activity的实例.然后 ...

  7. android service和activity的通讯

    我们须要用下面方式来启动service: </pre><pre name="code" class="java"><span st ...

  8. Service 启动Activity

    1, 在BroadcastReceiver中启动Activity的问题  *  * 如果在BroadcastReceiver的onReceive()方法中如下启动一个Activity  * Inten ...

  9. android开发之使用Messenger实现service与activity交互

    service与activity交互的方式有多种,这里说说使用Messenger来实现两者之间的交互. Service程序 public class MessengerService extends ...

随机推荐

  1. Spring 的IOC和AOP总结

    Spring 的IOC和AOP IOC 1.IOC 许多应用都是通过彼此间的相互合作来实现业务逻辑的,如类A要调用类B的方法,以前我们都是在类A中,通过自身new一个类B,然后在调用类B的方法,现在我 ...

  2. Spring中的循环依赖

    循环依赖 在使用Spring时,如果主要采用基于构造器的依赖注入方式,则可能会遇到循环依赖的情况,简而言之就是Bean A的构造器依赖于Bean B,Bean B的构造器又依赖于Bean A.在这种情 ...

  3. MySQL中横表和竖表相互转换

    一  竖表转横表 1. 首先创建竖表 create table student ( id varchar(32) primary key, name varchar (50) not null, su ...

  4. jenkins在windows下的最快安装方法

    jenkins在windows下的安装 2016年04月21日 13:00:09 阅读数:22828 在初步了解了jenkins是什么?jenkins的特点.基本结构,及大概的功能介绍后,就开始对je ...

  5. 阅读GIC-500 Technical Reference Manual笔记

    GIC-500是ARM GICv3的一个实现,它只支持ARMv8核和实现了GIC Stream协议的GIC CPU Interface,比如Cortex-A53. 关于GIC有四份相关文档:<C ...

  6. Android开发——子进程更新UI

    方式一:Handler和Message ① 实例化一个Handler并重写handlerMessage()方法 private Handler handler = newHandler() { pub ...

  7. Java基础系列--冒泡排序

    原创作品,可以转载,但是请标注出处地址:https://www.cnblogs.com/V1haoge/p/9064218.html 1.算法简介 冒牌排序是很耳熟的排序方式,虽然它使用的很少,但是经 ...

  8. easyui下载包详解

    easyui包详解: 文件夹: demo--该目录下存放的是 EasyUI PC 版各插件的示例示例.如果不想在官网上查看演示,可以在该目录下找到相应的演示示例 demo-mobile--该目录下存放 ...

  9. Requests库作者另一神器Pipenv的用法

    前言 我们在运行 Python 项目的时候经常会遇到一些版本问题,例如 A 项目依赖于 Django 1.5,而 B 项目又依赖 Django 2.0,而我们的系统却只有一个 Python 解释器,我 ...

  10. mock打桩之EasyMock

    TDD是测试驱动开发(Test-Driven Development)的英文简称,是敏捷开发中的一项核心实践和技术,也是一种设计方法论.TDD的原理是在开发功能代码之前,先编写单元测试用例代码,测试代 ...