Use of Content Observer in Android

Reproduced from: http://blog.csdn.net/qinjuning

Preface: In work, you need to open a thread to query a large number of one data base The value sent a change, resulting in a large overhead, and later under the guidance of the boss, the use of

ContentObserver solved the problem perfectly and was very excited. After that, I also summarized the ContentObserver.

Content Observer - Content Observer, which is designed to observe (capture) specific Uri-induced data base Change, and then do some corresponding processing, it is similar to

Trigger in database technology triggers when the Uri observed by ContentObserver changes. Triggers are divided into table triggers and row triggers.

Accordingly, ContentObserver is also divided into "Table ContentObserver" and "Row" ContentObserver, which is related to the Uri MIME Type it monitors.

Familiar with Content Provider, you should know that we can register different types of Uri through the UriMatcher class, and we can use these different types of Uri.

Uri queries for different results. According to the results returned by Uri, Uri Type can be divided into Uri that returns multiple data and Uri that returns single data.

Register/unregister the ContentObserver method, and the method prototype in the abstract class ContentResolver is as follows:

public final void registerContentObserver(Uri uri, boolean notifyForDescendents, ContentObserver observer)

Function: Register a ContentObserver derived class instance for the specified Uri and call back the instance object to process when the given Uri changes.

Parameter: uri) Uri that needs to be observed (registration in UriMatcher, otherwise the Uri is meaningless)

Notfy ForDescendents represents an exact match for false, that is, only the Uri is matched.

For true, it means that it can match its derived Uri at the same time. Examples are as follows:

Assume that Uri registered in UriMatcher has one type:

content://com.qin.cb/student

2 ,content://com.qin.cb/student/#

Content://com.qin.cb/student/schoolchild

Assume that the Uri we need to observe is content://com.qin.cb/student, and if there is a change in data, the Uri is content://com.qin.cb/student.

content://com.qin.cb/student/schoolchild, when notify ForDescendents is false, the ContentObserver will not listen.

However, when notify ForDescendents is ture, it can capture the database changes of the Uri.

Derived class instance of ContentObserver

public final void unregisterContentObserver(ContentObserver observer)

Function: Cancel observation of a given Uri

Parameter: Derived class instance of observer ContentObserver

Introduction to ContentObserver Class

Construction method public void ContentObserver(Handler handler)

Description: All derived classes of ContentObserver need to call this constructor

Parameters:handler Handler object. It could be the main thread Handler (at which point the UI can be updated) It can also be any Handler object.

Common methods

void onChange(boolean selfChange)

Function: Callback the method to process the observed Uri changes. All derived classes of ContentObserver need to overload the method to process the logic.

Parameter: After selfChange callback, its value is generally false, which means little (I don't know, understanding the method is the most important).

The other two methods are not very useful, and I don't understand them either. You can understand them by referring to SDK, presumptuously.

boolean deliverSelfNotifications()

Note: Returns true if this observer is interested in notifications for changes made through the cursor the observer is registered with.

final void dispatchChange(boolean selfChange)

The steps to observe a particular Uri are as follows:

Create our specific ContentObserver Derived classes must overload the parent construction method and onChange() method to handle the function implementation after callback

2. Use context.getContentResolover() to get the ContentResolove object, and then call registerContentObserver() method to register the content observer.

3. Because the life cycle of ContentObserver is not synchronized with Activity and Service, manual calls are required when not needed.

unregisterContentObserver() to cancel registration.

Okay, here's the basic explanation. A brief description of the small DEMO is given below.

There are two different ContentObserver derived classes in Demo, as follows:

1. Used to observe whether the system has changed Flight mode status，

PS: You can go to the SDK to see this type: Android provider.Settings.System. This class encapsulates access to all values under the settings module, such as:

Flight mode status, Bluetooth status, screen brightness values, etc., and the corresponding Uri is provided.

2. The short message data of the observation system has changed. When monitoring the change of short message data, query all sent short messages and display them.

There are several types of Uri for short messages:

content://sms/inbox Inbox
Content://sms/send) has been sent
Draft content://sms/draft)
content://sms/outbox Outbox Outbox (message being sent)
content://sms/failed Send Failure
content://sms/queued (e.g. when flying mode is turned on, the text message is in the waiting list)

For more information about SMS, you can refer to this blog:< android Medium Management Short Message>

When the flight mode is turned on and the text message is sent (note: use the Home key to exit, not the Back key), the DMEO screenshot is as follows:

The DEMO file is as follows:

1. ContentObserver derived from observing flight mode status, AirplaneContentObserver. Java

[java] view plain copy

print?

package com.qin.contentobserver;



import android.content.Context;

import android.database.ContentObserver;

import android.net.Uri;

import android.os.Handler;

import android.provider.*;

import android.provider.Settings.SettingNotFoundException;

import android.util.Log;





//Used to observe whether the row of flight mode in the system table has changed, the "row" content observer

public class AirplaneContentObserver extends ContentObserver {



    private static String TAG = "AirplaneContentObserver" ;



    private static int MSG_AIRPLANE = 1 ;



    private Context mContext;

    private Handler mHandler ;  //This Handler is used to update UI threads



    public AirplaneContentObserver(Context context, Handler handler) {

        super(handler);

        mContext = context;

        mHandler = handler ;

    }



    /**

     * This method is called back when the monitored Uri changes

     *

     * @param selfChange This value does not make much sense. Normally, the callback value is false.

     */

    @Override

    public void onChange(boolean selfChange) {

        Log.i(TAG, "————-the airplane mode has changed————-");



        //Is the system in flight mode?

        try {

            int isAirplaneOpen = Settings.System.getInt(mContext.getContentResolver(), Settings.System.AIRPLANE_MODE_ON);

            Log.i(TAG, " isAirplaneOpen —–> " +isAirplaneOpen) ;

            mHandler.obtainMessage(MSG_AIRPLANE,isAirplaneOpen).sendToTarget() ;

        }

        catch (SettingNotFoundException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }



    }



}

2. ContentObserver derived class, SMS ContentObserver, which observes the database changes of short messages in the system. Java

[java] view plain copy

print?

package com.qin.contentobserver;



import android.content.Context;

import android.database.ContentObserver;

import android.database.Cursor;

import android.net.Uri;

import android.os.Handler;

import android.util.Log;





//Content Observer Derivative Class is triggered by the Content Observer Content Observer as long as the information database changes.

public class SMSContentObserver extends ContentObserver {

    private static String TAG = "SMSContentObserver";



    private int MSG_OUTBOXCONTENT = 2 ;



    private Context mContext  ;

    private Handler mHandler ;   //Update UI threads



    public SMSContentObserver(Context context,Handler handler) {

        super(handler);

        mContext = context ;

        mHandler = handler ;

    }

    /**

     * This method is called back when the monitored Uri changes

     *

     * @param selfChange  This value does not make much sense. Normally, the callback value is false.

     */

    @Override

    public void onChange(boolean selfChange){

        Log.i(TAG, "the sms table has changed");



        //Query the contents of the inbox.

        Uri outSMSUri = Uri.parse("content://sms/sent") ;



        Cursor c = mContext.getContentResolver().query(outSMSUri, null, null, null,"date desc");

        if(c != null){



            Log.i(TAG, "the number of send is"+c.getCount()) ;



            StringBuilder sb = new StringBuilder() ;

            //Cyclic traversal

            while(c.moveToNext()){

//sb.append("Sender's mobile phone number:" +c. getInt (c. getColumn Index ("address")))

//Appnd ("Information Content:" +c. getInt (c. getColumn Index ("body")))

//Appnd ("Check it or not"+c.getInt (c.getColumn Index ("read")))

//Appnd ("Delivery time:"+c. getInt (c. getColumn Index ("date")))

//                .append("\n");

                sb.append("Sender's cell phone number: "+c.getInt(c.getColumnIndex("address")))

                  .append("information content: "+c.getString(c.getColumnIndex("body")))

                  .append("\n");

            }

            c.close();

            mHandler.obtainMessage(MSG_OUTBOXCONTENT, sb.toString()).sendToTarget();

        }

    }



}

3. The main engineering logic is MainActivity.java. Uri, the observation of short messages, passes through test I found that only this Uri could be monitored. "Content://sms" (equivalent to "content://sms/"), but can not listen to other Uri, such as "content://sms/outbox" and so on.

[java] view plain copy

print?

package com.qin.contentobserver;



import android.app.Activity;

import android.database.Cursor;

import android.net.Uri;

import android.os.Bundle;

import android.os.Handler;

import android.os.Message;

import android.provider.*;

import android.util.Log;

import android.widget.EditText;

import android.widget.TextView;



public class MainActivity extends Activity {



    private TextView tvAirplane;

    private EditText etSmsoutbox;



    //Message type value

    private static final int MSG_AIRPLANE = 1;

    private static final int MSG_OUTBOXCONTENT = 2;



    private AirplaneContentObserver airplaneCO;

    private SMSContentObserver smsContentObserver;



    /** Called when the activity is first created. */

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);



        tvAirplane = (TextView) findViewById(R.id.tvAirplane);

        etSmsoutbox = (EditText) findViewById(R.id.smsoutboxContent);



        //Create two objects

        airplaneCO = new AirplaneContentObserver(this, mHandler);

        smsContentObserver = new SMSContentObserver(this, mHandler);



        //Registered Content Observer

        registerContentObservers() ;

    }



    private void registerContentObservers() {

        //Get the Uri of the row of "flight mode" in the system table by calling getUriFor method

        Uri airplaneUri = Settings.System.getUriFor(Settings.System.AIRPLANE_MODE_ON);

        //Registered Content Observer

        getContentResolver().registerContentObserver(airplaneUri, false, airplaneCO);

        //” Table "Content observer, through testing I found that only this Uri -> content://sms can be monitored

        //You can't listen to other Uri, such as content://sms/outbox

        Uri smsUri = Uri.parse("content://sms");

        getContentResolver().registerContentObserver(smsUri, true,smsContentObserver);

    }



    private Handler mHandler = new Handler() {



        public void handleMessage(Message msg) {



            System.out.println("—mHanlder—-");

            switch (msg.what) {

            case MSG_AIRPLANE:

                int isAirplaneOpen = (Integer) msg.obj;

                if (isAirplaneOpen != 0)

                    tvAirplane.setText("Flight mode turned on");

                else if (isAirplaneOpen == 0)

                    tvAirplane.setText("Flight mode closed");

                break;

            case MSG_OUTBOXCONTENT:

                String outbox = (String) msg.obj;

                etSmsoutbox.setText(outbox);

                break;

            default:

                break;

            }

        }

    };

}

On this basis, you can use ContentObserver to achieve SMS blacklisting and smuggling skills, specific reference to this blog:

Summary: There are two main cases of using ContentObserver:

1. It is not economical and time-consuming to use threads to operate a database or data that needs frequent detection.

2. Do some things to the database without the user's knowledge, such as sending information quietly, refusing to accept short message blacklist, etc.

In both cases, using ContentObserver is undoubtedly the best edge.

The code download address is: http://download.csdn.net/detail/qinjuning/3896987

///////////////////////////////////////////////////////////////////////////////////////

// Important Supplement - > Description of ContentObserver Monitoring Principle

///////////////////////////////////////////////////////////////////////////////////////

Update (2012-05-4, today I gave the framework of ContentProvider a walk, add the following knowledge points):

Why do data changes call back to ContentObserver? Why did our custom ContentProvider data source change?

Later, no response was monitored. ? This is related to the system's callback system logic.

After each ContentProvider data source changes, if you want to notify its listener, such as ContentObserver, you must have its corresponding method update /

When insert / delete, the call this.getContentReslover (). notifychange(uri) is displayed Null method, callback listens for processing logic. Otherwise, we

Content Observer does not monitor data changes. Specific principles, you can refer to Lao Luo's article:

<Android Application Component Content Provider's Shared Data Update Notification Mechanism

PS: Lao Luo's analysis of ContentProvider's principle is still very powerful. We can take a look at the old Luo series carefully and follow the source code carefully.

Additionally, it is strongly recommended that the content Observer object be constructed by passing the Hadler where the main thread is located, as follows:

[java] view plain copy

print?

airplaneCO = new AirplaneContentObserver(this, mHandler); //mHandler is a Handler object for UI threads

Otherwise, an exception may be reported when updating the UI (Security Exception when a non-UI thread updates the UI). System-level processes can lead to

Restart your cell phone. Or in the onChange() method, use the Handler class correlation method to call back to the UI thread to update the UI view.

Posted by ruach on Fri, 12 Apr 2019 18:30:34 -0700

Programmer Group

Use of Content Observer in Android

Hot Keywords