diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index b459a44..d19d0c9 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -16,8 +16,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
   coreApp="true"
   package="com.android.dialer"
-  android:versionCode="190000"
-  android:versionName="14.0">
+  android:versionCode="220000"
+  android:versionName="17.0">
 
   <uses-sdk
     android:minSdkVersion="23"
diff --git a/java/com/android/dialer/binary/google/AndroidManifest.xml b/java/com/android/dialer/binary/google/AndroidManifest.xml
index 86f6bcb..0ebc006 100644
--- a/java/com/android/dialer/binary/google/AndroidManifest.xml
+++ b/java/com/android/dialer/binary/google/AndroidManifest.xml
@@ -16,8 +16,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
   coreApp="true"
   package="com.google.android.google_stub_dialer"
-  android:versionCode="190000"
-  android:versionName="14.0">
+  android:versionCode="220000"
+  android:versionName="17.0">
 
   <uses-sdk
     android:minSdkVersion="23"
diff --git a/java/com/android/dialer/calllog/CallLogFramework.java b/java/com/android/dialer/calllog/CallLogFramework.java
index e4bb4c8..c9d5f09 100644
--- a/java/com/android/dialer/calllog/CallLogFramework.java
+++ b/java/com/android/dialer/calllog/CallLogFramework.java
@@ -20,6 +20,7 @@
 import android.content.SharedPreferences;
 import android.support.annotation.MainThread;
 import android.support.annotation.Nullable;
+import android.support.annotation.VisibleForTesting;
 import com.android.dialer.buildtype.BuildType;
 import com.android.dialer.calllog.datasources.CallLogDataSource;
 import com.android.dialer.calllog.datasources.DataSources;
@@ -38,7 +39,8 @@
 @Singleton
 public final class CallLogFramework implements CallLogDataSource.ContentObserverCallbacks {
 
-  static final String PREF_FORCE_REBUILD = "callLogFrameworkForceRebuild";
+  @VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE)
+  public static final String PREF_FORCE_REBUILD = "callLogFrameworkForceRebuild";
 
   private final DataSources dataSources;
   private final SharedPreferences sharedPreferences;
diff --git a/java/com/android/dialer/calllog/datasources/phonelookup/PhoneLookupDataSource.java b/java/com/android/dialer/calllog/datasources/phonelookup/PhoneLookupDataSource.java
index 2148627..6ec11ad 100644
--- a/java/com/android/dialer/calllog/datasources/phonelookup/PhoneLookupDataSource.java
+++ b/java/com/android/dialer/calllog/datasources/phonelookup/PhoneLookupDataSource.java
@@ -33,14 +33,15 @@
 import com.android.dialer.calllog.datasources.CallLogDataSource;
 import com.android.dialer.calllog.datasources.CallLogMutations;
 import com.android.dialer.calllog.datasources.util.RowCombiner;
+import com.android.dialer.common.Assert;
 import com.android.dialer.common.LogUtil;
 import com.android.dialer.common.concurrent.Annotations.BackgroundExecutor;
 import com.android.dialer.common.concurrent.Annotations.LightweightExecutor;
 import com.android.dialer.phonelookup.PhoneLookup;
 import com.android.dialer.phonelookup.PhoneLookupInfo;
-import com.android.dialer.phonelookup.PhoneLookupSelector;
 import com.android.dialer.phonelookup.database.contract.PhoneLookupHistoryContract;
 import com.android.dialer.phonelookup.database.contract.PhoneLookupHistoryContract.PhoneLookupHistory;
+import com.android.dialer.phonelookup.selector.PhoneLookupSelector;
 import com.android.dialer.phonenumberproto.DialerPhoneNumberUtil;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
@@ -63,9 +64,11 @@
  * Responsible for maintaining the columns in the annotated call log which are derived from phone
  * numbers.
  */
-public final class PhoneLookupDataSource implements CallLogDataSource {
+public final class PhoneLookupDataSource
+    implements CallLogDataSource, PhoneLookup.ContentObserverCallbacks {
 
   private final PhoneLookup<PhoneLookupInfo> phoneLookup;
+  private final PhoneLookupSelector phoneLookupSelector;
   private final ListeningExecutorService backgroundExecutorService;
   private final ListeningExecutorService lightweightExecutorService;
 
@@ -86,12 +89,16 @@
    */
   private final Set<String> phoneLookupHistoryRowsToDelete = new ArraySet<>();
 
+  private CallLogDataSource.ContentObserverCallbacks dataSourceContentObserverCallbacks;
+
   @Inject
   PhoneLookupDataSource(
       PhoneLookup<PhoneLookupInfo> phoneLookup,
+      PhoneLookupSelector phoneLookupSelector,
       @BackgroundExecutor ListeningExecutorService backgroundExecutorService,
       @LightweightExecutor ListeningExecutorService lightweightExecutorService) {
     this.phoneLookup = phoneLookup;
+    this.phoneLookupSelector = phoneLookupSelector;
     this.backgroundExecutorService = backgroundExecutorService;
     this.lightweightExecutorService = lightweightExecutorService;
   }
@@ -275,8 +282,16 @@
   @MainThread
   @Override
   public void registerContentObservers(
-      Context appContext, ContentObserverCallbacks contentObserverCallbacks) {
-    // No content observers required for this data source.
+      Context appContext, CallLogDataSource.ContentObserverCallbacks contentObserverCallbacks) {
+    dataSourceContentObserverCallbacks = contentObserverCallbacks;
+    phoneLookup.registerContentObservers(appContext, this);
+  }
+
+  @MainThread
+  @Override
+  public void markDirtyAndNotify(Context appContext) {
+    Assert.isMainThread();
+    dataSourceContentObserverCallbacks.markDirtyAndNotify(appContext);
   }
 
   private static ImmutableSet<DialerPhoneNumber>
@@ -455,7 +470,7 @@
             }));
   }
 
-  private static void populateInserts(
+  private void populateInserts(
       ImmutableMap<Long, PhoneLookupInfo> existingInfo, CallLogMutations mutations) {
     for (Entry<Long, ContentValues> entry : mutations.getInserts().entrySet()) {
       long id = entry.getKey();
@@ -468,7 +483,7 @@
     }
   }
 
-  private static void updateMutations(
+  private void updateMutations(
       ImmutableMap<Long, PhoneLookupInfo> updatesToApply, CallLogMutations mutations) {
     for (Entry<Long, PhoneLookupInfo> entry : updatesToApply.entrySet()) {
       long id = entry.getKey();
@@ -554,17 +569,16 @@
     return normalizedNumbersToDelete;
   }
 
-  private static void updateContentValues(
-      ContentValues contentValues, PhoneLookupInfo phoneLookupInfo) {
-    contentValues.put(AnnotatedCallLog.NAME, PhoneLookupSelector.selectName(phoneLookupInfo));
+  private void updateContentValues(ContentValues contentValues, PhoneLookupInfo phoneLookupInfo) {
+    contentValues.put(AnnotatedCallLog.NAME, phoneLookupSelector.selectName(phoneLookupInfo));
     contentValues.put(
-        AnnotatedCallLog.PHOTO_URI, PhoneLookupSelector.selectPhotoUri(phoneLookupInfo));
+        AnnotatedCallLog.PHOTO_URI, phoneLookupSelector.selectPhotoUri(phoneLookupInfo));
     contentValues.put(
-        AnnotatedCallLog.PHOTO_ID, PhoneLookupSelector.selectPhotoId(phoneLookupInfo));
+        AnnotatedCallLog.PHOTO_ID, phoneLookupSelector.selectPhotoId(phoneLookupInfo));
     contentValues.put(
-        AnnotatedCallLog.LOOKUP_URI, PhoneLookupSelector.selectLookupUri(phoneLookupInfo));
+        AnnotatedCallLog.LOOKUP_URI, phoneLookupSelector.selectLookupUri(phoneLookupInfo));
     contentValues.put(
-        AnnotatedCallLog.NUMBER_TYPE_LABEL, PhoneLookupSelector.selectNumberLabel(phoneLookupInfo));
+        AnnotatedCallLog.NUMBER_TYPE_LABEL, phoneLookupSelector.selectNumberLabel(phoneLookupInfo));
     contentValues.put(
         AnnotatedCallLog.CAN_REPORT_AS_INVALID_NUMBER,
         PhoneLookupSelector.canReportAsInvalidNumber(phoneLookupInfo));
diff --git a/java/com/android/dialer/common/database/Selection.java b/java/com/android/dialer/common/database/Selection.java
index b61472d..e449fd9 100644
--- a/java/com/android/dialer/common/database/Selection.java
+++ b/java/com/android/dialer/common/database/Selection.java
@@ -18,8 +18,11 @@
 
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
+import android.text.TextUtils;
 import com.android.dialer.common.Assert;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
@@ -106,7 +109,14 @@
    *     enclosed in a parenthesis.
    */
   @NonNull
+  @SuppressWarnings("rawtypes")
   public static Selection fromString(@Nullable String selection, @Nullable String... args) {
+    return new Builder(selection, args == null ? Collections.emptyList() : Arrays.asList(args))
+        .build();
+  }
+
+  @NonNull
+  public static Selection fromString(@Nullable String selection, Collection<String> args) {
     return new Builder(selection, args).build();
   }
 
@@ -149,6 +159,16 @@
     public Selection is(@NonNull String condition) {
       return fromString(column + " " + Assert.isNotNull(condition));
     }
+
+    public Selection in(String... values) {
+      return in(values == null ? Collections.emptyList() : Arrays.asList(values));
+    }
+
+    public Selection in(Collection<String> values) {
+      return fromString(
+          column + " IN (" + TextUtils.join(",", Collections.nCopies(values.size(), "?")) + ")",
+          values);
+    }
   }
 
   /** Builder for {@link Selection} */
@@ -159,14 +179,14 @@
 
     private Builder() {}
 
-    private Builder(@Nullable String selection, @Nullable String... args) {
+    private Builder(@Nullable String selection, Collection<String> args) {
       if (selection == null) {
         return;
       }
       checkArgsCount(selection, args);
       this.selection.append(parenthesized(selection));
       if (args != null) {
-        Collections.addAll(selectionArgs, args);
+        selectionArgs.addAll(args);
       }
     }
 
@@ -213,14 +233,14 @@
       return this;
     }
 
-    private static void checkArgsCount(@NonNull String selection, @Nullable String... args) {
+    private static void checkArgsCount(@NonNull String selection, Collection<String> args) {
       int argsInSelection = 0;
       for (int i = 0; i < selection.length(); i++) {
         if (selection.charAt(i) == '?') {
           argsInSelection++;
         }
       }
-      Assert.checkArgument(argsInSelection == (args == null ? 0 : args.length));
+      Assert.checkArgument(argsInSelection == (args == null ? 0 : args.size()));
     }
   }
 
diff --git a/java/com/android/dialer/phonelookup/PhoneLookup.java b/java/com/android/dialer/phonelookup/PhoneLookup.java
index 859085e..118ae60 100644
--- a/java/com/android/dialer/phonelookup/PhoneLookup.java
+++ b/java/com/android/dialer/phonelookup/PhoneLookup.java
@@ -16,6 +16,8 @@
 
 package com.android.dialer.phonelookup;
 
+import android.content.Context;
+import android.support.annotation.MainThread;
 import android.support.annotation.NonNull;
 import android.telecom.Call;
 import com.android.dialer.DialerPhoneNumber;
@@ -82,4 +84,16 @@
    * be efficiently implemented.
    */
   ListenableFuture<Void> onSuccessfulBulkUpdate();
+
+  @MainThread
+  void registerContentObservers(
+      Context appContext, ContentObserverCallbacks contentObserverCallbacks);
+
+  /**
+   * Methods which may optionally be called as a result of a phone lookup's content observer firing.
+   */
+  interface ContentObserverCallbacks {
+    @MainThread
+    void markDirtyAndNotify(Context appContext);
+  }
 }
diff --git a/java/com/android/dialer/phonelookup/PhoneLookupModule.java b/java/com/android/dialer/phonelookup/PhoneLookupModule.java
index 8a59005..b4f3787 100644
--- a/java/com/android/dialer/phonelookup/PhoneLookupModule.java
+++ b/java/com/android/dialer/phonelookup/PhoneLookupModule.java
@@ -16,6 +16,7 @@
 
 package com.android.dialer.phonelookup;
 
+import com.android.dialer.phonelookup.blockednumber.DialerBlockedNumberPhoneLookup;
 import com.android.dialer.phonelookup.composite.CompositePhoneLookup;
 import com.android.dialer.phonelookup.cp2.Cp2PhoneLookup;
 import com.google.common.collect.ImmutableList;
@@ -27,8 +28,11 @@
 public abstract class PhoneLookupModule {
 
   @Provides
-  static ImmutableList<PhoneLookup> providePhoneLookupList(Cp2PhoneLookup cp2PhoneLookup) {
-    return ImmutableList.of(cp2PhoneLookup);
+  @SuppressWarnings({"unchecked", "rawtype"})
+  static ImmutableList<PhoneLookup> providePhoneLookupList(
+      Cp2PhoneLookup cp2PhoneLookup,
+      DialerBlockedNumberPhoneLookup dialerBlockedNumberPhoneLookup) {
+    return ImmutableList.of(cp2PhoneLookup, dialerBlockedNumberPhoneLookup);
   }
 
   @Provides
diff --git a/java/com/android/dialer/phonelookup/blockednumber/DialerBlockedNumberPhoneLookup.java b/java/com/android/dialer/phonelookup/blockednumber/DialerBlockedNumberPhoneLookup.java
new file mode 100644
index 0000000..54df399
--- /dev/null
+++ b/java/com/android/dialer/phonelookup/blockednumber/DialerBlockedNumberPhoneLookup.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright (C) 2018 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.phonelookup.blockednumber;
+
+import android.content.Context;
+import android.database.ContentObserver;
+import android.database.Cursor;
+import android.net.Uri;
+import android.support.annotation.MainThread;
+import android.support.annotation.NonNull;
+import android.support.annotation.WorkerThread;
+import android.telecom.Call;
+import android.util.ArraySet;
+import com.android.dialer.DialerPhoneNumber;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.common.concurrent.Annotations.BackgroundExecutor;
+import com.android.dialer.common.database.Selection;
+import com.android.dialer.database.FilteredNumberContract.FilteredNumber;
+import com.android.dialer.database.FilteredNumberContract.FilteredNumberColumns;
+import com.android.dialer.database.FilteredNumberContract.FilteredNumberTypes;
+import com.android.dialer.inject.ApplicationContext;
+import com.android.dialer.phonelookup.PhoneLookup;
+import com.android.dialer.phonelookup.PhoneLookupInfo;
+import com.android.dialer.phonelookup.PhoneLookupInfo.BlockedState;
+import com.android.dialer.phonelookup.PhoneLookupInfo.DialerBlockedNumberInfo;
+import com.android.dialer.phonenumberproto.DialerPhoneNumberUtil;
+import com.android.dialer.phonenumberproto.PartitionedNumbers;
+import com.android.dialer.telecom.TelecomCallUtil;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.i18n.phonenumbers.PhoneNumberUtil;
+import java.util.Set;
+import javax.inject.Inject;
+
+/**
+ * Lookup blocked numbers in the dialer internal database. This is used when the system database is
+ * not yet available.
+ */
+public final class DialerBlockedNumberPhoneLookup implements PhoneLookup<DialerBlockedNumberInfo> {
+
+  private final Context appContext;
+  private final ListeningExecutorService executorService;
+
+  @Inject
+  DialerBlockedNumberPhoneLookup(
+      @ApplicationContext Context appContext,
+      @BackgroundExecutor ListeningExecutorService executorService) {
+    this.appContext = appContext;
+    this.executorService = executorService;
+  }
+
+  @Override
+  public ListenableFuture<DialerBlockedNumberInfo> lookup(@NonNull Call call) {
+    return executorService.submit(
+        () -> {
+          DialerPhoneNumberUtil dialerPhoneNumberUtil =
+              new DialerPhoneNumberUtil(PhoneNumberUtil.getInstance());
+
+          DialerPhoneNumber number =
+              dialerPhoneNumberUtil.parse(
+                  TelecomCallUtil.getNumber(call),
+                  TelecomCallUtil.getCountryCode(appContext, call).orNull());
+          return queryNumbers(ImmutableSet.of(number)).get(number);
+        });
+  }
+
+  @Override
+  public ListenableFuture<Boolean> isDirty(ImmutableSet<DialerPhoneNumber> phoneNumbers) {
+    // Dirty state is recorded with PhoneLookupDataSource.markDirtyAndNotify(), which will force
+    // rebuild with the CallLogFramework
+    return Futures.immediateFuture(false);
+  }
+
+  @Override
+  public ListenableFuture<ImmutableMap<DialerPhoneNumber, DialerBlockedNumberInfo>>
+      getMostRecentInfo(ImmutableMap<DialerPhoneNumber, DialerBlockedNumberInfo> existingInfoMap) {
+    LogUtil.enterBlock("DialerBlockedNumberPhoneLookup.getMostRecentPhoneLookupInfo");
+    return executorService.submit(() -> queryNumbers(existingInfoMap.keySet()));
+  }
+
+  @Override
+  public void setSubMessage(
+      PhoneLookupInfo.Builder phoneLookupInfo, DialerBlockedNumberInfo subMessage) {
+    phoneLookupInfo.setDialerBlockedNumberInfo(subMessage);
+  }
+
+  @Override
+  public DialerBlockedNumberInfo getSubMessage(PhoneLookupInfo phoneLookupInfo) {
+    return phoneLookupInfo.getDialerBlockedNumberInfo();
+  }
+
+  @Override
+  public ListenableFuture<Void> onSuccessfulBulkUpdate() {
+    return Futures.immediateFuture(null);
+  }
+
+  @WorkerThread
+  private ImmutableMap<DialerPhoneNumber, DialerBlockedNumberInfo> queryNumbers(
+      ImmutableSet<DialerPhoneNumber> numbers) {
+    Assert.isWorkerThread();
+    PartitionedNumbers partitionedNumbers = new PartitionedNumbers(numbers);
+
+    Set<DialerPhoneNumber> blockedNumbers = new ArraySet<>();
+
+    Selection normalizedSelection =
+        Selection.column(FilteredNumberColumns.NORMALIZED_NUMBER)
+            .in(partitionedNumbers.validE164Numbers());
+    try (Cursor cursor =
+        appContext
+            .getContentResolver()
+            .query(
+                FilteredNumber.CONTENT_URI,
+                new String[] {FilteredNumberColumns.NORMALIZED_NUMBER, FilteredNumberColumns.TYPE},
+                normalizedSelection.getSelection(),
+                normalizedSelection.getSelectionArgs(),
+                null)) {
+      while (cursor != null && cursor.moveToNext()) {
+        if (cursor.getInt(1) == FilteredNumberTypes.BLOCKED_NUMBER) {
+          blockedNumbers.addAll(partitionedNumbers.dialerPhoneNumbersForE164(cursor.getString(0)));
+        }
+      }
+    }
+
+    Selection rawSelection =
+        Selection.column(FilteredNumberColumns.NUMBER)
+            .in(
+                partitionedNumbers
+                    .unformattableNumbers()
+                    .toArray(new String[partitionedNumbers.unformattableNumbers().size()]));
+    try (Cursor cursor =
+        appContext
+            .getContentResolver()
+            .query(
+                FilteredNumber.CONTENT_URI,
+                new String[] {FilteredNumberColumns.NUMBER, FilteredNumberColumns.TYPE},
+                rawSelection.getSelection(),
+                rawSelection.getSelectionArgs(),
+                null)) {
+      while (cursor != null && cursor.moveToNext()) {
+        if (cursor.getInt(1) == FilteredNumberTypes.BLOCKED_NUMBER) {
+          blockedNumbers.addAll(
+              partitionedNumbers.dialerPhoneNumbersForUnformattable(cursor.getString(0)));
+        }
+      }
+    }
+
+    ImmutableMap.Builder<DialerPhoneNumber, DialerBlockedNumberInfo> result =
+        ImmutableMap.builder();
+
+    for (DialerPhoneNumber number : numbers) {
+      result.put(
+          number,
+          DialerBlockedNumberInfo.newBuilder()
+              .setBlockedState(
+                  blockedNumbers.contains(number) ? BlockedState.BLOCKED : BlockedState.NOT_BLOCKED)
+              .build());
+    }
+
+    return result.build();
+  }
+
+  @Override
+  public void registerContentObservers(
+      Context appContext, ContentObserverCallbacks contentObserverCallbacks) {
+    appContext
+        .getContentResolver()
+        .registerContentObserver(
+            FilteredNumber.CONTENT_URI,
+            true, // FilteredNumberProvider notifies on the item
+            new FilteredNumberObserver(appContext, contentObserverCallbacks));
+  }
+
+  private static class FilteredNumberObserver extends ContentObserver {
+    private final Context appContext;
+    private final ContentObserverCallbacks contentObserverCallbacks;
+
+    FilteredNumberObserver(Context appContext, ContentObserverCallbacks contentObserverCallbacks) {
+      super(null);
+      this.appContext = appContext;
+      this.contentObserverCallbacks = contentObserverCallbacks;
+    }
+
+    @MainThread
+    @Override
+    @SuppressWarnings("FutureReturnValueIgnored") // never throws.
+    public void onChange(boolean selfChange, Uri uri) {
+      Assert.isMainThread();
+      LogUtil.enterBlock("DialerBlockedNumberPhoneLookup.FilteredNumberObserver.onChange");
+      contentObserverCallbacks.markDirtyAndNotify(appContext);
+    }
+  }
+}
diff --git a/java/com/android/dialer/phonelookup/composite/CompositePhoneLookup.java b/java/com/android/dialer/phonelookup/composite/CompositePhoneLookup.java
index da4378b..34f3531 100644
--- a/java/com/android/dialer/phonelookup/composite/CompositePhoneLookup.java
+++ b/java/com/android/dialer/phonelookup/composite/CompositePhoneLookup.java
@@ -16,6 +16,8 @@
 
 package com.android.dialer.phonelookup.composite;
 
+import android.content.Context;
+import android.support.annotation.MainThread;
 import android.support.annotation.NonNull;
 import android.telecom.Call;
 import com.android.dialer.DialerPhoneNumber;
@@ -60,7 +62,7 @@
    * <p>Note: If any of the dependent lookups fails, the returned future will also fail. If any of
    * the dependent lookups does not complete, the returned future will also not complete.
    */
-  @SuppressWarnings("unchecked")
+  @SuppressWarnings({"unchecked", "rawtype"})
   @Override
   public ListenableFuture<PhoneLookupInfo> lookup(@NonNull Call call) {
     // TODO(zachh): Add short-circuiting logic so that this call is not blocked on low-priority
@@ -164,4 +166,13 @@
     return Futures.transform(
         Futures.allAsList(futures), unused -> null, lightweightExecutorService);
   }
+
+  @Override
+  @MainThread
+  public void registerContentObservers(
+      Context appContext, ContentObserverCallbacks contentObserverCallbacks) {
+    for (PhoneLookup phoneLookup : phoneLookups) {
+      phoneLookup.registerContentObservers(appContext, contentObserverCallbacks);
+    }
+  }
 }
diff --git a/java/com/android/dialer/phonelookup/cp2/Cp2PhoneLookup.java b/java/com/android/dialer/phonelookup/cp2/Cp2PhoneLookup.java
index 60c934a..307e0a4 100644
--- a/java/com/android/dialer/phonelookup/cp2/Cp2PhoneLookup.java
+++ b/java/com/android/dialer/phonelookup/cp2/Cp2PhoneLookup.java
@@ -37,7 +37,7 @@
 import com.android.dialer.phonelookup.PhoneLookupInfo.Cp2Info;
 import com.android.dialer.phonelookup.PhoneLookupInfo.Cp2Info.Cp2ContactInfo;
 import com.android.dialer.phonelookup.database.contract.PhoneLookupHistoryContract.PhoneLookupHistory;
-import com.android.dialer.phonenumberproto.DialerPhoneNumberUtil;
+import com.android.dialer.phonenumberproto.PartitionedNumbers;
 import com.android.dialer.storage.Unencrypted;
 import com.android.dialer.telecom.TelecomCallUtil;
 import com.google.common.base.Optional;
@@ -45,7 +45,6 @@
 import com.google.common.collect.ImmutableSet;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListeningExecutorService;
-import com.google.i18n.phonenumbers.PhoneNumberUtil;
 import com.google.protobuf.InvalidProtocolBufferException;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -392,6 +391,12 @@
         });
   }
 
+  @Override
+  public void registerContentObservers(
+      Context appContext, ContentObserverCallbacks contentObserverCallbacks) {
+    // Do nothing since CP2 changes are too noisy.
+  }
+
   /**
    * 1. get all contact ids. if the id is unset, add the number to the list of contacts to look up.
    * 2. reduce our list of contact ids to those that were updated after lastModified. 3. Now we have
@@ -475,7 +480,8 @@
     // Divide the numbers into those we can format to E164 and those we can't. Then run separate
     // queries against the contacts table using the NORMALIZED_NUMBER and NUMBER columns.
     // TODO(zachh): These queries are inefficient without a lastModified column to filter on.
-    PartitionedNumbers partitionedNumbers = new PartitionedNumbers(updatedNumbers);
+    PartitionedNumbers partitionedNumbers =
+        new PartitionedNumbers(ImmutableSet.copyOf(updatedNumbers));
     if (!partitionedNumbers.validE164Numbers().isEmpty()) {
       try (Cursor cursor =
           queryPhoneTableBasedOnE164(CP2_INFO_PROJECTION, partitionedNumbers.validE164Numbers())) {
@@ -701,56 +707,4 @@
     }
     return where.toString();
   }
-
-  /**
-   * Divides a set of {@link DialerPhoneNumber DialerPhoneNumbers} by those that can be formatted to
-   * E164 and those that cannot.
-   */
-  private static class PartitionedNumbers {
-    private Map<String, Set<DialerPhoneNumber>> e164NumbersToDialerPhoneNumbers = new ArrayMap<>();
-    private Map<String, Set<DialerPhoneNumber>> unformattableNumbersToDialerPhoneNumbers =
-        new ArrayMap<>();
-
-    PartitionedNumbers(Set<DialerPhoneNumber> dialerPhoneNumbers) {
-      DialerPhoneNumberUtil dialerPhoneNumberUtil =
-          new DialerPhoneNumberUtil(PhoneNumberUtil.getInstance());
-      for (DialerPhoneNumber dialerPhoneNumber : dialerPhoneNumbers) {
-        Optional<String> e164 = dialerPhoneNumberUtil.formatToE164(dialerPhoneNumber);
-        if (e164.isPresent()) {
-          String validE164 = e164.get();
-          Set<DialerPhoneNumber> currentNumbers = e164NumbersToDialerPhoneNumbers.get(validE164);
-          if (currentNumbers == null) {
-            currentNumbers = new ArraySet<>();
-            e164NumbersToDialerPhoneNumbers.put(validE164, currentNumbers);
-          }
-          currentNumbers.add(dialerPhoneNumber);
-        } else {
-          String unformattableNumber = dialerPhoneNumber.getRawInput().getNumber();
-          Set<DialerPhoneNumber> currentNumbers =
-              unformattableNumbersToDialerPhoneNumbers.get(unformattableNumber);
-          if (currentNumbers == null) {
-            currentNumbers = new ArraySet<>();
-            unformattableNumbersToDialerPhoneNumbers.put(unformattableNumber, currentNumbers);
-          }
-          currentNumbers.add(dialerPhoneNumber);
-        }
-      }
-    }
-
-    Set<String> unformattableNumbers() {
-      return unformattableNumbersToDialerPhoneNumbers.keySet();
-    }
-
-    Set<String> validE164Numbers() {
-      return e164NumbersToDialerPhoneNumbers.keySet();
-    }
-
-    Set<DialerPhoneNumber> dialerPhoneNumbersForE164(String e164) {
-      return e164NumbersToDialerPhoneNumbers.get(e164);
-    }
-
-    Set<DialerPhoneNumber> dialerPhoneNumbersForUnformattable(String unformattableNumber) {
-      return unformattableNumbersToDialerPhoneNumbers.get(unformattableNumber);
-    }
-  }
 }
diff --git a/java/com/android/dialer/phonelookup/phone_lookup_info.proto b/java/com/android/dialer/phonelookup/phone_lookup_info.proto
index c42faf4..75423b9 100644
--- a/java/com/android/dialer/phonelookup/phone_lookup_info.proto
+++ b/java/com/android/dialer/phonelookup/phone_lookup_info.proto
@@ -83,4 +83,26 @@
     optional InfoType info_type = 6;
   }
   optional PeopleApiInfo people_api_info = 3;
+
+  // Whether a number is blocked or not. Used by both the system blacklist and
+  // dialer fallback
+  enum BlockedState {
+    UNKNOWN = 0;
+    BLOCKED = 1;
+    NOT_BLOCKED = 2;
+  }
+
+  // Message for the android system BlockedNumber lookup. Available starting in
+  // N.
+  message SystemBlockedNumberInfo {
+    optional BlockedState blocked_state = 1;
+  }
+  optional SystemBlockedNumberInfo system_blocked_number_info = 4;
+
+  // Message for the dialer fallback for blocked number. Used in M or when the
+  // migration to the system has not been completed.
+  message DialerBlockedNumberInfo {
+    optional BlockedState blocked_state = 1;
+  }
+  optional DialerBlockedNumberInfo dialer_blocked_number_info = 5;
 }
\ No newline at end of file
diff --git a/java/com/android/dialer/phonelookup/selector/AndroidManifest.xml b/java/com/android/dialer/phonelookup/selector/AndroidManifest.xml
new file mode 100644
index 0000000..5d836c7
--- /dev/null
+++ b/java/com/android/dialer/phonelookup/selector/AndroidManifest.xml
@@ -0,0 +1,18 @@
+<!--
+ ~ Copyright (C) 2018 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
+ -->
+<manifest
+    package="com.android.dialer.phonelookup.selector">
+</manifest>
diff --git a/java/com/android/dialer/phonelookup/PhoneLookupSelector.java b/java/com/android/dialer/phonelookup/selector/PhoneLookupSelector.java
similarity index 78%
rename from java/com/android/dialer/phonelookup/PhoneLookupSelector.java
rename to java/com/android/dialer/phonelookup/selector/PhoneLookupSelector.java
index c933af7..a960d4e 100644
--- a/java/com/android/dialer/phonelookup/PhoneLookupSelector.java
+++ b/java/com/android/dialer/phonelookup/selector/PhoneLookupSelector.java
@@ -13,13 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License
  */
-package com.android.dialer.phonelookup;
+package com.android.dialer.phonelookup.selector;
 
+import android.content.Context;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
+import android.support.annotation.VisibleForTesting;
+import com.android.dialer.inject.ApplicationContext;
+import com.android.dialer.phonelookup.PhoneLookup;
+import com.android.dialer.phonelookup.PhoneLookupInfo;
+import com.android.dialer.phonelookup.PhoneLookupInfo.BlockedState;
 import com.android.dialer.phonelookup.PhoneLookupInfo.Cp2Info.Cp2ContactInfo;
 import com.android.dialer.phonelookup.PhoneLookupInfo.PeopleApiInfo;
 import com.android.dialer.phonelookup.PhoneLookupInfo.PeopleApiInfo.InfoType;
+import javax.inject.Inject;
 
 /**
  * Prioritizes information from a {@link PhoneLookupInfo}.
@@ -35,12 +42,20 @@
  */
 public final class PhoneLookupSelector {
 
+  private final Context appContext;
+
+  @Inject
+  @VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE)
+  public PhoneLookupSelector(@ApplicationContext Context appContext) {
+    this.appContext = appContext;
+  }
+
   /**
    * Select the name associated with this number. Examples of this are a local contact's name or a
    * business name received from caller ID.
    */
   @NonNull
-  public static String selectName(PhoneLookupInfo phoneLookupInfo) {
+  public String selectName(PhoneLookupInfo phoneLookupInfo) {
     Cp2ContactInfo firstLocalContact = firstLocalContact(phoneLookupInfo);
     if (firstLocalContact != null) {
       String name = firstLocalContact.getName();
@@ -56,7 +71,7 @@
 
   /** Select the photo URI associated with this number. */
   @NonNull
-  public static String selectPhotoUri(PhoneLookupInfo phoneLookupInfo) {
+  public String selectPhotoUri(PhoneLookupInfo phoneLookupInfo) {
     Cp2ContactInfo firstLocalContact = firstLocalContact(phoneLookupInfo);
     if (firstLocalContact != null) {
       String photoUri = firstLocalContact.getPhotoUri();
@@ -68,7 +83,7 @@
   }
 
   /** Select the photo ID associated with this number, or 0 if there is none. */
-  public static long selectPhotoId(PhoneLookupInfo phoneLookupInfo) {
+  public long selectPhotoId(PhoneLookupInfo phoneLookupInfo) {
     Cp2ContactInfo firstLocalContact = firstLocalContact(phoneLookupInfo);
     if (firstLocalContact != null) {
       long photoId = firstLocalContact.getPhotoId();
@@ -81,7 +96,7 @@
 
   /** Select the lookup URI associated with this number. */
   @NonNull
-  public static String selectLookupUri(PhoneLookupInfo phoneLookupInfo) {
+  public String selectLookupUri(PhoneLookupInfo phoneLookupInfo) {
     Cp2ContactInfo firstLocalContact = firstLocalContact(phoneLookupInfo);
     if (firstLocalContact != null) {
       String lookupUri = firstLocalContact.getLookupUri();
@@ -97,7 +112,11 @@
    * set by the user.
    */
   @NonNull
-  public static String selectNumberLabel(PhoneLookupInfo phoneLookupInfo) {
+  public String selectNumberLabel(PhoneLookupInfo phoneLookupInfo) {
+    if (isBlocked(phoneLookupInfo)) {
+      return appContext.getString(R.string.blocked_number_new_call_log_label);
+    }
+
     Cp2ContactInfo firstLocalContact = firstLocalContact(phoneLookupInfo);
     if (firstLocalContact != null) {
       String label = firstLocalContact.getLabel();
@@ -135,10 +154,15 @@
    * show a synthesized photo containing photos of both "Mom" and "Dad").
    */
   @Nullable
-  private static Cp2ContactInfo firstLocalContact(PhoneLookupInfo phoneLookupInfo) {
+  private Cp2ContactInfo firstLocalContact(PhoneLookupInfo phoneLookupInfo) {
     if (phoneLookupInfo.getCp2Info().getCp2ContactInfoCount() > 0) {
       return phoneLookupInfo.getCp2Info().getCp2ContactInfo(0);
     }
     return null;
   }
+
+  private static boolean isBlocked(PhoneLookupInfo info) {
+    return info.hasDialerBlockedNumberInfo()
+        && info.getDialerBlockedNumberInfo().getBlockedState().equals(BlockedState.BLOCKED);
+  }
 }
diff --git a/java/com/android/dialer/phonelookup/selector/res/values/strings.xml b/java/com/android/dialer/phonelookup/selector/res/values/strings.xml
new file mode 100644
index 0000000..2080b39
--- /dev/null
+++ b/java/com/android/dialer/phonelookup/selector/res/values/strings.xml
@@ -0,0 +1,22 @@
+<!--
+  ~ Copyright (C) 2018 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
+  -->
+
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+
+  <!-- Label under the name of a blocked number in the call log. [CHAR LIMIT=15] -->
+  <string name="blocked_number_new_call_log_label">Blocked</string>
+
+</resources>
diff --git a/java/com/android/dialer/phonenumberproto/PartitionedNumbers.java b/java/com/android/dialer/phonenumberproto/PartitionedNumbers.java
new file mode 100644
index 0000000..372f21e
--- /dev/null
+++ b/java/com/android/dialer/phonenumberproto/PartitionedNumbers.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2018 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.phonenumberproto;
+
+import android.support.annotation.NonNull;
+import android.support.annotation.WorkerThread;
+import android.support.v4.util.ArrayMap;
+import android.support.v4.util.ArraySet;
+import com.android.dialer.DialerPhoneNumber;
+import com.android.dialer.common.Assert;
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.i18n.phonenumbers.PhoneNumberUtil;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Divides a set of {@link DialerPhoneNumber DialerPhoneNumbers} by those that can be formatted to
+ * E164 and those that cannot.
+ */
+public final class PartitionedNumbers {
+  private final ImmutableMap<String, ImmutableSet<DialerPhoneNumber>>
+      e164NumbersToDialerPhoneNumbers;
+  private final ImmutableMap<String, ImmutableSet<DialerPhoneNumber>>
+      unformattableNumbersToDialerPhoneNumbers;
+
+  @WorkerThread
+  public PartitionedNumbers(@NonNull ImmutableSet<DialerPhoneNumber> dialerPhoneNumbers) {
+    Assert.isWorkerThread();
+    DialerPhoneNumberUtil dialerPhoneNumberUtil =
+        new DialerPhoneNumberUtil(PhoneNumberUtil.getInstance());
+    Map<String, Set<DialerPhoneNumber>> e164MapBuilder = new ArrayMap<>();
+    Map<String, Set<DialerPhoneNumber>> unformattableMapBuilder = new ArrayMap<>();
+
+    for (DialerPhoneNumber dialerPhoneNumber : dialerPhoneNumbers) {
+      Optional<String> e164 = dialerPhoneNumberUtil.formatToE164(dialerPhoneNumber);
+      if (e164.isPresent()) {
+        String validE164 = e164.get();
+        Set<DialerPhoneNumber> currentNumbers = e164MapBuilder.get(validE164);
+        if (currentNumbers == null) {
+          currentNumbers = new ArraySet<>();
+          e164MapBuilder.put(validE164, currentNumbers);
+        }
+        currentNumbers.add(dialerPhoneNumber);
+      } else {
+        String unformattableNumber = dialerPhoneNumber.getRawInput().getNumber();
+        Set<DialerPhoneNumber> currentNumbers = unformattableMapBuilder.get(unformattableNumber);
+        if (currentNumbers == null) {
+          currentNumbers = new ArraySet<>();
+          unformattableMapBuilder.put(unformattableNumber, currentNumbers);
+        }
+        currentNumbers.add(dialerPhoneNumber);
+      }
+    }
+
+    e164NumbersToDialerPhoneNumbers = makeImmutable(e164MapBuilder);
+    unformattableNumbersToDialerPhoneNumbers = makeImmutable(unformattableMapBuilder);
+  }
+
+  /** Returns the set of formatted number from the original DialerPhoneNumbers */
+  @NonNull
+  public ImmutableSet<String> unformattableNumbers() {
+    return unformattableNumbersToDialerPhoneNumbers.keySet();
+  }
+
+  /** Returns the set of raw number that is unformattable from the original DialerPhoneNumbers */
+  @NonNull
+  public ImmutableSet<String> validE164Numbers() {
+    return e164NumbersToDialerPhoneNumbers.keySet();
+  }
+
+  /**
+   * Returns the corresponding set of original DialerPhoneNumber that maps to the e.164 number, or
+   * an empty set if the number is not found.
+   */
+  @NonNull
+  public ImmutableSet<DialerPhoneNumber> dialerPhoneNumbersForE164(String e164) {
+    return Assert.isNotNull(e164NumbersToDialerPhoneNumbers.get(e164));
+  }
+
+  /**
+   * Returns the corresponding set of original DialerPhoneNumber that maps to the unformattable
+   * number returned by {@link #unformattableNumbers()}, or an empty set if the number is not found.
+   */
+  @NonNull
+  public ImmutableSet<DialerPhoneNumber> dialerPhoneNumbersForUnformattable(
+      String unformattableNumber) {
+    return Assert.isNotNull(unformattableNumbersToDialerPhoneNumbers.get(unformattableNumber));
+  }
+
+  private static <K, V> ImmutableMap<K, ImmutableSet<V>> makeImmutable(
+      Map<K, Set<V>> mutableMapOfSet) {
+    ImmutableMap.Builder<K, ImmutableSet<V>> mapBuilder = ImmutableMap.builder();
+    for (Map.Entry<K, Set<V>> entry : mutableMapOfSet.entrySet()) {
+      mapBuilder.put(entry.getKey(), ImmutableSet.copyOf(entry.getValue()));
+    }
+    return mapBuilder.build();
+  }
+}
diff --git a/java/com/android/dialer/telecom/TelecomCallUtil.java b/java/com/android/dialer/telecom/TelecomCallUtil.java
index b877a73..7d71b4b 100644
--- a/java/com/android/dialer/telecom/TelecomCallUtil.java
+++ b/java/com/android/dialer/telecom/TelecomCallUtil.java
@@ -103,20 +103,27 @@
   @WorkerThread
   public static Optional<String> getE164Number(Context appContext, Call call) {
     Assert.isWorkerThread();
-    PhoneAccountHandle phoneAccountHandle = call.getDetails().getAccountHandle();
-    Optional<SubscriptionInfo> subscriptionInfo =
-        TelecomUtil.getSubscriptionInfo(appContext, phoneAccountHandle);
     String rawNumber = getNumber(call);
     if (TextUtils.isEmpty(rawNumber)) {
       return Optional.absent();
     }
-    String countryCode =
-        subscriptionInfo.isPresent() ? subscriptionInfo.get().getCountryIso() : null;
-    if (countryCode == null) {
+    Optional<String> countryCode = getCountryCode(appContext, call);
+    if (!countryCode.isPresent()) {
       LogUtil.w("TelecomCallUtil.getE164Number", "couldn't find a country code for call");
       return Optional.absent();
     }
-    return Optional.fromNullable(
-        PhoneNumberUtils.formatNumberToE164(rawNumber, countryCode.toUpperCase(Locale.US)));
+    return Optional.fromNullable(PhoneNumberUtils.formatNumberToE164(rawNumber, countryCode.get()));
+  }
+
+  @WorkerThread
+  public static Optional<String> getCountryCode(Context appContext, Call call) {
+    Assert.isWorkerThread();
+    PhoneAccountHandle phoneAccountHandle = call.getDetails().getAccountHandle();
+    Optional<SubscriptionInfo> subscriptionInfo =
+        TelecomUtil.getSubscriptionInfo(appContext, phoneAccountHandle);
+    if (subscriptionInfo.isPresent() && subscriptionInfo.get().getCountryIso() != null) {
+      return Optional.of(subscriptionInfo.get().getCountryIso().toUpperCase(Locale.US));
+    }
+    return Optional.absent();
   }
 }
diff --git a/packages.mk b/packages.mk
index a1cf7fc..03268fd 100644
--- a/packages.mk
+++ b/packages.mk
@@ -39,6 +39,7 @@
 	com.android.dialer.notification \
 	com.android.dialer.oem \
 	com.android.dialer.phonelookup.database \
+	com.android.dialer.phonelookup.selector \
 	com.android.dialer.phonenumberutil \
 	com.android.dialer.postcall \
 	com.android.dialer.precall.impl \