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原則和常用設計原則，高內聚、低偶合。