androidobserver

㈠ 观察者模式 在android中什么时候会用到

android中注册短信和联系人的变更,就会用到观察者模式
通过ContentProvider注册一个observer实现的

㈡ android packageinstallobserver为什么没这个类

java">.Stub{
publicvoidpackageInstalled(StringpackageName,intreturnCode){
Messagemsg=mHandler.obtainMessage(INSTALL_COMPLETE);
msg.arg1=returnCode;
mHandler.sendMessage(msg);
}
};

你看看这里，地址：http://blog.csdn.net/connectionutils/article/details/8224179 《求不封》

求采纳

㈢ android 数据库怎么监听数据变化

在android中经常会用到改变数据库内容后再去使用数据库更新的内容，很多人会重新去query一遍，但是这样的问题就是程序会特别占内存，而且有可能会搂关cursor而导致程序内存未释放等等。其实android内部提供了一种ContentObserver的东西来监听数据库内容的变化。
ContentObserver的构造函数需要一个参数Hanlder，因为ContentObserver内部使用了一个实现Runnable接口的内部类NotificationRunnable，来实现数据库内容的变化。需要使用hanlder去post消息。注册ContentObserver的方法是：getContentResolver().registerContentObserver(uri, notifyForDescendents, observer).
上面3个参数为：uri----Uri类型，是需要监听的数据库的uri.
notifyForDescendents---boolean true的话就会监听所有与此uri相关的uri。false的话则是直接特殊的uri才会监听。一般都设置为true.
observer-----ContentObserver 就是需要的contentobserver.
初始化一个ContentObserver对象，重载onChange(boolean ),在这个方法里去操作数据库的使用，针对变化后的使用。

㈣ android中获得控件的位置(相对于布局文件)

正确的代码如下所示

TextViewtv=(TextView)findViewById(R.id.text);
tv.getViewTreeObserver().addOnGlobalLayoutListener(newOnGlobalLayoutListener(){
@Override
publicvoidonGlobalLayout(){
//这里执行获取位置大小操作
intleft=tv.getLeft();
inttop=tv.getTop();
intbottom=tv.getBottom();
intright=tv.getRight();
//tv相对于父布局的坐标就得出来了

}
}

view的位置和大小是通过onLayout和onMeasure方法计算出来的，执行到activity的onCreate()方法时，尚未开始计算控件的大小和位置，所以是取不到的

OnGlobalLayoutListener 是ViewTreeObserver的内部类，当一个视图树的布局发生改变时，可以被ViewTreeObserver监听到，这是一个注册监听视图树的观察者(observer)，在视图树的全局事件改变时得到通知

除了OnGlobalLayoutListener ，ViewTreeObserver还有如下内部类：

interfaceViewTreeObserver.OnGlobalFocusChangeListener

当在一个视图树中的焦点状态发生改变时，所要调用的回调函数的接口类

interfaceViewTreeObserver.OnGlobalLayoutListener

当在一个视图树中全局布局发生改变或者视图树中的某个视图的可视状态发生改变时，所要调用的回调函数的接口类

interfaceViewTreeObserver.OnPreDrawListener

当一个视图树将要绘制时，所要调用的回调函数的接口类

interfaceViewTreeObserver.OnScrollChangedListener

当一个视图树中的一些组件发生滚动时，所要调用的回调函数的接口类

interfaceViewTreeObserver.OnTouchModeChangeListener

当一个视图树的触摸模式发生改变时，所要调用的回调函数的接口类

㈤ android 7.0 smsobserver有的手机可以自动填写有的不行为什么

一般自动重启是正常的，安卓手机都有这毛病，但如果过于频繁，就有可能是装的软件不对，或者设置上有问题，想想是装了哪个软件以后出现问题的，卸载了它，或者格十化内存卡，如果你觉得软件没问题，就恢复一下出厂设置 刚买了什么都没干就一直重启，你有可能买到了翻新机，上论坛查帖子检验一下 希望能帮上你

㈥ 安卓rxjava怎么将实体类转换为observer

在开始说代码之前，先澄清几个概念。RxJava最核心的东西就是Observable和Observer。Observable会发出数据，而与之相对的Observer则会通过订阅Observable来进行观察。Observer可以在Observable发出数据、报错或者声明没有数据可以发送时进行相应的操作。这三个操作被封装在Observer接口中，相应的方法为onNext()，onError()和onCompleted()。明确了这些概念以后，让我们来看一些例子。

㈦ Android中有没有对多个对象的监听方法，就像观察者模式一样

Android
中的监听器模式与观察者模式

1、 观察者模式与监听器机制

1.1 观察者模式

1.2 监听器（Listener）机制

代码的基本框架：

* 被监控着

package com.wonders.group;

import java.util.Collection;

public class ModelTie {

private Collection<Object> dataSet;

public interface DataSetSupervioer {

public void onChange();

}

private DataSetSupervioer dataSetChangeListener;

public void setDataSetChangeListener(DataSetSupervioer
dataSetChangeListener) {

this.dataSetChangeListener = dataSetChangeListener;

}

public void notifyDataSetChange() {

if (null != dataSetChangeListener) {

dataSetChangeListener.onChange();

}

}

public Collection<Object> getDataSet() {

return dataSet;

}

public ModelTie setDataSet(Collection<Object> dataSet)
{

this.dataSet = dataSet;

this.notifyDataSetChange(); // 数据设置完毕要通知监听器进行更新操作

return this;

}

}

* 监控者

package com.wonders.group;

import java.util.Collection;

import java.util.Iterator;

import com.wonders.group.ModelTie.DataSetSupervioer;

public class PresentationTie {

private ModelTie model;

public PresentationTie() {

super();

// 添加监听器

model.setDataSetChangeListener(new DataSetSupervioer()
{

public void onChange() {

// 填写一些前置操作，如更新数据

DisplayModel(); // 重新绘制

// 填写一些后置操作，如更新状态

}

});

}

public void DisplayModel() {

Collection<Object> collection =
model.getDataSet();

if (collection != null) {

for (Iterator iterator = collection.iterator();
iterator.hasNext();) {

System.out.println(((Object)
iterator.next()).toString());

// 其他等等操作

}

}

}

public ModelTie getModel() {

return model;

}

public void setModel(ModelTie model) {

this.model = model;

}

}

2、
ArrayAdapter的观察者实现机制

以下仅罗列关键代码：

public class ArrayAdapter<T> extends BaseAdapter implements Filterable
{

private boolean mNotifyOnChange = true;

/**

* Adds the specified object at the end of the array.

*/

public void add(T object) {

if (mOriginalValues != null) {

synchronized (mLock) {

mOriginalValues.add(object);

if (mNotifyOnChange) notifyDataSetChanged();

}

} else {

mObjects.add(object);

if (mNotifyOnChange) notifyDataSetChanged();

}

}

/**

* Inserts the specified object at the specified index in the
array.

*/

public void insert(T object, int index) {

if (mOriginalValues != null) {

synchronized (mLock) {

mOriginalValues.add(index, object);

if (mNotifyOnChange) notifyDataSetChanged();

}

} else {

mObjects.add(index, object);

if (mNotifyOnChange) notifyDataSetChanged();

}

}

/**

* Removes the specified object from the array.

*/

public void remove(T object) {

if (mOriginalValues != null) {

synchronized (mLock) {

mOriginalValues.remove(object);

}

} else {

mObjects.remove(object);

}

if (mNotifyOnChange) notifyDataSetChanged();

}

/**

* Remove all elements from the list.

*/

public void clear() {

if (mOriginalValues != null) {

synchronized (mLock) {

mOriginalValues.clear();

}

} else {

mObjects.clear();

}

if (mNotifyOnChange) notifyDataSetChanged();

}

/**

* Sorts the content of this adapter using the specified
comparator.

*/

public void sort(Comparator<? super T> comparator) {

Collections.sort(mObjects, comparator);

if (mNotifyOnChange) notifyDataSetChanged();

}

@Override

public void notifyDataSetChanged() {

super.notifyDataSetChanged(); //
关键代码，这个notifyDataSetChanged()是从父类BaseAdapter继承过来的，所以看看在父类中它干了些什么

mNotifyOnChange = true;

}

}

/**

* Common base class of common implementation for an {@link
Adapter} that can be

* used in both {@link ListView} (by implementing the
specialized

* {@link ListAdapter} interface} and {@link Spinner} (by
implementing the

* specialized {@link SpinnerAdapter} interface.

*/

public abstract class BaseAdapter implements ListAdapter,
SpinnerAdapter {

private final DataSetObservable mDataSetObservable = new
DataSetObservable();

public void registerDataSetObserver(DataSetObserver observer)
{

这对方法用来注册或注销

观察ArrayAdapter的观察者的

mDataSetObservable.registerObserver(observer);

}

public void unregisterDataSetObserver(DataSetObserver
observer) {

mDataSetObservable.unregisterObserver(observer);

}

/**

* Notifies the attached View that the underlying data has
been changed

* and it should refresh itself.

*/

public void notifyDataSetChanged() {

mDataSetObservable.notifyChanged(); //
关键代码：说明调的是成员变量mDataSetObservable的方法，所以进入DataSetObservable看看具体是如何操作的

}

public void notifyDataSetInvalidated() {

mDataSetObservable.notifyInvalidated();

}

}

package android.database;

/**

* A specialization of Observable for DataSetObserver that
provides methods for

* invoking the various callback methods of DataSetObserver.

*/

public class DataSetObservable extends
Observable<DataSetObserver> {

/**

* Invokes onChanged on each observer. Called when the data
set being observed has

* changed, and which when read contains the new state of the
data.

*/

public void notifyChanged() {

synchronized(mObservers) {

for (DataSetObserver observer : mObservers) { //
这里的mObservers是哪来的呢?继续追踪，但首先可以判断是来自Observable<DataSetObserver>的。进入看看

observer.onChanged();

}

}

}

/**

* Invokes onInvalidated on each observer. Called when the
data set being monitored

* has changed such that it is no longer valid.

*/

public void notifyInvalidated() {

synchronized (mObservers) {

for (DataSetObserver observer : mObservers) {

observer.onInvalidated();

}

}

}

}

public abstract class Observable<T> {

/**

* The list of observers. An observer can be in the list at
most

* once and will never be null.

*/

protected final ArrayList<T> mObservers = new
ArrayList<T>();

public void registerObserver(T observer) {

if (observer == null) {

throw new IllegalArgumentException("The observer is
null.");

}

synchronized(mObservers) {

if (mObservers.contains(observer)) {

throw new IllegalStateException("Observer " +
observer + " is already registered.");

}

mObservers.add(observer);

}

}

public void unregisterObserver(T observer) {

if (observer == null) {

throw new IllegalArgumentException("The observer is
null.");

}

synchronized(mObservers) {

int index = mObservers.indexOf(observer);

if (index == -1) {

throw new IllegalStateException("Observer " +
observer + " was not registered.");

}

mObservers.remove(index);

}

}

public void unregisterAll() {

synchronized(mObservers) {

mObservers.clear();

}

}

}

㈧ androidx.lifecycle 生命周期感知型组件实现原理

androidx.lifecycle 组件用来感知另一个组件如 Activity 和 Fragment 的生命周期变化，方便在生命周期变更时处理一些事情。

其逻辑简单来说就是：使用者向 LifecycleRegistry 注册一个 LifecycleObserver ，当 LifecycleOwner（一般由 Activity 和 Fragment 实现）发生生命周期变更时，将其变更的 STATE 通知给 LifecycleRegistry ，然后 LifecycleRegistry 将其变更的 EVENT 告知 LifecycleEventObserver ，LifecycleEventObserver 通过 Lifecycling 转换成用户注册的 LifecycleObserver 类型并回调。

可以看到这里面最有趣的就是 LifecycleObserver 的实现方式，这是本篇重点描述的内容。

整个 lifecylce 组件最有趣的实现应该就是这个 LifecycleObserver ，它是一个空接口。所有实现它的类最后会通过 Lifecycling 转换成它的一个已知实现类 LifecycleEventObserver 。

这个框架实现的核心。它定义了一个回调函数 onStateChanged(owner, event) 。

我们先回到 Lifecycle 及其实现类 LifecycleRegistry 。

Lifecycle 定义了 Lifecycle 的 STATE 和 EVENT 。

状态和 EVENT 和 Activity 及 Fragment 对应。初始状态为 INITIALIZED 和 DESTROYED ，定义从初始状态到 CREATED 再到 STARTED 再到 RESUMED 为状态上升，相反为状态下降。

Lifecycle 存储了 Activity 、Fragment 的生命周期状态，并方便其它对象跟踪。LifecycleRegistry 是其实现类，它允许多个对象同时跟踪生命周期状态（通过 LifecycleObserver）。

上面说到可以向 LifecycleRegistry 注册任意实现的 LifecycleObserver ，然后 LifecycleRegistry 会通过 Lifecycling 转换成 LifecycleEventObserver 去监听，说到变更时再转换回自定义 LifecycleObserver 中的回调方法。那么是怎么实现的呢？

这个框架中定义了两个实现方式，一种通过自定义的 adater ，另外一种为反射。

通过 adapter 的方法其实原理很简单，就是自定义 LifecycleObserver 时同时自定义一个 adapter ，这个 adapter 需要自己实现将 LifecycleEventObserver 中回调的状态转换成 observer 中回调的方法。

这个 adapter 需要在 LifecycleObserver 同级的 pkg 下面且名为 LifecycleAdapter ，其父类或其本身继承自 GeneratedAdapter ，并有构造函数 LifecycleAdapter(LifecyelObserver)。

Lifecycling 在转换时将为这种类型的 observer 创建一个 或 ，并传入自定义的 GeneratedAdapter 实现类。因为这个 XXXGeneratedAdapterObserver 实现了 LifecycleEventObserver ，所以在其收到 onStateChange 回调时只需调用 GeneratedAdapter #callMethods ，剩下交给 adapter 自己去实现状态与回调的转换。

如果不想自定义 GeneratedAdapter 的实现类可以吗，可以。这个框架还实现了反射回调机制。只要你在自定义 LifecycleObserver 时给回调函数加上 @OnLifecycleEvent(Lifecycle.Event xxx) 的注释，Lifecycling 会帮你创建一个 并传入 observer 对象，这个 实现 LifecycleEventObserver ，并通过反射机制取出并缓存所有按规则加上了 @OnLifecycleEvent 注释的方法，在收到 onStateChange 时取出对应 event 的反射方法，并回调。

可以看到其核心实现在 CallbackInfo ，其缓存了 observer 对象中的 [event, 反射方法 list] map ，在收到 lifecycle 变更时，取出对应 event 的所有反射方法 list 并回调就行。

Lifecycling 可以说是整个实现的精髓了，它在 LifecycleObserver 注册时将其转换成 LifecycleEventObserver 的 adapter 或 reflect 实现类。

一般来说，我们使用 LifecycleEventObserver 就行，虽然这个框架通过复杂的实现可以让你随意（其实还是有条件）的定义自己要的 LifecycleObserver ，但似乎也不是很有实际用途？

android developers：使用生命周期感知型组件处理生命周期

㈨ Android LiveData和MutableLiveData使用详解

参考链接：
https://blog.csdn.net/gtxiaoxu/article/details/86660760
https://www.cnblogs.com/guanxinjing/p/11544273.html

首先LiveData其实与数据实体类（Plain OrdinaryJava Object）是一样的东西,它负责暂存数据。其次LiveData也是一个观察者模式的数据实体类,它的观察者可以回调数据是否已经更新.

LiveData与MutableLiveData的其实在概念上是一模一样的，唯一几个的区别如下:

继承LiveData并且在泛型里写下你的实体类
postValue(this) 这个方法是用于回调数据更新的方法. 你可以在你需要被观察的数据里添加.

调用 ViewModelProvider of(@NonNull Fragment fragment, @Nullable Factory factory) 方法，只不过，需要多传递一个 factory 参数。
我们的做法是：实现 Factory 接口，重写 create 方法，在create 方法里面调用相应的构造函数，返回相应的实例。

MutableLiveData只是作用于变量所以我们直接就可以在ViewModel里实例化它,并且在泛型里标注变量的类型.

我们回过头来再来看一下 ViewModelProvider 的 of 方法，他主要有四个方法，分别是

1,2 方法之间的主要区别是传入 Fragment 或者 FragmentActivity。而我们知道，通过 ViewModel of 方法创建的 ViewModel 实例， 对于同一个 fragment 或者 fragmentActivity 实例，ViewModel 实例是相同的，因而我们可以利用该特点，在 Fragment 中创建 ViewModel 的时候，传入的是 Fragment 所依附的 Activity。因而他们的 ViewModel 实例是相同的，从而可以做到共享数据。

说到全局共享数据，我们想一下我们的应用全景，比如说我的账户数据，这个对于整个 App 来说，肯定是全局共享的。有时候，当我们的数据变化的时候，我们需要通知我们相应的界面，刷新 UI。如果用传统的方式来实现，那么我们一般才采取观察者的方式来实现，这样，当我们需要观察数据的时候，我们需要添加 observer，在界面销毁的时候，我们需要移除 observer。

但是，如果我们用 LiveData 来实现的话，它内部逻辑都帮我们封装好了，我们只需要保证LiveData 是单例的就ok，在需要观察的地方调用 observer 方法即可。也不需要手动移除 observer，不会发生内存泄漏，方便快捷。

postValue的特性如下：

setValue()的特性如下：

返回当前值。 注意，在后台线程上调用此方法并不能保证将接收到最新的值。

移除指定的观察者

如果此LiveData具有活动（Activity或者Fragment在前台,当前屏幕显示）的观察者，则返回true。其实如果这个数据的观察者在最前台就返回true，否则false。

当活动观察者的数量从0变为1时调用。这个回调可以用来知道这个LiveData正在被使用，因此应该保持最新。

当活动观察者的数量从1变为0时调用。即观察者的生命周期状态没有STARTED or RESUMED

如果此LiveData具有观察者，则返回true。

设置此LiveData数据当前activity或者Fragment的观察者，会给此activity或者Fragment在前台时回调数据。

移除当前Activity或者Fragment的全部观察者,在使用了observeForever 时调用，即监听了应用在前台状态时的LiveData值变化

㈩ android中观察者模式的应用场景是什么

你说的场景是符合这个模式的：
观察者模式的应用场景：
1、 对一个对象状态的更新，需要其他对象同步更新，而且其他对象的数量动态可变。
2、 对象仅需要将自己的更新通知给其他对象而不需要知道其他对象的细节。
观察者模式的优点：
1、 Subject和Observer之间是松偶合的，分别可以各自独立改变。
2、 Subject在发送广播通知的时候，无须指定具体的Observer，Observer可以自己决定是否要订阅Subject的通知。
3、 遵守大部分GRASP原则和常用设计原则，高内聚、低偶合。