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

Commit 0c00c3ef authored by Brandon Maxwell's avatar Brandon Maxwell Committed by Android (Google) Code Review
Browse files

Merge changes from topic 'mockDelete' into nyc-dev 

* changes:
  Using FilteredNumCompat for unblock
  Updating AsyncQueryHandler with FilteredNumCompat
  Implementing Compat class for Filtering
parents 008c82f4 f0e0ce60

src-N/com/android/dialer/compat/BlockedNumbersSdkCompat.java

0 → 100644
+32 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2016 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License

 */



package com.android.dialer.compat;



import android.net.Uri;

import android.provider.BlockedNumberContract.BlockedNumbers;



public class BlockedNumbersSdkCompat {



    public static final Uri CONTENT_URI = BlockedNumbers.CONTENT_URI;



    public static final String _ID = BlockedNumbers.COLUMN_ID;



    public static final String COLUMN_ORIGINAL_NUMBER = BlockedNumbers.COLUMN_ORIGINAL_NUMBER;



    public static final String E164_NUMBER = BlockedNumbers.COLUMN_E164_NUMBER;



}

src-pre-N/com/android/dialer/compat/BlockedNumbersSdkCompat.java

0 → 100644
+30 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2016 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License

 */



package com.android.dialer.compat;



import android.net.Uri;



public class BlockedNumbersSdkCompat {



    public static final Uri CONTENT_URI = null;



    public static final String _ID = null;



    public static final String COLUMN_ORIGINAL_NUMBER = null;



    public static final String E164_NUMBER = null;

}

src/com/android/dialer/compat/FilteredNumberCompat.java

0 → 100644
+189 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2016 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License

 */



    package com.android.dialer.compat;



import com.google.common.base.Preconditions;



import android.content.ContentUris;

import android.content.ContentValues;

import android.net.Uri;

import android.support.annotation.Nullable;

import android.telephony.PhoneNumberUtils;



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

import com.android.contacts.common.testing.NeededForTesting;

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;



import java.util.ArrayList;

import java.util.List;



/**

 * Compatibility class to encapsulate logic to switch between call blocking using

 * {@link com.android.dialer.database.FilteredNumberContract} and using

 * {@link android.provider.BlockedNumberContract}. This class should be used rather than explicitly

 * referencing columns from either contract class in situations where both blocking solutions may be

 * used.

 */

public class FilteredNumberCompat {



    // Flag to enable feature.

    // TODO(maxwelb) remove when ready to enable new filtering.

    private static final boolean isNewFilteringEnabled = false;

    private static Boolean isEnabledForTest;



    /**

     * @return The column name for ID in the filtered number database.

     */

    public static String getIdColumnName() {

        return useNewFiltering() ? BlockedNumbersSdkCompat._ID : FilteredNumberColumns._ID;

    }



    /**

     * @return The column name for type in the filtered number database. Will be {@code null} for

     * the framework blocking implementation.

     */

    @Nullable

    public static String getTypeColumnName() {

        return useNewFiltering() ? null : FilteredNumberColumns.TYPE;

    }



    /**

     * @return The column name for source in the filtered number database. Will be {@code null} for

     * the framework blocking implementation

     */

    @Nullable

    public static String getSourceColumnName() {

        return useNewFiltering() ? null : FilteredNumberColumns.SOURCE;

    }



    /**

     * @return The column name for the original number in the filtered number database.

     */

    public static String getOriginalNumberColumnName() {

        return useNewFiltering() ? BlockedNumbersSdkCompat.COLUMN_ORIGINAL_NUMBER

                : FilteredNumberColumns.NUMBER;

    }



    /**

     * @return The column name for country iso in the filtered number database. Will be {@code null}

     * the framework blocking implementation

     */

    @Nullable

    public static String getCountryIsoColumnName() {

        return useNewFiltering() ? null : FilteredNumberColumns.COUNTRY_ISO;

    }



    /**

     * @return The column name for the e164 formatted number in the filtered number database.

     */

    public static String getE164NumberColumnName() {

        return useNewFiltering() ? BlockedNumbersSdkCompat.E164_NUMBER

                : FilteredNumberColumns.NORMALIZED_NUMBER;

    }



    /**

     * @return {@code true} if the new filtering is enabled, {@code false} otherwise.

     */

    public static boolean useNewFiltering() {

        if (isEnabledForTest != null) {

            return CompatUtils.isNCompatible() && isEnabledForTest;

        }

        return CompatUtils.isNCompatible() && isNewFilteringEnabled;

    }



    @NeededForTesting

    public static void setIsEnabledForTest(Boolean isEnabled) {

        isEnabledForTest = isEnabled;

    }



    /**

     * Gets the content {@link Uri} for number filtering.

     *

     * @param id The optional id to append with the base content uri.

     * @return The Uri for number filtering.

     */

    public static Uri getContentUri(@Nullable Integer id) {

        if (id == null) {

            return getBaseUri();

        }

        return ContentUris.withAppendedId(getBaseUri(), id);

    }





    private static Uri getBaseUri() {

        return useNewFiltering() ? BlockedNumbersSdkCompat.CONTENT_URI : FilteredNumber.CONTENT_URI;

    }



    /**

     * Removes any null column names from the given projection array. This method is intended to be

     * used to strip out any column names that aren't available in every version of number blocking.

     * Example:

     * {@literal

     *   getContext().getContentResolver().query(

     *       someUri,

     *       // Filtering ensures that no non-existant columns are queried

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

     *           FilteredNumberCompat.getTypeColumnName()},

     *       FilteredNumberCompat.getE164NumberColumnName() + " = ?",

     *       new String[] {e164Number});

     * }

     *

     * @param projection The projection array.

     * @return The filtered projection array.

     */

    @Nullable

    public static String[] filter(@Nullable String[] projection) {

        if (projection == null) {

            return null;

        }

        List<String> filtered = new ArrayList<>();

        for (String column : projection) {

            if (column != null) {

                filtered.add(column);

            }

        }

        return filtered.toArray(new String[filtered.size()]);

    }



    /**

     * Creates a new {@link ContentValues} suitable for inserting in the filtered number table.

     *

     * @param number The unformatted number to insert.

     * @param e164Number (optional) The number to insert formatted to E164 standard.

     * @param countryIso (optional) The country iso to use to format the number.

     * @return The ContentValues to insert.

     * @throws NullPointerException If number is null.

     */

    public static ContentValues newBlockNumberContentValues(String number,

            @Nullable String e164Number, @Nullable String countryIso) {

        ContentValues contentValues = new ContentValues();

        contentValues.put(getOriginalNumberColumnName(), Preconditions.checkNotNull(number));

        if (!useNewFiltering()) {

            if (e164Number == null) {

                e164Number = PhoneNumberUtils.formatNumberToE164(number, countryIso);

            }

            contentValues.put(getE164NumberColumnName(), e164Number);

            contentValues.put(getCountryIsoColumnName(), countryIso);

            contentValues.put(getTypeColumnName(), FilteredNumberTypes.BLOCKED_NUMBER);

            contentValues.put(getSourceColumnName(), FilteredNumberSources.USER);

        }

        return contentValues;

    }

}

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

+42 −45
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
@@ -114,15 +115,11 @@ public class FilteredNumberAsyncQueryHandler extends AsyncQueryHandler { 
        }

    }



    private static Uri getContentUri(Integer id) {

        Uri uri = FilteredNumber.CONTENT_URI;

        if (id != null) {

            uri = ContentUris.withAppendedId(uri, id);

        }

        return uri;

    }



    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 +133,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 +149,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 +163,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 +174,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 +194,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,27 +214,31 @@ 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 (optional) 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) {

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

        if (id == null) {

            throw new IllegalArgumentException("Null id passed into unblock");

        }

        unblock(listener, getContentUri(id));

        unblock(listener, FilteredNumberCompat.getContentUri(id));

    }



    /**

     * Removes row from database.

     * @param listener (optional) The {@link OnUnblockNumberListener} called after the number is

     * unblocked.

     * @param uri The uri of row to remove, from

     * {@link FilteredNumberAsyncQueryHandler#blockNumber}.

     */

    public void unblock(final OnUnblockNumberListener listener, final Uri uri) {

    public void unblock(@Nullable final OnUnblockNumberListener listener, final Uri uri) {

        startQuery(NO_TOKEN, new Listener() {

            @Override

            public void onQueryComplete(int token, Object cookie, Cursor cursor) {
@@ -254,7 +251,7 @@ public class FilteredNumberAsyncQueryHandler extends AsyncQueryHandler { 
                cursor.moveToFirst();

                final ContentValues values = new ContentValues();

                DatabaseUtils.cursorRowToContentValues(cursor, values);

                values.remove(FilteredNumberColumns._ID);

                values.remove(FilteredNumberCompat.getIdColumnName());



                startDelete(NO_TOKEN, new Listener() {

                    @Override

tests/src/com/android/dialer/compat/FilteredNumberCompatTest.java

0 → 100644
+149 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2016 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License

 */



package com.android.dialer.compat;



import android.content.ContentUris;

import android.content.ContentValues;

import android.net.Uri;

import android.provider.BlockedNumberContract.BlockedNumbers;

import android.test.AndroidTestCase;

import android.test.suitebuilder.annotation.SmallTest;



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

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;



import java.util.Arrays;



@SmallTest

public class FilteredNumberCompatTest extends AndroidTestCase {



    private static final String E164_NUMBER = "+16502530000";

    private static final String NON_E164_NUMBER = "6502530000";

    private static final String COUNTRY_ISO = "US";



    private static final Uri EXPECTED_BASE_URI = CompatUtils.isNCompatible()

            ? BlockedNumbers.CONTENT_URI : FilteredNumber.CONTENT_URI;



    @Override

    public void setUp() throws Exception {

        super.setUp();

        FilteredNumberCompat.setIsEnabledForTest(true);

    }



    public void testIsNewFilteringEnabled_TestValueFalse() {

        FilteredNumberCompat.setIsEnabledForTest(false);

        assertFalse(FilteredNumberCompat.useNewFiltering());

    }



    public void testIsNewFilteringEnabled_TestValueTrue() {

        FilteredNumberCompat.setIsEnabledForTest(true);

        assertEquals(CompatUtils.isNCompatible(), FilteredNumberCompat.useNewFiltering());

    }



    public void testGetContentUri_NullId() {

        assertEquals(EXPECTED_BASE_URI, FilteredNumberCompat.getContentUri(null));

    }



    public void testGetContentUri() {

        assertEquals(ContentUris.withAppendedId(EXPECTED_BASE_URI, 1),

                FilteredNumberCompat.getContentUri(1));

    }



    public void testFilter_NullProjection() {

        assertNull(FilteredNumberCompat.filter(null));

    }



    public void testFilter_NoNulls() {

        assertArrayEquals(new String[] {"a", "b", "c"},

                FilteredNumberCompat.filter(new String[] {"a", "b", "c"}));

    }



    public void testFilter_WithNulls() {

        assertArrayEquals(new String[] {"a", "b"},

                FilteredNumberCompat.filter(new String[] {"a", null, "b"}));

    }



    public void testNewBlockNumberContentValues_NullNumber() {

        try {

            FilteredNumberCompat.newBlockNumberContentValues(null, null, null);

            fail();

        } catch (NullPointerException e) {}

    }



    public void testNewBlockNumberContentValues_N() {

        if (!CompatUtils.isNCompatible()) {

            return;

        }

        ContentValues contentValues = new ContentValues();

        contentValues.put(BlockedNumbers.COLUMN_ORIGINAL_NUMBER, NON_E164_NUMBER);

        assertEquals(contentValues, FilteredNumberCompat.newBlockNumberContentValues(

                NON_E164_NUMBER,

                null, null));

    }



    public void testNewBlockNumberContentValues_N_Disabled() {

        if (!CompatUtils.isNCompatible()) {

            return;

        }

        FilteredNumberCompat.setIsEnabledForTest(false);

        assertEquals(newExpectedContentValuesM(NON_E164_NUMBER, E164_NUMBER, COUNTRY_ISO),

                FilteredNumberCompat.newBlockNumberContentValues(NON_E164_NUMBER, E164_NUMBER, COUNTRY_ISO));

    }



    public void testNewBlockNumberContentValues_M_NullE164() {

        if (CompatUtils.isNCompatible()) {

            return;

        }

        assertEquals(newExpectedContentValuesM(NON_E164_NUMBER, E164_NUMBER, COUNTRY_ISO),

                FilteredNumberCompat.newBlockNumberContentValues(NON_E164_NUMBER, null, COUNTRY_ISO));

    }



    public void testNewBlockNumberContentValues_M_NullCountryIso() {

        if (CompatUtils.isNCompatible()) {

            return;

        }

        assertEquals(newExpectedContentValuesM(NON_E164_NUMBER, E164_NUMBER, null),

                FilteredNumberCompat.newBlockNumberContentValues(NON_E164_NUMBER, E164_NUMBER, null));

    }



    public void testNewBlockNumberContentValues_M_NullE164AndCountryIso() {

        if (CompatUtils.isNCompatible()) {

            return;

        }

        // Number can't be formatted properly without country code

        assertEquals(newExpectedContentValuesM(NON_E164_NUMBER, null, null),

                FilteredNumberCompat.newBlockNumberContentValues(NON_E164_NUMBER, null, null));

    }



    private ContentValues newExpectedContentValuesM(String number, String e164Number,

            String countryIso) {

        ContentValues contentValues = new ContentValues();

        contentValues.put(FilteredNumberColumns.NUMBER, number);

        contentValues.put(FilteredNumberColumns.NORMALIZED_NUMBER, e164Number);

        contentValues.put(FilteredNumberColumns.COUNTRY_ISO, countryIso);

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

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

        return contentValues;

    }



    private void assertArrayEquals(String[] expected, String[] actual) {

        assertEquals(Arrays.toString(expected), Arrays.toString(actual));

    }

}