diff --git a/service/Android.mk b/service/Android.mk
index 78c2dea..b00af1a 100644
--- a/service/Android.mk
+++ b/service/Android.mk
@@ -23,6 +23,9 @@
 	common/bluetooth/advertise_data.cpp \
 	common/bluetooth/advertise_settings.cpp \
 	common/bluetooth/gatt_identifier.cpp \
+	common/bluetooth/scan_filter.cpp \
+	common/bluetooth/scan_result.cpp \
+	common/bluetooth/scan_settings.cpp \
 	common/bluetooth/util/address_helper.cpp \
 	common/bluetooth/util/atomic_string.cpp \
 	common/bluetooth/uuid.cpp
diff --git a/service/common/bluetooth/binder/parcel_helpers.cpp b/service/common/bluetooth/binder/parcel_helpers.cpp
index d6d1cd9..141f940 100644
--- a/service/common/bluetooth/binder/parcel_helpers.cpp
+++ b/service/common/bluetooth/binder/parcel_helpers.cpp
@@ -16,10 +16,17 @@
 
 #include "service/common/bluetooth/binder/parcel_helpers.h"
 
+#include "service/common/bluetooth/util/address_helper.h"
+
 using android::Parcel;
 
 using bluetooth::AdvertiseData;
 using bluetooth::AdvertiseSettings;
+using bluetooth::GattIdentifier;
+using bluetooth::ScanFilter;
+using bluetooth::ScanResult;
+using bluetooth::ScanSettings;
+using bluetooth::UUID;
 
 namespace ipc {
 namespace binder {
@@ -85,13 +92,13 @@
       new AdvertiseSettings(mode, timeout, tx_power, connectable));
 }
 
-void WriteUUIDToParcel(const bluetooth::UUID& uuid, android::Parcel* parcel) {
+void WriteUUIDToParcel(const UUID& uuid, android::Parcel* parcel) {
   // The scheme used by android.os.ParcelUuid is to wrote the most significant
   // bits first as one 64-bit integer, followed by the least significant bits in
   // a second 64-bit integer. This is the same as writing the raw-bytes in
   // sequence, but we don't want to assume any host-endianness here. So follow
   // the same scheme and use the same Parcel APIs.
-  bluetooth::UUID::UUID128Bit bytes = uuid.GetFullBigEndian();
+  UUID::UUID128Bit bytes = uuid.GetFullBigEndian();
 
   uint64_t most_sig_bits =
       ((((uint64_t) bytes[0]) << 56) |
@@ -117,9 +124,9 @@
   parcel->writeUint64(least_sig_bits);
 }
 
-std::unique_ptr<bluetooth::UUID> CreateUUIDFromParcel(
+std::unique_ptr<UUID> CreateUUIDFromParcel(
     const android::Parcel& parcel) {
-  bluetooth::UUID::UUID128Bit bytes;
+  UUID::UUID128Bit bytes;
 
   uint64_t most_sig_bits = parcel.readUint64();
   uint64_t least_sig_bits = parcel.readUint64();
@@ -142,11 +149,11 @@
   bytes[14] = (least_sig_bits >> 8) & 0xFF;
   bytes[15] = least_sig_bits & 0xFF;
 
-  return std::unique_ptr<bluetooth::UUID>(new bluetooth::UUID(bytes));
+  return std::unique_ptr<UUID>(new UUID(bytes));
 }
 
 void WriteGattIdentifierToParcel(
-    const bluetooth::GattIdentifier& gatt_id,
+    const GattIdentifier& gatt_id,
     android::Parcel* parcel) {
   parcel->writeCString(gatt_id.device_address().c_str());
   parcel->writeInt32(gatt_id.is_primary());
@@ -160,7 +167,7 @@
   parcel->writeInt32(gatt_id.descriptor_instance_id());
 }
 
-std::unique_ptr<bluetooth::GattIdentifier> CreateGattIdentifierFromParcel(
+std::unique_ptr<GattIdentifier> CreateGattIdentifierFromParcel(
     const android::Parcel& parcel) {
   std::string device_address = parcel.readCString();
   bool is_primary = parcel.readInt32();
@@ -173,12 +180,152 @@
   int char_id = parcel.readInt32();
   int desc_id = parcel.readInt32();
 
-  return std::unique_ptr<bluetooth::GattIdentifier>(
-      new bluetooth::GattIdentifier(
+  return std::unique_ptr<GattIdentifier>(
+      new GattIdentifier(
           device_address, is_primary,
           *service_uuid, *char_uuid, *desc_uuid,
           service_id, char_id, desc_id));
 }
 
+void WriteScanFilterToParcel(
+    const ScanFilter& filter,
+    android::Parcel* parcel) {
+  bool has_name = !filter.device_name().empty();
+  parcel->writeInt32(has_name ? 1 : 0);
+  if (has_name)
+    parcel->writeCString(filter.device_name().c_str());
+
+  bool has_address = !filter.device_address().empty();
+  parcel->writeInt32(has_address ? 1 : 0);
+  if (has_address)
+    parcel->writeCString(filter.device_address().c_str());
+
+  parcel->writeInt32(filter.service_uuid() ? 1 : 0);
+  if (filter.service_uuid()) {
+    WriteUUIDToParcel(*filter.service_uuid(), parcel);
+    parcel->writeInt32(filter.service_uuid_mask() ? 1 : 0);
+    if (filter.service_uuid_mask())
+      WriteUUIDToParcel(*filter.service_uuid_mask(), parcel);
+  }
+
+  // TODO(armansito): Support service and manufacturer data.
+}
+
+std::unique_ptr<ScanFilter> CreateScanFilterFromParcel(
+    const android::Parcel& parcel) {
+  std::string device_name;
+  if (parcel.readInt32() == 1)
+    device_name = parcel.readCString();
+
+  std::string device_address;
+  if (parcel.readInt32() == 1)
+    device_address = parcel.readCString();
+
+  std::unique_ptr<UUID> service_uuid, service_uuid_mask;
+  if (parcel.readInt32() == 1) {
+    service_uuid = CreateUUIDFromParcel(parcel);
+    if (parcel.readInt32() == 1)
+      service_uuid_mask = CreateUUIDFromParcel(parcel);
+  }
+
+  // TODO(armansito): Support service and manufacturer data.
+
+  std::unique_ptr<ScanFilter> filter(new ScanFilter());
+
+  filter->set_device_name(device_name);
+
+  if (!filter->SetDeviceAddress(device_address))
+    return nullptr;
+
+  if (!service_uuid)
+    return filter;
+
+  if (service_uuid_mask)
+    filter->SetServiceUuidWithMask(*service_uuid, *service_uuid_mask);
+  else
+    filter->SetServiceUuid(*service_uuid);
+
+  return filter;
+}
+
+void WriteScanSettingsToParcel(
+    const ScanSettings& settings,
+    android::Parcel* parcel) {
+  parcel->writeInt32(settings.mode());
+  parcel->writeInt32(settings.callback_type());
+  parcel->writeInt32(settings.result_type());
+  parcel->writeInt64(settings.report_delay().InMilliseconds());
+  parcel->writeInt32(settings.match_mode());
+  parcel->writeInt32(settings.match_count_per_filter());
+}
+
+std::unique_ptr<ScanSettings> CreateScanSettingsFromParcel(
+    const android::Parcel& parcel) {
+  ScanSettings::Mode mode =
+      static_cast<ScanSettings::Mode>(parcel.readInt32());
+  ScanSettings::CallbackType callback_type =
+      static_cast<ScanSettings::CallbackType>(parcel.readInt32());
+  ScanSettings::ResultType result_type =
+      static_cast<ScanSettings::ResultType>(parcel.readInt32());
+  base::TimeDelta report_delay = base::TimeDelta::FromMilliseconds(
+      parcel.readInt64());
+  ScanSettings::MatchMode match_mode =
+      static_cast<ScanSettings::MatchMode>(parcel.readInt32());
+  ScanSettings::MatchCount match_count_per_filter =
+      static_cast<ScanSettings::MatchCount>(parcel.readInt32());
+
+  return std::unique_ptr<ScanSettings>(new ScanSettings(
+      mode, callback_type, result_type, report_delay,
+      match_mode, match_count_per_filter));
+}
+
+void WriteScanResultToParcel(
+    const bluetooth::ScanResult& scan_result,
+    android::Parcel* parcel) {
+  // The Java framework code conditionally inserts 1 or 0 to indicate if the
+  // device adress and the scan record fields are present, based on whether the
+  // Java object is null. We do something similar here for consistency, although
+  // the native definition of ScanResult requires a valid BD_ADDR.
+  if (util::IsAddressValid(scan_result.device_address())) {
+    parcel->writeInt32(1);
+    parcel->writeCString(scan_result.device_address().c_str());
+  } else {
+    parcel->writeInt32(0);
+  }
+
+  if (!scan_result.scan_record().empty()) {
+    parcel->writeInt32(1);
+    parcel->writeByteArray(scan_result.scan_record().size(),
+                          scan_result.scan_record().data());
+  } else {
+    parcel->writeInt32(0);
+  }
+
+  parcel->writeInt32(scan_result.rssi());
+}
+
+std::unique_ptr<bluetooth::ScanResult> CreateScanResultFromParcel(
+    const android::Parcel& parcel) {
+  std::string device_address;
+  if (parcel.readInt32())
+    device_address = parcel.readCString();
+
+  std::vector<uint8_t> scan_record;
+  if (parcel.readInt32()) {
+    int record_len = parcel.readInt32();
+    if (record_len != -1) {
+      uint8_t bytes[record_len];
+      parcel.read(bytes, record_len);
+
+      scan_record = std::vector<uint8_t>(bytes, bytes + record_len);
+    }
+  }
+
+  int rssi = parcel.readInt32();
+
+  return std::unique_ptr<ScanResult>(new ScanResult(
+      device_address, scan_record, rssi));
+}
+
 }  // namespace binder
 }  // namespace ipc
diff --git a/service/common/bluetooth/binder/parcel_helpers.h b/service/common/bluetooth/binder/parcel_helpers.h
index b96ea9b..a4c1073 100644
--- a/service/common/bluetooth/binder/parcel_helpers.h
+++ b/service/common/bluetooth/binder/parcel_helpers.h
@@ -23,11 +23,17 @@
 #include <bluetooth/advertise_data.h>
 #include <bluetooth/advertise_settings.h>
 #include <bluetooth/gatt_identifier.h>
+#include <bluetooth/scan_filter.h>
+#include <bluetooth/scan_result.h>
+#include <bluetooth/scan_settings.h>
 #include <bluetooth/uuid.h>
 
 namespace ipc {
 namespace binder {
 
+// Java Parcel meta-data constants.
+const int kParcelValList = 11;
+
 // Helpers for converting bluetooth::AdvertiseData to/from Parcel
 
 void WriteAdvertiseDataToParcel(
@@ -62,5 +68,32 @@
 std::unique_ptr<bluetooth::GattIdentifier> CreateGattIdentifierFromParcel(
     const android::Parcel& parcel);
 
+// Helpers for converting bluetooth::ScanFilter to/from Parcel
+
+void WriteScanFilterToParcel(
+    const bluetooth::ScanFilter& filter,
+    android::Parcel* parcel);
+
+std::unique_ptr<bluetooth::ScanFilter> CreateScanFilterFromParcel(
+    const android::Parcel& parcel);
+
+// Helpers for converting bluetooth::ScanSettings to/from Parcel
+
+void WriteScanSettingsToParcel(
+    const bluetooth::ScanSettings& settings,
+    android::Parcel* parcel);
+
+std::unique_ptr<bluetooth::ScanSettings> CreateScanSettingsFromParcel(
+    const android::Parcel& parcel);
+
+// Helpers for converting bluetooth::ScanResult to/from Parcel
+
+void WriteScanResultToParcel(
+    const bluetooth::ScanResult& scan_result,
+    android::Parcel* parcel);
+
+std::unique_ptr<bluetooth::ScanResult> CreateScanResultFromParcel(
+    const android::Parcel& parcel);
+
 }  // namespace binder
 }  // namespace ipc
diff --git a/service/common/bluetooth/scan_filter.cpp b/service/common/bluetooth/scan_filter.cpp
new file mode 100644
index 0000000..beeeedc
--- /dev/null
+++ b/service/common/bluetooth/scan_filter.cpp
@@ -0,0 +1,98 @@
+//
+//  Copyright (C) 2015 Google, Inc.
+//
+//  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.
+//
+
+#include "service/common/bluetooth/scan_filter.h"
+
+#include "service/common/bluetooth/util/address_helper.h"
+
+namespace bluetooth {
+
+ScanFilter::ScanFilter(const ScanFilter& other) {
+  device_name_ = other.device_name_;
+  device_address_ = other.device_address_;
+
+  if (other.service_uuid_)
+    service_uuid_.reset(new UUID(*other.service_uuid_));
+
+  if (other.service_uuid_mask_)
+    service_uuid_mask_.reset(new UUID(*other.service_uuid_mask_));
+}
+
+ScanFilter& ScanFilter::operator=(const ScanFilter& other) {
+  device_name_ = other.device_name_;
+  device_address_ = other.device_address_;
+
+  if (other.service_uuid_)
+    service_uuid_.reset(new UUID(*other.service_uuid_));
+  else
+    service_uuid_ = nullptr;
+
+  if (other.service_uuid_mask_)
+    service_uuid_mask_.reset(new UUID(*other.service_uuid_mask_));
+  else
+    service_uuid_mask_ = nullptr;
+
+  return *this;
+}
+
+bool ScanFilter::SetDeviceAddress(const std::string& device_address) {
+  if (!util::IsAddressValid(device_address))
+    return false;
+
+  device_address_ = device_address;
+  return true;
+}
+
+void ScanFilter::SetServiceUuid(const UUID& service_uuid) {
+  service_uuid_.reset(new UUID(service_uuid));
+  service_uuid_mask_.reset();
+}
+
+void ScanFilter::SetServiceUuidWithMask(const UUID& service_uuid,
+                                        const UUID& mask) {
+  service_uuid_.reset(new UUID(service_uuid));
+  service_uuid_mask_.reset(new UUID(mask));
+}
+
+bool ScanFilter::operator==(const ScanFilter& rhs) const {
+  if (device_name_ != rhs.device_name_)
+    return false;
+
+  if (device_address_ != rhs.device_address_)
+    return false;
+
+  // Both must be either NULL or non-NULL. If only one of them is NULL, then
+  // return false.
+  if (!!service_uuid_ != !!rhs.service_uuid_)
+    return false;
+
+  if (service_uuid_ && rhs.service_uuid_ &&
+      *service_uuid_ != *rhs.service_uuid_)
+    return false;
+
+  // Both must be either NULL or non-NULL. If only one of them is NULL, then
+  // return false.
+  if (!!service_uuid_mask_ != !!rhs.service_uuid_mask_)
+    return false;
+
+  if (service_uuid_mask_ && rhs.service_uuid_mask_ &&
+      *service_uuid_mask_ != *rhs.service_uuid_mask_)
+    return false;
+
+  return true;
+}
+
+}  // namespace bluetooth
diff --git a/service/common/bluetooth/scan_filter.h b/service/common/bluetooth/scan_filter.h
new file mode 100644
index 0000000..5812b26
--- /dev/null
+++ b/service/common/bluetooth/scan_filter.h
@@ -0,0 +1,77 @@
+//
+//  Copyright (C) 2015 Google, Inc.
+//
+//  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.
+//
+
+#pragma once
+
+#include <memory>
+
+#include <bluetooth/uuid.h>
+
+namespace bluetooth {
+
+// Used for filtering scan results by allowing clients to restrict scan results
+// to only those that are of interest to them.
+class ScanFilter {
+ public:
+  ScanFilter() = default;
+  ~ScanFilter() = default;
+
+  // Copy constructor and assignment operator.
+  ScanFilter(const ScanFilter& other);
+  ScanFilter& operator=(const ScanFilter& other);
+
+  // The device name used while filtering scan results.
+  const std::string& device_name() const { return device_name_; }
+  void set_device_name(const std::string& name) { device_name_ = name; }
+
+  // The device address used while filtering scan results. Address should be in
+  // the XX:XX:XX:XX:XX:XX where X is a hexadecimal digit.
+  const std::string& device_address() const { return device_address_; }
+
+  // Sets the device address used for filtering. Returns false if
+  // |device_address| is in an illegal format.
+  bool SetDeviceAddress(const std::string& device_address);
+
+  // The service UUID and its mask used while filtering scan results. See
+  // SetServiceUuidWithMask for what this mask does. The raw pointer returned
+  // from these getters belongs to the ScanFilter object. nullptr will be
+  // returned if these fields have not been set on this filter.
+  UUID* service_uuid() const { return service_uuid_.get(); }
+  UUID* service_uuid_mask() const { return service_uuid_mask_.get(); }
+
+  // Sets the service UUID for this filter.
+  void SetServiceUuid(const UUID& service_uuid);
+
+  // Sets the service UUID for this filter with a 128-bit mask. The mask allows
+  // the caller to partially filter scanned service UUIDs. For any of the
+  // 128-bits of a UUID, set the corresponding bit in the mask to 1 to match the
+  // advertised value, and 0 to ignore that bit.
+  void SetServiceUuidWithMask(const UUID& service_uuid, const UUID& mask);
+
+  // Comparison operator.
+  bool operator==(const ScanFilter& rhs) const;
+
+ private:
+  std::string device_name_;
+  std::string device_address_;
+
+  std::unique_ptr<UUID> service_uuid_;
+  std::unique_ptr<UUID> service_uuid_mask_;
+
+  // TODO(armansito): Add service and manufacturer data filter fields.
+};
+
+}  // namespace bluetooth
diff --git a/service/common/bluetooth/scan_result.cpp b/service/common/bluetooth/scan_result.cpp
new file mode 100644
index 0000000..7656778
--- /dev/null
+++ b/service/common/bluetooth/scan_result.cpp
@@ -0,0 +1,49 @@
+//
+//  Copyright (C) 2015 Google, Inc.
+//
+//  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.
+//
+
+#include "service/common/bluetooth/scan_result.h"
+
+#include <base/logging.h>
+
+#include "service/common/bluetooth/util/address_helper.h"
+
+
+namespace bluetooth {
+
+ScanResult::ScanResult(const std::string& device_address,
+                       const std::vector<uint8_t> scan_record,
+                       int rssi)
+    : device_address_(device_address),
+      scan_record_(scan_record),
+      rssi_(rssi) {
+  CHECK(util::IsAddressValid(device_address)) << "Invalid BD_ADDR given: "
+                                              << device_address;
+}
+
+bool ScanResult::operator==(const ScanResult& rhs) const {
+  if (device_address_ != rhs.device_address_)
+    return false;
+
+  if (scan_record_ != rhs.scan_record_)
+    return false;
+
+  if (rssi_ != rhs.rssi_)
+    return false;
+
+  return true;
+}
+
+}  // namespace bluetooth
diff --git a/service/common/bluetooth/scan_result.h b/service/common/bluetooth/scan_result.h
new file mode 100644
index 0000000..f9fdbf3
--- /dev/null
+++ b/service/common/bluetooth/scan_result.h
@@ -0,0 +1,55 @@
+//
+//  Copyright (C) 2015 Google, Inc.
+//
+//  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.
+//
+
+#pragma once
+
+#include <stdint.h>
+
+#include <string>
+#include <vector>
+
+namespace bluetooth {
+
+// ScanResult represents a single Bluetooth LE device scan result. It
+// encapsulates information about discovered LE devices.
+class ScanResult {
+ public:
+  ScanResult(const std::string& device_address,
+             const std::vector<uint8_t> scan_record,
+             int rssi);
+  ScanResult() = default;
+  ~ScanResult() = default;
+
+  // Returns the remote BD_ADDR associated with this scan result.
+  const std::string& device_address() const { return device_address_; }
+
+  // Returns the scan record (advertising +scan-response data) associated with
+  // this scan result.
+  const std::vector<uint8_t>& scan_record() const { return scan_record_; }
+
+  // Returns the RSSI associated with this scan result.
+  int rssi() const { return rssi_; }
+
+  // Comparison operator.
+  bool operator==(const ScanResult& rhs) const;
+
+ private:
+  std::string device_address_;
+  std::vector<uint8_t> scan_record_;
+  int rssi_;
+};
+
+}  // namespace bluetooth
diff --git a/service/common/bluetooth/scan_settings.cpp b/service/common/bluetooth/scan_settings.cpp
new file mode 100644
index 0000000..2c807c0
--- /dev/null
+++ b/service/common/bluetooth/scan_settings.cpp
@@ -0,0 +1,65 @@
+//
+//  Copyright (C) 2015 Google, Inc.
+//
+//  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.
+//
+
+#include "service/common/bluetooth/scan_settings.h"
+
+namespace bluetooth {
+
+ScanSettings::ScanSettings()
+    : mode_(MODE_LOW_POWER),
+      callback_type_(CALLBACK_TYPE_ALL_MATCHES),
+      result_type_(RESULT_TYPE_FULL),
+      match_count_per_filter_(MATCH_COUNT_MAX_ADVERTISEMENTS) {
+}
+
+ScanSettings::ScanSettings(
+    Mode mode,
+    CallbackTypeBitField callback_type,
+    ResultType result_type,
+    base::TimeDelta report_delay_ms,
+    MatchMode match_mode,
+    MatchCount match_count_per_filter)
+    : mode_(mode),
+      callback_type_(callback_type),
+      result_type_(result_type),
+      report_delay_ms_(report_delay_ms),
+      match_mode_(match_mode),
+      match_count_per_filter_(match_count_per_filter) {
+}
+
+bool ScanSettings::operator==(const ScanSettings& rhs) const {
+  if (mode_ != rhs.mode_)
+    return false;
+
+  if (callback_type_ != rhs.callback_type_)
+    return false;
+
+  if (result_type_ != rhs.result_type_)
+    return false;
+
+  if (report_delay_ms_ != rhs.report_delay_ms_)
+    return false;
+
+  if (match_mode_ != rhs.match_mode_)
+    return false;
+
+  if (match_count_per_filter_ != rhs.match_count_per_filter_)
+    return false;
+
+  return true;
+}
+
+}  // namespace bluetooth
diff --git a/service/common/bluetooth/scan_settings.h b/service/common/bluetooth/scan_settings.h
new file mode 100644
index 0000000..8f183b6
--- /dev/null
+++ b/service/common/bluetooth/scan_settings.h
@@ -0,0 +1,164 @@
+//
+//  Copyright (C) 2015 Google, Inc.
+//
+//  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.
+//
+
+#pragma once
+
+#include <base/time/time.h>
+
+namespace bluetooth {
+
+// ScanSettings encapsulates Bluetooth LE device scan parameters. This is the
+// native equivalent of the Android framework class defined in
+// frameworks/base/core/java/android/bluetooth/le/ScanSettings.java.
+class ScanSettings {
+ public:
+  // A scan mode describes the power consumption involved in LE scans.
+  enum Mode {
+    // A special Bluetooth LE scan mode. Applications using this scan mode will
+    // passively listen for other scan results without starting BLE scans
+    // themselves.
+    MODE_OPPORTUNISTIC = -1,
+
+    // Perform Bluetooth LE scan in low power mode. This is the default scan
+    // mode as it consumes the least power.
+    MODE_LOW_POWER = 0,
+
+    // Perform Bluetooth LE scan in balanced power mode. Scan results are
+    // returned at a rate that provides a good trade-off between scan frequency
+    // and power consumption.
+    MODE_BALANCED = 1,
+
+    // Scan using the highest duty cycle. It's recommended to only use this mode
+    // when the application is running in the foreground.
+    MODE_LOW_LATENCY = 2,
+  };
+
+  // A callback type describes how scan results will be reported to applications
+  // in asynchronous callbacks.
+  enum CallbackType {
+    // Trigger a callback for every Bluetooth advertisement found that matches
+    // the filter criteria. If no filter is active, all advertisement packets
+    // are reported.
+    CALLBACK_TYPE_ALL_MATCHES = 1,
+
+    // A result callback is only triggered for the first advertisement packet
+    // received that matches the filter criteria. This requires that the
+    // hardware support the offloaded filtering feature.
+    CALLBACK_TYPE_FIRST_MATCH = 2,
+
+    // Receive a callback when advertisements are no longer received from a
+    // device that has been previously reported by a first match callback. This
+    // requires that the hardware support the offloaded filtering feature.
+    CALLBACK_TYPE_MATCH_LOST = 4,
+  };
+  using CallbackTypeBitField = int;
+
+  // Determines how many advertisements to match per filter.
+  enum MatchCount {
+    // Match one advertisement per filter.
+    MATCH_COUNT_ONE_ADVERTISEMENT = 1,
+
+    // Match few advertisements per filter depending on the current capability
+    // and availability of hardware resources.
+    MATCH_COUNT_FEW_ADVERTISEMENTS = 2,
+
+    // Match as many advertisements per filter as the underlying hardware can
+    // allow, depending on the current capability and availability of hardware
+    // resources.
+    MATCH_COUNT_MAX_ADVERTISEMENTS = 3,
+  };
+
+  // Hardware filter match mode.
+  enum MatchMode {
+    // In aggressive mode the hardware will determine a match sooner even with
+    // feeble signal strength and a low number of sightings in a duration.
+    MATCH_MODE_AGGRESSIVE = 1,
+
+    // In sticky mode a higher threshold of signal strength and sightings is
+    // required before a scan result is reported by the hardware.
+    MATCH_MODE_STICKY = 2,
+  };
+
+  // Scan result type describes the contents of each scan result.
+  enum ResultType {
+    // Request full scan results which contain the device name, RSSI,
+    // advertising data, scan response data, and the scan timestamp.
+    RESULT_TYPE_FULL = 0,
+
+    // Request abbreviated scan results which contain the device name, RSSI, and
+    // scan timestamp.
+    // Note: It is possible for an application to get more scan results than it
+    // asked for, if there are multiple apps using this type.
+    RESULT_TYPE_ABBREVIATED = 1,
+  };
+
+  // The default constructor sets all fields to defaults:
+  //   mode: MODE_LOW_POWER
+  //   callback_type: CALLBACK_TYPE_ALL_MATCHES
+  //   result_type: RESULT_TYPE_FULL
+  //   report_delay_ms: 0
+  //   match_mode: MATCH_MODE_AGGRESSIVE
+  //   match_count_per_filter: MATCH_COUNT_MAX_ADVERTISEMENTS
+  ScanSettings();
+  ScanSettings(Mode mode,
+               CallbackTypeBitField callback_type,
+               ResultType result_type,
+               base::TimeDelta report_delay_ms,
+               MatchMode match_mode,
+               MatchCount match_count_per_filter);
+  ~ScanSettings() = default;
+
+  // Returns the scan mode.
+  Mode mode() const { return mode_; }
+  void set_mode(Mode mode) { mode_ = mode; }
+
+  // Returns the callback type.
+  CallbackTypeBitField callback_type() const { return callback_type_; }
+  void set_callback_type(CallbackTypeBitField type) { callback_type_ = type; }
+
+  // Returns the scan result type.
+  ResultType result_type() const { return result_type_; }
+  void set_result_type(ResultType type) { result_type_ = type; }
+
+  // Returns the report delay value in milliseconds.
+  const base::TimeDelta& report_delay() const { return report_delay_ms_; }
+  void set_report_delay(const base::TimeDelta& delay) {
+    report_delay_ms_ = delay;
+  }
+
+  // Returns the hardware filter match mode.
+  MatchMode match_mode() const { return match_mode_; }
+  void set_match_mode(MatchMode mode) { match_mode_ = mode; }
+
+  // Returns the count of advertisements to match per filter.
+  MatchCount match_count_per_filter() const { return match_count_per_filter_; }
+  void set_match_count_per_filter(MatchCount count) {
+    match_count_per_filter_ = count;
+  }
+
+  // Comparison operator.
+  bool operator==(const ScanSettings& rhs) const;
+
+ private:
+  Mode mode_;
+  CallbackTypeBitField callback_type_;
+  ResultType result_type_;
+  base::TimeDelta report_delay_ms_;
+  MatchMode match_mode_;
+  MatchCount match_count_per_filter_;
+};
+
+}  // namespace bluetooth
diff --git a/service/common/bluetooth/uuid.cpp b/service/common/bluetooth/uuid.cpp
index e96934d..8a34437 100644
--- a/service/common/bluetooth/uuid.cpp
+++ b/service/common/bluetooth/uuid.cpp
@@ -44,6 +44,20 @@
   return UUID(bytes);
 }
 
+// static
+UUID UUID::GetNil() {
+  UUID128Bit bytes;
+  bytes.fill(0);
+  return UUID(bytes);
+}
+
+// static
+UUID UUID::GetMax() {
+  UUID128Bit bytes;
+  bytes.fill(1);
+  return UUID(bytes);
+}
+
 void UUID::InitializeDefault() {
   // Initialize to Bluetooth SIG base UUID.
   id_ = kSigBaseUUID;
diff --git a/service/common/bluetooth/uuid.h b/service/common/bluetooth/uuid.h
index a88476f..ec89f1e 100644
--- a/service/common/bluetooth/uuid.h
+++ b/service/common/bluetooth/uuid.h
@@ -37,6 +37,12 @@
   // Creates and returns a random 128-bit UUID.
   static UUID GetRandom();
 
+  // Creates and returns a UUID in which all 128 bits are equal to 0.
+  static UUID GetNil();
+
+  // Creates and returns a UUID in which all 128 bits are equal to 1.
+  static UUID GetMax();
+
   // Construct a Bluetooth 'base' UUID.
   UUID();
 
@@ -71,6 +77,9 @@
 
   bool operator<(const UUID& rhs) const;
   bool operator==(const UUID& rhs) const;
+  inline bool operator!=(const UUID& rhs) const {
+    return !(*this == rhs);
+  }
 
  private:
   void InitializeDefault();
diff --git a/service/test/parcel_helpers_unittest.cpp b/service/test/parcel_helpers_unittest.cpp
index f79beec..138f9b5 100644
--- a/service/test/parcel_helpers_unittest.cpp
+++ b/service/test/parcel_helpers_unittest.cpp
@@ -25,6 +25,9 @@
 using bluetooth::AdvertiseData;
 using bluetooth::AdvertiseSettings;
 using bluetooth::GattIdentifier;
+using bluetooth::ScanFilter;
+using bluetooth::ScanResult;
+using bluetooth::ScanSettings;
 using bluetooth::UUID;
 
 namespace ipc {
@@ -71,6 +74,33 @@
   return id_in == *id_out;
 }
 
+bool TestScanSettings(const ScanSettings& settings_in) {
+  Parcel parcel;
+  WriteScanSettingsToParcel(settings_in, &parcel);
+  parcel.setDataPosition(0);
+  auto settings_out = CreateScanSettingsFromParcel(parcel);
+
+  return settings_in == *settings_out;
+}
+
+bool TestScanFilter(const ScanFilter& filter_in) {
+  Parcel parcel;
+  WriteScanFilterToParcel(filter_in, &parcel);
+  parcel.setDataPosition(0);
+  auto filter_out = CreateScanFilterFromParcel(parcel);
+
+  return filter_in == *filter_out;
+}
+
+bool TestScanResult(const ScanResult& result_in) {
+  Parcel parcel;
+  WriteScanResultToParcel(result_in, &parcel);
+  parcel.setDataPosition(0);
+  auto result_out = CreateScanResultFromParcel(parcel);
+
+  return result_in == *result_out;
+}
+
 TEST(ParcelHelpersTest, EmptyAdvertiseData) {
   std::vector<uint8_t> data;
   AdvertiseData adv(data);
@@ -131,6 +161,52 @@
   TestGattIdentifier(*desc_id);
 }
 
+TEST(ParcelHelpersTest, ScanSettings) {
+  ScanSettings settings0;
+  ScanSettings settings1(
+      ScanSettings::MODE_BALANCED,
+      ScanSettings::CALLBACK_TYPE_FIRST_MATCH,
+      ScanSettings::RESULT_TYPE_ABBREVIATED,
+      base::TimeDelta::FromMilliseconds(150),
+      ScanSettings::MATCH_MODE_STICKY,
+      ScanSettings::MATCH_COUNT_FEW_ADVERTISEMENTS);
+
+  EXPECT_TRUE(TestScanSettings(settings0));
+  EXPECT_TRUE(TestScanSettings(settings1));
+}
+
+TEST(ParcelHelpersTest, ScanFilter) {
+  ScanFilter filter;
+
+  filter.set_device_name("Test Device Name");
+  ASSERT_TRUE(filter.SetDeviceAddress("01:02:04:AB:CD:EF"));
+  EXPECT_TRUE(TestScanFilter(filter));
+
+  UUID uuid = UUID::GetRandom();
+  filter.SetServiceUuid(uuid);
+  EXPECT_TRUE(TestScanFilter(filter));
+
+  UUID mask = UUID::GetRandom();
+  filter.SetServiceUuidWithMask(uuid, mask);
+  EXPECT_TRUE(TestScanFilter(filter));
+}
+
+TEST(ParcelHelpersTest, ScanResult) {
+  const char kTestAddress[] = "01:02:03:AB:CD:EF";
+  const char kEmptyAddress[] = "";
+
+  const std::vector<uint8_t> kEmptyBytes;
+  const std::vector<uint8_t> kTestBytes{ 0x01, 0x02, 0x03 };
+
+  const int kTestRssi = 127;
+
+  ScanResult result0(kTestAddress, kEmptyBytes, kTestRssi);
+  ScanResult result1(kTestAddress, kTestBytes, kTestRssi);
+
+  EXPECT_TRUE(TestScanResult(result0));
+  EXPECT_TRUE(TestScanResult(result1));
+}
+
 }  // namespace
 }  // namespace binder
 }  // namespace ipc