Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 60fb1dc7 authored by Brandon Maxwell's avatar Brandon Maxwell
Browse files

Updating AsyncQueryHandler with FilteredNumCompat 

+ FilteredNumberAsyncQueryHandler needs to make use of the
FilteredNumberCompat class to unsure that it is
blocking/unblocking/checking the proper solution, based on which is
enabled.

+ This CL updates the queryHandler to the FilteredNumberCompat class
for the hasBlockedNumbers, isBlockedNumber, and blockNumber
operations.

Bug=26664600

Change-Id: I5ecf6e340a97e94bf696a0e6c4a7e922b791a6f5
parent 9baf4e56

src/com/android/dialer/database/FilteredNumberAsyncQueryHandler.java

+34 −32
Original line number Diff line number Diff line
@@ -24,12 +24,13 @@ import android.database.Cursor; 
import android.database.DatabaseUtils;

import android.database.sqlite.SQLiteDatabaseCorruptException;

import android.net.Uri;

import android.support.annotation.Nullable;

import android.telephony.PhoneNumberUtils;

import android.text.TextUtils;



import com.android.dialer.compat.FilteredNumberCompat;

import com.android.dialer.database.FilteredNumberContract.FilteredNumber;

import com.android.dialer.database.FilteredNumberContract.FilteredNumberColumns;

import com.android.dialer.database.FilteredNumberContract.FilteredNumberSources;

import com.android.dialer.database.FilteredNumberContract.FilteredNumberTypes;



public class FilteredNumberAsyncQueryHandler extends AsyncQueryHandler {
@@ -58,7 +59,7 @@ public class FilteredNumberAsyncQueryHandler extends AsyncQueryHandler { 
         * Invoked after querying if a number is blocked.

         * @param id The ID of the row if blocked, null otherwise.

         */

        public void onCheckComplete(Integer id);

        void onCheckComplete(Integer id);

    }



    public interface OnBlockNumberListener {
@@ -66,7 +67,7 @@ public class FilteredNumberAsyncQueryHandler extends AsyncQueryHandler { 
         * Invoked after inserting a blocked number.

         * @param uri The uri of the newly created row.

         */

        public void onBlockComplete(Uri uri);

        void onBlockComplete(Uri uri);

    }



    public interface OnUnblockNumberListener {
@@ -75,7 +76,7 @@ public class FilteredNumberAsyncQueryHandler extends AsyncQueryHandler { 
         * @param rows The number of rows affected (expected value 1).

         * @param values The deleted data (used for restoration).

         */

        public void onUnblockComplete(int rows, ContentValues values);

        void onUnblockComplete(int rows, ContentValues values);

    }



    public interface OnHasBlockedNumbersListener {
@@ -83,7 +84,7 @@ public class FilteredNumberAsyncQueryHandler extends AsyncQueryHandler { 
         * @param hasBlockedNumbers {@code true} if any blocked numbers are stored.

         *     {@code false} otherwise.

         */

        public void onHasBlockedNumbers(boolean hasBlockedNumbers);

        void onHasBlockedNumbers(boolean hasBlockedNumbers);

    }



    @Override
@@ -123,6 +124,10 @@ public class FilteredNumberAsyncQueryHandler extends AsyncQueryHandler { 
    }



    public final void incrementFilteredCount(Integer id) {

        // No concept of counts with new filtering

        if (FilteredNumberCompat.useNewFiltering()) {

            return;

        }

        startUpdate(NO_TOKEN, null,

                ContentUris.withAppendedId(FilteredNumber.CONTENT_URI_INCREMENT_FILTERED_COUNT, id),

                null, null, null);
@@ -136,9 +141,10 @@ public class FilteredNumberAsyncQueryHandler extends AsyncQueryHandler { 
                        listener.onHasBlockedNumbers(cursor != null && cursor.getCount() > 0);

                    }

                },

                getContentUri(null),

                new String[]{ FilteredNumberColumns._ID },

                FilteredNumberColumns.TYPE + "=" + FilteredNumberTypes.BLOCKED_NUMBER,

                FilteredNumberCompat.getContentUri(null),

                new String[]{ FilteredNumberCompat.getIdColumnName() },

                FilteredNumberCompat.useNewFiltering() ? null : FilteredNumberColumns.TYPE

                        + "=" + FilteredNumberTypes.BLOCKED_NUMBER,

                null,

                null);

    }
@@ -151,8 +157,8 @@ public class FilteredNumberAsyncQueryHandler extends AsyncQueryHandler { 
     */

    public boolean isBlockedNumber(

            final OnCheckBlockedListener listener, String number, String countryIso) {

        final String normalizedNumber = PhoneNumberUtils.formatNumberToE164(number, countryIso);

        if (TextUtils.isEmpty(normalizedNumber)) {

        final String e164Number = PhoneNumberUtils.formatNumberToE164(number, countryIso);

        if (TextUtils.isEmpty(e164Number)) {

            return false;

        }
@@ -165,7 +171,9 @@ public class FilteredNumberAsyncQueryHandler extends AsyncQueryHandler { 
                            return;

                        }

                        cursor.moveToFirst();

                        if (cursor.getInt(cursor.getColumnIndex(FilteredNumberColumns.TYPE))

                        // New filtering doesn't have a concept of type

                        if (!FilteredNumberCompat.useNewFiltering()

                                && cursor.getInt(cursor.getColumnIndex(FilteredNumberColumns.TYPE))

                                != FilteredNumberTypes.BLOCKED_NUMBER) {

                            listener.onCheckComplete(null);

                            return;
@@ -174,17 +182,18 @@ public class FilteredNumberAsyncQueryHandler extends AsyncQueryHandler { 
                                cursor.getInt(cursor.getColumnIndex(FilteredNumberColumns._ID)));

                    }

                },

                getContentUri(null),

                new String[]{ FilteredNumberColumns._ID, FilteredNumberColumns.TYPE },

                FilteredNumberColumns.NORMALIZED_NUMBER + " = ?",

                new String[]{ normalizedNumber },

                FilteredNumberCompat.getContentUri(null),

                FilteredNumberCompat.filter(new String[]{FilteredNumberCompat.getIdColumnName(),

                        FilteredNumberCompat.getTypeColumnName()}),

                FilteredNumberCompat.getE164NumberColumnName() + " = ?",

                new String[]{e164Number},

                null);



        return true;

    }



    public void blockNumber(

            final OnBlockNumberListener listener, String number, String countryIso) {

            final OnBlockNumberListener listener, String number, @Nullable String countryIso) {

        blockNumber(listener, null, number, countryIso);

    }
@@ -193,19 +202,11 @@ public class FilteredNumberAsyncQueryHandler extends AsyncQueryHandler { 
     */

    public void blockNumber(

            final OnBlockNumberListener listener,

            String normalizedNumber,

            @Nullable String normalizedNumber,

            String number,

            String countryIso) {

        if (normalizedNumber == null) {

            normalizedNumber = PhoneNumberUtils.formatNumberToE164(number, countryIso);

        }

        ContentValues v = new ContentValues();

        v.put(FilteredNumberColumns.NORMALIZED_NUMBER, normalizedNumber);

        v.put(FilteredNumberColumns.NUMBER, number);

        v.put(FilteredNumberColumns.COUNTRY_ISO, countryIso);

        v.put(FilteredNumberColumns.TYPE, FilteredNumberTypes.BLOCKED_NUMBER);

        v.put(FilteredNumberColumns.SOURCE, FilteredNumberSources.USER);

        blockNumber(listener, v);

            @Nullable String countryIso) {

        blockNumber(listener, FilteredNumberCompat.newBlockNumberContentValues(number,

                normalizedNumber, countryIso));

    }



    /**
@@ -221,13 +222,14 @@ public class FilteredNumberAsyncQueryHandler extends AsyncQueryHandler { 
                            listener.onBlockComplete(uri);

                        }

                    }

                }, getContentUri(null), values);

                }, FilteredNumberCompat.getContentUri(null), values);

    }



    /**

     * Removes row from database.

     * Caller should call {@link FilteredNumberAsyncQueryHandler#startBlockedQuery} first.

     * @param id The ID of row to remove, from {@link FilteredNumberAsyncQueryHandler#startBlockedQuery}.

     * Unblocks the number with the given id.

     *

     * @param listener The {@link OnUnblockNumberListener} called after the number is unblocked.

     * @param id The id of the number to unblock.

     */

    public void unblock(final OnUnblockNumberListener listener, Integer id) {

        if (id == null) {

tests/src/com/android/dialer/database/FilteredNumberAsyncQueryHandlerTest.java

+174 −43
Original line number Diff line number Diff line
@@ -18,11 +18,16 @@ package com.android.dialer.database; 


import android.content.ContentValues;

import android.net.Uri;

import android.provider.BlockedNumberContract;

import android.provider.BlockedNumberContract.BlockedNumbers;

import android.test.InstrumentationTestCase;

import android.test.mock.MockContentResolver;

import android.test.suitebuilder.annotation.SmallTest;



import com.android.contacts.common.compat.CompatUtils;

import com.android.contacts.common.test.mocks.MockContentProvider;

import com.android.contacts.common.test.mocks.MockContentProvider.Query;

import com.android.dialer.compat.FilteredNumberCompat;

import com.android.dialer.database.FilteredNumberAsyncQueryHandler.OnBlockNumberListener;

import com.android.dialer.database.FilteredNumberAsyncQueryHandler.OnCheckBlockedListener;

import com.android.dialer.database.FilteredNumberAsyncQueryHandler.OnHasBlockedNumbersListener;
@@ -33,14 +38,19 @@ import com.android.dialer.database.FilteredNumberContract.FilteredNumberTypes; 
import java.util.concurrent.CountDownLatch;

import java.util.concurrent.TimeUnit;



@SmallTest

public class FilteredNumberAsyncQueryHandlerTest extends InstrumentationTestCase {



    private static final String E164_NUMBER = "+16502530000";

    private static final String NUMBER = "6502530000";

    private static final String COUNTRY_ISO = "US";

    private static final Integer ID = 1;

    private static final Uri BLOCKED_NUMBER_URI =

    private static final Uri BLOCKED_NUMBER_URI_N = CompatUtils.isNCompatible() ?

            Uri.withAppendedPath(BlockedNumberContract.AUTHORITY_URI, "blocked") : null;

    private static final Uri BLOCKED_NUMBER_URI_M =

            Uri.withAppendedPath(FilteredNumberContract.AUTHORITY_URI, "filtered_numbers_table");

    private static final Uri BLOCKED_NUMBER_URI = CompatUtils.isNCompatible() ? BLOCKED_NUMBER_URI_N

            : BLOCKED_NUMBER_URI_M;

    private static final Uri EXPECTED_URI = Uri.fromParts("android", "google", "dialer");



    private final MockContentResolver mContentResolver = new MockContentResolver();
@@ -49,31 +59,80 @@ public class FilteredNumberAsyncQueryHandlerTest extends InstrumentationTestCase 
    @Override

    public void setUp() throws Exception {

        super.setUp();

        FilteredNumberCompat.setIsEnabledForTest(true);

        if (CompatUtils.isNCompatible()) {

            mContentResolver.addProvider(BlockedNumberContract.AUTHORITY, mContentProvider);

        } else {

            mContentResolver.addProvider(FilteredNumberContract.AUTHORITY, mContentProvider);

        }

    }



    public void testIsBlockedNumber_NoResults() throws Throwable {

        newIsBlockedNumberExpectedQueryM().returnEmptyCursor();

        final CheckBlockedListener listener = new CheckBlockedListener();

    public void testHasBlockedNumbers_Disabled() throws Throwable {

        if (!CompatUtils.isNCompatible()) {

            return;

        }

        FilteredNumberCompat.setIsEnabledForTest(false);

        final MockContentResolver resolver = new MockContentResolver();

        MockContentProvider disabledProvider = new MockContentProvider();

        resolver.addProvider(FilteredNumberContract.AUTHORITY, disabledProvider);



        disabledProvider.expectQuery(BLOCKED_NUMBER_URI_M).withProjection(FilteredNumberColumns._ID)

                .withSelection(FilteredNumberColumns.TYPE + "="

                        + FilteredNumberTypes.BLOCKED_NUMBER, null).returnRow(ID);

        final HasBlockedNumbersListener listener = new HasBlockedNumbersListener();

        runTestOnUiThread(new Runnable() {

            @Override

            public void run() {

                new FilteredNumberAsyncQueryHandler(mContentResolver)

                        .isBlockedNumber(listener, NUMBER, COUNTRY_ISO);

                new FilteredNumberAsyncQueryHandler(resolver).hasBlockedNumbers(listener);

            }

        });

        assertNull(listener.waitForCallback());

        assertTrue(listener.waitForCallback());

        disabledProvider.verify();

    }



    public void testHasBlockedNumbers_NoResults() throws Throwable {

        newHasBlockedNumbersExpectedQuery().returnEmptyCursor();

        final HasBlockedNumbersListener listener = new HasBlockedNumbersListener();

        runTestOnUiThread(new Runnable() {

            @Override

            public void run() {

                new FilteredNumberAsyncQueryHandler(mContentResolver).hasBlockedNumbers(listener);

            }

        });

        assertFalse(listener.waitForCallback());

        mContentProvider.verify();

    }



    public void testIsBlockedNumber() throws Throwable {

        newIsBlockedNumberExpectedQueryM().returnRow(ID, FilteredNumberTypes.BLOCKED_NUMBER);

    public void testHasBlockedNumbers() throws Throwable {

        newHasBlockedNumbersExpectedQuery().returnRow(ID);

        final HasBlockedNumbersListener listener = new HasBlockedNumbersListener();

        runTestOnUiThread(new Runnable() {

            @Override

            public void run() {

                new FilteredNumberAsyncQueryHandler(mContentResolver).hasBlockedNumbers(listener);

            }

        });

        assertTrue(listener.waitForCallback());

        mContentProvider.verify();

    }



    public void testIsBlockedNumber_Disabled() throws Throwable {

        if (!CompatUtils.isNCompatible()) {

            return;

        }

        FilteredNumberCompat.setIsEnabledForTest(false);

        final MockContentResolver resolver = new MockContentResolver();

        MockContentProvider disabledProvider = new MockContentProvider();

        resolver.addProvider(FilteredNumberContract.AUTHORITY, disabledProvider);

        disabledProvider.expectQuery(BLOCKED_NUMBER_URI_M)

                .withProjection(FilteredNumberColumns._ID, FilteredNumberColumns.TYPE)

                .withSelection(FilteredNumberColumns.NORMALIZED_NUMBER + " = ?", E164_NUMBER)

                .returnRow(ID, FilteredNumberTypes.BLOCKED_NUMBER);

        final CheckBlockedListener listener = new CheckBlockedListener();

        runTestOnUiThread(new Runnable() {

            @Override

            public void run() {

                new FilteredNumberAsyncQueryHandler(mContentResolver)

                new FilteredNumberAsyncQueryHandler(resolver)

                        .isBlockedNumber(listener, NUMBER, COUNTRY_ISO);

            }

        });
@@ -81,50 +140,66 @@ public class FilteredNumberAsyncQueryHandlerTest extends InstrumentationTestCase 
        mContentProvider.verify();

    }



    public void testHasBlockedNumbers_NoResults() throws Throwable {

        newHasBlockedNumbersExpectedQueryM().returnEmptyCursor();

        final HasBlockedNumbersListener listener = new HasBlockedNumbersListener();

    public void testIsBlockedNumber_NoResults() throws Throwable {

        newIsBlockedNumberExpectedQuery().returnEmptyCursor();

        final CheckBlockedListener listener = new CheckBlockedListener();



        runTestOnUiThread(new Runnable() {

            @Override

            public void run() {

                new FilteredNumberAsyncQueryHandler(mContentResolver).hasBlockedNumbers(listener);

                new FilteredNumberAsyncQueryHandler(mContentResolver)

                        .isBlockedNumber(listener, NUMBER, COUNTRY_ISO);

            }

        });

        assertFalse(listener.waitForCallback());

        assertNull(listener.waitForCallback());

        mContentProvider.verify();

    }



    public void testHasBlockedNumbers() throws Throwable {

        newHasBlockedNumbersExpectedQueryM().returnRow(ID);

        final HasBlockedNumbersListener listener = new HasBlockedNumbersListener();

    public void testIsBlockedNumber() throws Throwable {

        if (CompatUtils.isNCompatible()) {

            newIsBlockedNumberExpectedQuery().returnRow(ID);

        } else {

            newIsBlockedNumberExpectedQuery().returnRow(ID, FilteredNumberTypes.BLOCKED_NUMBER);

        }

        final CheckBlockedListener listener = new CheckBlockedListener();

        runTestOnUiThread(new Runnable() {

            @Override

            public void run() {

                new FilteredNumberAsyncQueryHandler(mContentResolver).hasBlockedNumbers(listener);

                new FilteredNumberAsyncQueryHandler(mContentResolver)

                        .isBlockedNumber(listener, NUMBER, COUNTRY_ISO);

           }

        });

        assertTrue(listener.waitForCallback());

        assertEquals(ID, listener.waitForCallback());

        mContentProvider.verify();

    }



    private Query newIsBlockedNumberExpectedQueryM() {

        return mContentProvider.expectQuery(BLOCKED_NUMBER_URI)

                .withProjection(FilteredNumberColumns._ID, FilteredNumberColumns.TYPE)

                .withSelection(FilteredNumberColumns.NORMALIZED_NUMBER + " = ?", E164_NUMBER);

    public void testBlockNumber_Disabled() throws Throwable {

        if (!CompatUtils.isNCompatible()) {

            return;

        }

        FilteredNumberCompat.setIsEnabledForTest(false);

        final MockContentResolver resolver = new MockContentResolver();

        MockContentProvider disabledProvider = new MockContentProvider();

        resolver.addProvider(FilteredNumberContract.AUTHORITY, disabledProvider);



    private Query newHasBlockedNumbersExpectedQueryM() {

        return mContentProvider.expectQuery(BLOCKED_NUMBER_URI).withProjection(

                FilteredNumberColumns._ID)

                .withSelection(FilteredNumberColumns.TYPE + "="

                        + FilteredNumberTypes.BLOCKED_NUMBER, null);

        disabledProvider.expectInsert(BLOCKED_NUMBER_URI_M, newBlockNumberContentValuesM(),

                EXPECTED_URI);

        final BlockNumberListener listener = new BlockNumberListener();

        runTestOnUiThread(new Runnable() {

            @Override

            public void run() {

                new FilteredNumberAsyncQueryHandler(resolver).blockNumber(listener, E164_NUMBER,

                        NUMBER, COUNTRY_ISO);

            }

        });

        assertSame(EXPECTED_URI, listener.waitForCallback());

        disabledProvider.verify();

    }



    public void testBlockNumber() throws Throwable {

        mContentProvider.expectInsert(BLOCKED_NUMBER_URI, newBlockNumberContentValues(),

                EXPECTED_URI);

        final BlockingArgumentCaptorOnBlockNumberListener listener =

                new BlockingArgumentCaptorOnBlockNumberListener();

        final BlockNumberListener listener = new BlockNumberListener();

        runTestOnUiThread(new Runnable() {

            @Override

            public void run() {
@@ -132,16 +207,14 @@ public class FilteredNumberAsyncQueryHandlerTest extends InstrumentationTestCase 
                        E164_NUMBER, NUMBER, COUNTRY_ISO);

            }

        });

        assertTrue(listener.onBlockCompleteCalled.await(5000, TimeUnit.MILLISECONDS));

        assertSame(EXPECTED_URI, listener.uri);

        assertSame(EXPECTED_URI, listener.waitForCallback());

        mContentProvider.verify();

    }



    public void testBlockNumber_NullNormalizedNumber() throws Throwable {

        mContentProvider.expectInsert(BLOCKED_NUMBER_URI, newBlockNumberContentValues(),

                EXPECTED_URI);

        final BlockingArgumentCaptorOnBlockNumberListener listener =

                new BlockingArgumentCaptorOnBlockNumberListener();

        final BlockNumberListener listener = new BlockNumberListener();

        runTestOnUiThread(new Runnable() {

            @Override

            public void run() {
@@ -149,12 +222,63 @@ public class FilteredNumberAsyncQueryHandlerTest extends InstrumentationTestCase 
                        NUMBER, COUNTRY_ISO);

            }

        });

        assertTrue(listener.onBlockCompleteCalled.await(5000, TimeUnit.MILLISECONDS));

        assertSame(EXPECTED_URI, listener.uri);

        assertSame(EXPECTED_URI, listener.waitForCallback());

        mContentProvider.verify();

    }



    private Query newIsBlockedNumberExpectedQuery() {

        if (CompatUtils.isNCompatible()) {

            return newIsBlockedNumberExpectedQueryN();

        }

        return newIsBlockedNumberExpectedQueryM();

    }



    private Query newIsBlockedNumberExpectedQueryN() {

        return mContentProvider.expectQuery(BLOCKED_NUMBER_URI)

                .withProjection(BlockedNumbers.COLUMN_ID)

                .withSelection(BlockedNumbers.COLUMN_E164_NUMBER + " = ?", E164_NUMBER);

    }



    private Query newIsBlockedNumberExpectedQueryM() {

        return mContentProvider.expectQuery(BLOCKED_NUMBER_URI)

                .withProjection(FilteredNumberColumns._ID, FilteredNumberColumns.TYPE)

                .withSelection(FilteredNumberColumns.NORMALIZED_NUMBER + " = ?", E164_NUMBER);

    }



    private Query newHasBlockedNumbersExpectedQuery() {

        if (CompatUtils.isNCompatible()) {

            return newHasBlockedNumbersExpectedQueryN();

        }

        return newHasBlockedNumbersExpectedQueryM();

    }



    private Query newHasBlockedNumbersExpectedQueryN() {

        return mContentProvider.expectQuery(BLOCKED_NUMBER_URI)

                .withProjection(BlockedNumbers.COLUMN_ID)

                .withSelection(null, null);

    }



    private Query newHasBlockedNumbersExpectedQueryM() {

        return mContentProvider.expectQuery(BLOCKED_NUMBER_URI).withProjection(

                FilteredNumberColumns._ID)

                .withSelection(FilteredNumberColumns.TYPE + "="

                        + FilteredNumberTypes.BLOCKED_NUMBER, null);

    }



    private ContentValues newBlockNumberContentValues() {

        if (CompatUtils.isNCompatible()) {

            return newBlockNumberContentValuesN();

        }

        return newBlockNumberContentValuesM();

    }



    private ContentValues newBlockNumberContentValuesN() {

        ContentValues contentValues = new ContentValues();

        contentValues.put(BlockedNumbers.COLUMN_ORIGINAL_NUMBER, NUMBER);

        return contentValues;

    }



    private ContentValues newBlockNumberContentValuesM() {

        ContentValues contentValues = new ContentValues();

        contentValues.put(FilteredNumberColumns.NORMALIZED_NUMBER, E164_NUMBER);

        contentValues.put(FilteredNumberColumns.NUMBER, NUMBER);
@@ -208,11 +332,11 @@ public class FilteredNumberAsyncQueryHandlerTest extends InstrumentationTestCase 
        }

    }



    private class BlockingArgumentCaptorOnBlockNumberListener implements OnBlockNumberListener {

    private class BlockNumberListener implements OnBlockNumberListener {

        public final CountDownLatch onBlockCompleteCalled;

        public Uri uri;



        public BlockingArgumentCaptorOnBlockNumberListener() {

        public BlockNumberListener() {

            onBlockCompleteCalled = new CountDownLatch(1);

        }
@@ -221,5 +345,12 @@ public class FilteredNumberAsyncQueryHandlerTest extends InstrumentationTestCase 
            this.uri = uri;

            onBlockCompleteCalled.countDown();

        }



        public Uri waitForCallback() throws InterruptedException {

            if (!onBlockCompleteCalled.await(5000, TimeUnit.MILLISECONDS)) {

                throw new IllegalStateException("Waiting on callback timed out.");

            }

            return uri;

        }

    }

}