Roll forward to cl/338482889

Signed-off-by: Alexey Polyudov <apolyudov@google.com>
Change-Id: Ic2bdb234e89f3c5860d1b483dd4bce689f13d057

cpp/platform/base/BUILD

@@ -0,0 +1,138 @@
+# Copyright 2020 Google LLC
+#
+# 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
+#
+#     https://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.
+
+load("//ads/util/non_compile:non_compile.bzl", "cc_with_non_compile_test")
+
+cc_library(
+    name = "base",
+    srcs = [
+        "base64_utils.cc",
+        "bluetooth_utils.cc",
+        "prng.cc",
+    ],
+    hdrs = [
+        "base64_utils.h",
+        "bluetooth_utils.h",
+        "byte_array.h",
+        "callable.h",
+        "exception.h",
+        "input_stream.h",
+        "listeners.h",
+        "output_stream.h",
+        "payload_id.h",
+        "prng.h",
+        "runnable.h",
+        "socket.h",
+        "types.h",
+    ],
+    visibility = [
+        "//googlemac/iPhone/Shared/Nearby/Connections:__subpackages__",
+        "//core:__subpackages__",
+        "//platform:__subpackages__",
+        "//platform/api:__subpackages__",
+    ],
+    deps = [
+        "//absl/meta:type_traits",
+        "//absl/strings",
+        "//absl/strings:str_format",
+        "//absl/time",
+    ],
+)
+
+cc_library(
+    name = "util",
+    srcs = [
+        "base_input_stream.cc",
+        "base_pipe.cc",
+    ],
+    hdrs = [
+        "base_input_stream.h",
+        "base_mutex_lock.h",
+        "base_pipe.h",
+    ],
+    visibility = [
+        "//googlemac/iPhone/Shared/Nearby/Connections:__subpackages__",
+        "//core:__subpackages__",
+        "//platform/impl:__subpackages__",
+        "//platform/public:__pkg__",
+    ],
+    deps = [
+        ":base",
+        "//platform/api:types",
+        "//absl/base:core_headers",
+    ],
+)
+
+cc_library(
+    name = "logging",
+    hdrs = [
+        "logging.h",
+    ],
+    visibility = [
+        "//googlemac/iPhone/Shared/Nearby/Connections:__subpackages__",
+        "//platform:__subpackages__",
+    ],
+    deps = [
+        "//platform/api:platform",
+        "//platform/api:types",
+    ],
+)
+
+cc_library(
+    name = "test_util",
+    testonly = True,
+    srcs = [
+        "medium_environment.cc",
+    ],
+    hdrs = [
+        "medium_environment.h",
+    ],
+    visibility = [
+        "//core:__subpackages__",
+        "//platform/impl:__subpackages__",
+        "//platform/public:__pkg__",
+    ],
+    deps = [
+        ":base",
+        ":logging",
+        "//platform/api:comm",
+        "//platform/public:types",
+        "//absl/container:flat_hash_map",
+        "//absl/strings",
+    ],
+)
+
+cc_test(
+    name = "platform_base_test",
+    srcs = [
+        "bluetooth_utils_test.cc",
+        "byte_array_test.cc",
+        "prng_test.cc",
+    ],
+    deps = [
+        ":base",
+        "//testing/base/public:gunit_main",
+    ],
+)
+
+cc_with_non_compile_test(
+    name = "exception_test",
+    srcs = [
+        "exception_test.cc",
+    ],
+    deps = [
+        ":base",
+        "//testing/base/public:gunit_main",
+    ],
+)

cpp/platform/base/base64_utils.cc

@@ -0,0 +1,41 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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 "platform/base/base64_utils.h"
+
+#include "platform/base/byte_array.h"
+#include "absl/strings/escaping.h"
+
+namespace location {
+namespace nearby {
+
+std::string Base64Utils::Encode(const ByteArray& bytes) {
+  std::string base64_string;
+
+  absl::WebSafeBase64Escape(std::string(bytes), &base64_string);
+
+  return base64_string;
+}
+
+ByteArray Base64Utils::Decode(absl::string_view base64_string) {
+  std::string decoded_string;
+  if (!absl::WebSafeBase64Unescape(base64_string, &decoded_string)) {
+    return ByteArray();
+  }
+
+  return ByteArray(decoded_string.data(), decoded_string.size());
+}
+
+}  // namespace nearby
+}  // namespace location

cpp/platform/base/base64_utils.h

@@ -0,0 +1,33 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_BASE64_UTILS_H_
+#define PLATFORM_BASE_BASE64_UTILS_H_
+
+#include "platform/base/byte_array.h"
+#include "absl/strings/string_view.h"
+
+namespace location {
+namespace nearby {
+
+class Base64Utils {
+ public:
+  static std::string Encode(const ByteArray& bytes);
+  static ByteArray Decode(absl::string_view base64_string);
+};
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_BASE_BASE64_UTILS_H_

cpp/platform/base/base_input_stream.cc

@@ -0,0 +1,99 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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 "platform/base/base_input_stream.h"
+
+namespace location {
+namespace nearby {
+
+ExceptionOr<ByteArray> BaseInputStream::Read(std::int64_t size) {
+  if (!IsAvailable(size)) {
+    return ExceptionOr<ByteArray>{Exception::kIo};
+  }
+
+  ByteArray read_bytes{static_cast<size_t>(size)};
+  if (read_bytes.CopyAt(/*offset=*/0, buffer_,
+                        /*source_offset=*/position_)) {
+    position_ += size;
+    return ExceptionOr<ByteArray>{read_bytes};
+  } else {
+    return ExceptionOr<ByteArray>{Exception::kIo};
+  }
+}
+
+std::uint8_t BaseInputStream::ReadUint8() {
+  constexpr int byte_size = sizeof(std::uint8_t);
+  ByteArray read_bytes = ReadBytes(byte_size);
+  if (read_bytes.Empty() || read_bytes.size() != byte_size) {
+    return -1;
+  }
+
+  return read_bytes.data()[0];
+}
+
+std::uint16_t BaseInputStream::ReadUint16() {
+  constexpr int byte_size = sizeof(std::uint16_t);
+  ByteArray read_bytes = ReadBytes(byte_size);
+  if (read_bytes.Empty() || read_bytes.size() != byte_size) {
+    return -1;
+  }
+
+  // Convert from network order.
+  const char *data = read_bytes.data();
+  return static_cast<uint16_t>(data[0]) << 8 | static_cast<uint16_t>(data[1]);
+}
+
+std::uint32_t BaseInputStream::ReadUint32() {
+  constexpr int byte_size = sizeof(std::uint32_t);
+  ByteArray read_bytes = ReadBytes(byte_size);
+  if (read_bytes.Empty() || read_bytes.size() != byte_size) {
+    return -1;
+  }
+
+  // Convert from network order.
+  const char *data = read_bytes.data();
+  return static_cast<uint32_t>(data[0]) << 24 |
+         static_cast<uint32_t>(data[1]) << 16 |
+         static_cast<uint32_t>(data[2]) << 8 | static_cast<uint32_t>(data[3]);
+}
+
+std::uint64_t BaseInputStream::ReadUint64() {
+  constexpr int byte_size = sizeof(std::uint64_t);
+  ByteArray read_bytes = ReadBytes(byte_size);
+  if (read_bytes.Empty() || read_bytes.size() != byte_size) {
+    return -1;
+  }
+
+  // Convert from network order.
+  const char *data = read_bytes.data();
+  return static_cast<uint64_t>(data[0]) << 56 |
+         static_cast<uint64_t>(data[1]) << 48 |
+         static_cast<uint64_t>(data[2]) << 40 |
+         static_cast<uint64_t>(data[3]) << 32 |
+         static_cast<uint64_t>(data[4]) << 24 |
+         static_cast<uint64_t>(data[5]) << 16 |
+         static_cast<uint64_t>(data[6]) << 8 | static_cast<uint64_t>(data[7]);
+}
+
+ByteArray BaseInputStream::ReadBytes(int size) {
+  ExceptionOr<ByteArray> read_bytes_result = Read(size);
+  if (!read_bytes_result.ok()) {
+    return ByteArray{};
+  }
+
+  return read_bytes_result.GetResult();
+}
+
+}  // namespace nearby
+}  // namespace location

cpp/platform/base/base_input_stream.h

@@ -0,0 +1,57 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_BASE_INPUT_STREAM_H_
+#define PLATFORM_BASE_BASE_INPUT_STREAM_H_
+
+#include "platform/base/byte_array.h"
+#include "platform/base/exception.h"
+#include "platform/base/input_stream.h"
+
+namespace location {
+namespace nearby {
+
+// A base {@link InputStream } for reading the contents of a byte array.
+class BaseInputStream : public InputStream {
+ public:
+  explicit BaseInputStream(ByteArray &buffer) : buffer_{buffer} {}
+  BaseInputStream(const BaseInputStream &) = delete;
+  BaseInputStream &operator=(const BaseInputStream &) = delete;
+  ~BaseInputStream() override { Close(); }
+
+  ExceptionOr<ByteArray> Read(std::int64_t size) override;
+
+  Exception Close() override {
+    // Do nothing.
+    return {Exception::kSuccess};
+  }
+
+  std::uint8_t ReadUint8();
+  std::uint16_t ReadUint16();
+  std::uint32_t ReadUint32();
+  std::uint64_t ReadUint64();
+  ByteArray ReadBytes(int size);
+  bool IsAvailable(int size) const {
+    return buffer_.size() - position_ >= size;
+  }
+
+ private:
+  ByteArray &buffer_;
+  int position_{0};
+};
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_BASE_BASE_INPUT_STREAM_H_

cpp/platform/base/base_mutex_lock.h

@@ -0,0 +1,40 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_BASE_MUTEX_LOCK_H_
+#define PLATFORM_BASE_BASE_MUTEX_LOCK_H_
+
+#include "platform/api/mutex.h"
+#include "absl/base/thread_annotations.h"
+
+namespace location {
+namespace nearby {
+
+// An RAII mechanism to acquire a Lock over a block of code.
+class ABSL_SCOPED_LOCKABLE BaseMutexLock final {
+ public:
+  explicit BaseMutexLock(api::Mutex* mutex) ABSL_EXCLUSIVE_LOCK_FUNCTION(mutex)
+      : mutex_(mutex) {
+    mutex_->Lock();
+  }
+  ~BaseMutexLock() ABSL_UNLOCK_FUNCTION() { mutex_->Unlock(); }
+
+ private:
+  api::Mutex* mutex_;
+};
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_BASE_BASE_MUTEX_LOCK_H_

cpp/platform/base/base_pipe.cc

@@ -0,0 +1,109 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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 "platform/base/base_pipe.h"
+
+#include "platform/base/base_mutex_lock.h"
+#include "platform/base/input_stream.h"
+#include "platform/base/output_stream.h"
+
+namespace location {
+namespace nearby {
+
+ExceptionOr<ByteArray> BasePipe::Read(size_t size) {
+  BaseMutexLock lock(mutex_.get());
+
+  // We're done reading all the chunks that were written before the OutputStream
+  // was closed, so there's nothing to do here other than return an empty chunk
+  // to serve as an EOF indication to callers.
+  if (read_all_chunks_) {
+    return ExceptionOr<ByteArray>{ByteArray{}};
+  }
+
+  while (buffer_.empty() && !input_stream_closed_) {
+    Exception wait_exception = cond_->Wait();
+
+    if (wait_exception.Raised()) {
+      return ExceptionOr<ByteArray>{wait_exception};
+    }
+  }
+
+  if (input_stream_closed_) {
+    return ExceptionOr<ByteArray>{Exception::kIo};
+  }
+
+  ByteArray first_chunk{buffer_.front()};
+  buffer_.pop_front();
+
+  // If we received our sentinel chunk, mark the fact that there cannot
+  // possibly be any more chunks to read here on in, and return an empty chunk
+  // to serve as an EOF indication to callers.
+  if (first_chunk.Empty()) {
+    read_all_chunks_ = true;
+    return ExceptionOr<ByteArray>{ByteArray{}};
+  }
+
+  // If first_chunk is small enough to not overshoot the requested 'size', just
+  // return that.
+  if (first_chunk.size() <= size) {
+    return ExceptionOr<ByteArray>{first_chunk};
+  } else {
+    // Break first_chunk into 2 parts -- the first one of which (next_chunk)
+    // will be 'size' bytes long, and will be returned, and the second one of
+    // which (overflow_chunk) will be re-inserted into buffer_, at the head of
+    // the queue, to be served up in the next call to read().
+    ByteArray next_chunk(first_chunk.data(), size);
+    buffer_.push_front(
+        ByteArray(first_chunk.data() + size, first_chunk.size() - size));
+    return ExceptionOr<ByteArray>{next_chunk};
+  }
+}
+
+Exception BasePipe::Write(const ByteArray& data) {
+  BaseMutexLock lock(mutex_.get());
+
+  return WriteLocked(data);
+}
+
+void BasePipe::MarkInputStreamClosed() {
+  BaseMutexLock lock(mutex_.get());
+
+  input_stream_closed_ = true;
+  // Trigger cond_ to unblock a potentially-blocked call to read(), and to let
+  // it know to return Exception::IO.
+  cond_->Notify();
+}
+
+void BasePipe::MarkOutputStreamClosed() {
+  BaseMutexLock lock(mutex_.get());
+
+  // Write a sentinel null chunk before marking output_stream_closed as true.
+  WriteLocked(ByteArray{});
+  output_stream_closed_ = true;
+}
+
+Exception BasePipe::WriteLocked(const ByteArray& data) {
+  if (input_stream_closed_ || output_stream_closed_) {
+    return {Exception::kIo};
+  }
+
+  buffer_.push_back(data);
+  // Trigger cond_ to unblock a potentially-blocked call to read(), now that
+  // there's more data for it to consume.
+  cond_->Notify();
+  return {Exception::kSuccess};
+}
+
+}  // namespace nearby
+}  // namespace location

cpp/platform/base/base_pipe.h

@@ -0,0 +1,142 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_BASE_PIPE_H_
+#define PLATFORM_BASE_BASE_PIPE_H_
+
+#include <cstdint>
+#include <deque>
+#include <memory>
+
+#include "platform/api/condition_variable.h"
+#include "platform/api/mutex.h"
+#include "platform/base/byte_array.h"
+#include "platform/base/exception.h"
+#include "platform/base/input_stream.h"
+#include "platform/base/output_stream.h"
+#include "absl/base/thread_annotations.h"
+
+namespace location {
+namespace nearby {
+
+// Common Pipe implenentation.
+// It does not depend on platform implementation, and this allows it to
+// be used in the platform implementation itself.
+// Concrete class must be derived from it, as follows:
+//
+// class DerivedPipe : public BasePipe {
+//  public:
+//   DerivedPipe() {
+//     auto mutex = /* construct platform-dependent mutex */;
+//     auto cond = /* construct platform-dependent condition variable */;
+//     Setup(std::move(mutex), std::move(cond));
+//   }
+//   ~DerivedPipe() override = default;
+//   DerivedPipe(DerivedPipe&&) = default;
+//   DerivedPipe& operator=(DerivedPipe&&) = default;
+// };
+class BasePipe {
+ public:
+  static constexpr const size_t kChunkSize = 64 * 1024;
+  virtual ~BasePipe() = default;
+
+  // Pipe is not copyable or movable, because copy/move will invalidate
+  // references to input and output streams.
+  // If move is required, Pipe could be wrapped with std::unique_ptr<>.
+  BasePipe(BasePipe&&) = delete;
+  BasePipe& operator=(BasePipe&&) = delete;
+
+  // Get...() methods return references to input and output steam facades.
+  // It is safe to call Get...() methods multiple times.
+  InputStream& GetInputStream() { return input_stream_; }
+  OutputStream& GetOutputStream() { return output_stream_; }
+
+ protected:
+  BasePipe() = default;
+
+  void Setup(std::unique_ptr<api::Mutex> mutex,
+             std::unique_ptr<api::ConditionVariable> cond) {
+    mutex_ = std::move(mutex);
+    cond_ = std::move(cond);
+  }
+
+ private:
+  class BasePipeInputStream : public InputStream {
+   public:
+    explicit BasePipeInputStream(BasePipe* pipe) : pipe_(pipe) {}
+    ~BasePipeInputStream() override { DoClose(); }
+
+    ExceptionOr<ByteArray> Read(std::int64_t size) override {
+      return pipe_->Read(size);
+    }
+    Exception Close() override {
+      return DoClose();
+    }
+
+   private:
+    Exception DoClose() {
+      pipe_->MarkInputStreamClosed();
+      return {Exception::kSuccess};
+    }
+    BasePipe* pipe_;
+  };
+  class BasePipeOutputStream : public OutputStream {
+   public:
+    explicit BasePipeOutputStream(BasePipe* pipe) : pipe_(pipe) {}
+    ~BasePipeOutputStream() override { DoClose(); }
+
+    Exception Write(const ByteArray& data) override {
+      return pipe_->Write(data);
+    }
+    Exception Flush() override { return {Exception::kSuccess}; }
+    Exception Close() override {
+      return DoClose();
+    }
+
+   private:
+    Exception DoClose() {
+      pipe_->MarkOutputStreamClosed();
+      return {Exception::kSuccess};
+    }
+    BasePipe* pipe_;
+  };
+
+  ExceptionOr<ByteArray> Read(size_t size) ABSL_LOCKS_EXCLUDED(mutex_);
+  Exception Write(const ByteArray& data) ABSL_LOCKS_EXCLUDED(mutex_);
+
+  void MarkInputStreamClosed() ABSL_LOCKS_EXCLUDED(mutex_);
+  void MarkOutputStreamClosed() ABSL_LOCKS_EXCLUDED(mutex_);
+
+  Exception WriteLocked(const ByteArray& data)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Order of declaration matters:
+  // - mutex must be defined before condvar;
+  // - input & output streams must be after both mutex and condvar.
+  bool input_stream_closed_ ABSL_GUARDED_BY(mutex_) = false;
+  bool output_stream_closed_ ABSL_GUARDED_BY(mutex_) = false;
+  bool read_all_chunks_ ABSL_GUARDED_BY(mutex_) = false;
+
+  std::deque<ByteArray> ABSL_GUARDED_BY(mutex_) buffer_;
+  std::unique_ptr<api::Mutex> mutex_;
+  std::unique_ptr<api::ConditionVariable> cond_;
+
+  BasePipeInputStream input_stream_{this};
+  BasePipeOutputStream output_stream_{this};
+};
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_BASE_BASE_PIPE_H_

cpp/platform/base/bluetooth_utils.cc

@@ -0,0 +1,75 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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 "platform/base/bluetooth_utils.h"
+
+#include "absl/strings/escaping.h"
+#include "absl/strings/str_format.h"
+
+namespace location {
+namespace nearby {
+
+std::string BluetoothUtils::ToString(const ByteArray& bluetooth_mac_address) {
+  std::string colon_delimited_string;
+
+  if (bluetooth_mac_address.size() != kBluetoothMacAddressLength)
+    return colon_delimited_string;
+
+  if (IsBluetoothMacAddressUnset(bluetooth_mac_address))
+    return colon_delimited_string;
+
+  for (auto byte : std::string(bluetooth_mac_address)) {
+    if (!colon_delimited_string.empty())
+      absl::StrAppend(&colon_delimited_string, ":");
+    absl::StrAppend(&colon_delimited_string, absl::StrFormat("%02X", byte));
+  }
+  return colon_delimited_string;
+}
+
+ByteArray BluetoothUtils::FromString(absl::string_view bluetooth_mac_address) {
+  std::string bt_mac_address(bluetooth_mac_address);
+
+  // Remove the colon delimiters.
+  bt_mac_address.erase(
+      std::remove(bt_mac_address.begin(), bt_mac_address.end(), ':'),
+      bt_mac_address.end());
+
+  // If the bluetooth mac address is invalid (wrong size), return a null byte
+  // array.
+  if (bt_mac_address.length() != kBluetoothMacAddressLength * 2) {
+    return ByteArray();
+  }
+
+  // Convert to bytes. If MAC Address bytes are unset, return a null byte array.
+  auto bt_mac_address_string(absl::HexStringToBytes(bt_mac_address));
+  auto bt_mac_address_bytes =
+      ByteArray(bt_mac_address_string.data(), bt_mac_address_string.size());
+  if (IsBluetoothMacAddressUnset(bt_mac_address_bytes)) {
+    return ByteArray();
+  }
+  return bt_mac_address_bytes;
+}
+
+bool BluetoothUtils::IsBluetoothMacAddressUnset(
+    const ByteArray& bluetooth_mac_address_bytes) {
+  for (int i = 0; i < bluetooth_mac_address_bytes.size(); i++) {
+    if (bluetooth_mac_address_bytes.data()[i] != 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+}  // namespace nearby
+}  // namespace location

cpp/platform/base/bluetooth_utils.h

@@ -0,0 +1,46 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_BLUETOOTH_UTILS_H_
+#define PLATFORM_BASE_BLUETOOTH_UTILS_H_
+
+#include "platform/base/byte_array.h"
+#include "absl/strings/string_view.h"
+
+namespace location {
+namespace nearby {
+
+class BluetoothUtils {
+ public:
+  static constexpr int kBluetoothMacAddressLength = 6;
+
+  // Converts a Bluetooth MAC address from byte array to String format. Returns
+  // empty if input byte array is not of correct format.
+  // e.g. {-84, 55, 67, -68, -87, 40} -> "AC:37:43:BC:A9:28".
+  static std::string ToString(const ByteArray& bluetooth_mac_address);
+
+  // Converts a Bluetooth MAC address from String format to byte array. Returns
+  // empty if input string is not of correct format.
+  // e.g. "AC:37:43:BC:A9:28" -> {-84, 55, 67, -68, -87, 40}.
+  static ByteArray FromString(absl::string_view bluetooth_mac_address);
+
+  // Checks if a Bluetooth MAC address is zero for every byte.
+  static bool IsBluetoothMacAddressUnset(
+      const ByteArray& bluetooth_mac_address);
+};
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_BASE_BLUETOOTH_UTILS_H_

cpp/platform/base/bluetooth_utils_test.cc

@@ -0,0 +1,89 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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 "platform/base/bluetooth_utils.h"
+
+#include "gtest/gtest.h"
+
+namespace location {
+namespace nearby {
+
+constexpr absl::string_view kBluetoothMacAddress{"00:00:E6:88:64:13"};
+constexpr char kBluetoothMacAddressBytes[] = {0x00, 0x00, 0xe6,
+                                              0x88, 0x64, 0x13};
+
+TEST(BluetoothUtilsTest, ToStringWorks) {
+  ByteArray bt_mac_address_bytes{
+      kBluetoothMacAddressBytes, sizeof(kBluetoothMacAddressBytes)};
+
+  auto bt_mac_address = BluetoothUtils::ToString(bt_mac_address_bytes);
+
+  EXPECT_EQ(kBluetoothMacAddress, bt_mac_address);
+}
+
+TEST(BluetoothUtilsTest, FromStringWorks) {
+  ByteArray bt_mac_address_bytes{
+      kBluetoothMacAddressBytes, sizeof(kBluetoothMacAddressBytes)};
+
+  auto bt_mac_address_bytes_result =
+      BluetoothUtils::FromString(kBluetoothMacAddress);
+
+  EXPECT_EQ(bt_mac_address_bytes, bt_mac_address_bytes_result);
+}
+
+TEST(BluetoothUtilsTest, InvalidBytesReturnsEmptyString) {
+  std::string string_result;
+
+  char bad_bt_mac_address_1[] = {0x02, 0x20, 0x00};
+  ByteArray bad_bt_mac_address_bytes_1{bad_bt_mac_address_1,
+                                       sizeof(bad_bt_mac_address_1)};
+  string_result = BluetoothUtils::ToString(bad_bt_mac_address_bytes_1);
+  EXPECT_TRUE(string_result.empty());
+
+  char bad_bt_mac_address_2[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+  ByteArray bad_bt_mac_address_bytes_2{bad_bt_mac_address_2,
+                                       sizeof(bad_bt_mac_address_2)};
+  string_result = BluetoothUtils::ToString(bad_bt_mac_address_bytes_2);
+  EXPECT_TRUE(string_result.empty());
+
+  char bad_bt_mac_address_3[] = {0x11, 0x22, 0x33, 0x44, 0x55,
+                                 0x66, 0x77, 0x88, 0x99};
+  ByteArray bad_bt_mac_address_bytes_3{bad_bt_mac_address_3,
+                                       sizeof(bad_bt_mac_address_3)};
+  string_result = BluetoothUtils::ToString(bad_bt_mac_address_bytes_3);
+  EXPECT_TRUE(string_result.empty());
+}
+
+TEST(BluetoothUtilsTest, InvalidStringReturnsEmptyByteArray) {
+  ByteArray bytes_result;
+
+  std::string bad_bt_mac_address_1 = "022:00";
+  bytes_result = BluetoothUtils::FromString(bad_bt_mac_address_1);
+  EXPECT_TRUE(bytes_result.Empty());
+
+  std::string bad_bt_mac_address_2 = "22:00:11:33:77:aa::bb::99";
+  bytes_result = BluetoothUtils::FromString(bad_bt_mac_address_2);
+  EXPECT_TRUE(bytes_result.Empty());
+
+  std::string bad_bt_mac_address_3 = "00:00:00:00:00:00";
+  bytes_result = BluetoothUtils::FromString(bad_bt_mac_address_3);
+  EXPECT_TRUE(bytes_result.Empty());
+
+  std::string bad_bt_mac_address_4 = "BLUETOOTHCHIP";
+  bytes_result = BluetoothUtils::FromString(bad_bt_mac_address_4);
+  EXPECT_TRUE(bytes_result.Empty());
+}
+
+}  // namespace nearby
+}  // namespace location

cpp/platform/base/byte_array.h

@@ -0,0 +1,112 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_BYTE_ARRAY_H_
+#define PLATFORM_BASE_BYTE_ARRAY_H_
+
+#include <array>
+#include <cstdint>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+namespace location {
+namespace nearby {
+
+class ByteArray {
+ public:
+  // Create an empty ByteArray
+  ByteArray() = default;
+  template <size_t N>
+  explicit ByteArray(const std::array<char, N>& data) {
+    SetData(data.data(), data.size());
+  }
+  ByteArray(const ByteArray&) = default;
+  ByteArray& operator=(const ByteArray&) = default;
+  ByteArray(ByteArray&&) = default;
+  ByteArray& operator=(ByteArray&&) = default;
+
+  // Moves string out of temporary, allowing for a zero-copy constructions.
+  // This is an optimization for very large strings.
+  explicit ByteArray(std::string&& source) : data_(std::move(source)) {}
+
+  // Create ByteArray by copy of a std::string. This can't be a string_view,
+  // because it will conflict with std::string&& version of constructor.
+  explicit ByteArray(const std::string& source) {
+    SetData(source.data(), source.size());
+  }
+
+  // Create default-initialized ByteArray of a given size.
+  explicit ByteArray(size_t size) { SetData(size); }
+
+  // Create value-initialized ByteArray of a given size.
+  ByteArray(const char* data, size_t size) { SetData(data, size); }
+
+  // Assign a new value to this ByteArray, as a copy of data, with a given size.
+  void SetData(const char* data, size_t size) {
+    if (data == nullptr) {
+      size = 0;
+    }
+    data_.assign(data, size);
+  }
+
+  // Assign a new value of a given size to this ByteArray
+  // (as a repeated char value).
+  void SetData(size_t size, char value = 0) { data_.assign(size, value); }
+
+  // Returns true, if changes were performed to container, false otherwise.
+  bool CopyAt(size_t offset, const ByteArray& from, size_t source_offset = 0) {
+    if (offset >= size()) return false;
+    if (source_offset >= from.size()) return false;
+    memcpy(data() + offset, from.data() + source_offset,
+           std::min(size() - offset, from.size() - source_offset));
+    return true;
+  }
+
+  char* data() { return &data_[0]; }
+  const char* data() const { return data_.data(); }
+  size_t size() const { return data_.size(); }
+  bool Empty() const { return data_.empty(); }
+
+  friend bool operator==(const ByteArray& lhs, const ByteArray& rhs);
+  friend bool operator!=(const ByteArray& lhs, const ByteArray& rhs);
+  friend bool operator<(const ByteArray& lhs, const ByteArray& rhs);
+
+  // Returns a copy of internal representation as std::string.
+  explicit operator std::string() const& { return data_; }
+
+  // Moves string out of temporary ByteArray, allowing for a zero-copy
+  // operation.
+  explicit operator std::string() && { return std::move(data_); }
+
+ private:
+  std::string data_;
+};
+
+inline bool operator==(const ByteArray& lhs, const ByteArray& rhs) {
+  return lhs.data_ == rhs.data_;
+}
+
+inline bool operator!=(const ByteArray& lhs, const ByteArray& rhs) {
+  return !(lhs == rhs);
+}
+
+inline bool operator<(const ByteArray& lhs, const ByteArray& rhs) {
+  return lhs.data_ < rhs.data_;
+}
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_BASE_BYTE_ARRAY_H_

cpp/platform/base/byte_array_test.cc

@@ -0,0 +1,90 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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 "platform/base/byte_array.h"
+
+#include <cstring>
+
+#include "gtest/gtest.h"
+
+namespace {
+
+using location::nearby::ByteArray;
+
+TEST(ByteArrayTest, DefaultSizeIsZero) {
+  ByteArray bytes;
+  EXPECT_EQ(0, bytes.size());
+}
+
+TEST(ByteArrayTest, DefaultIsEmpty) {
+  ByteArray bytes;
+  EXPECT_TRUE(bytes.Empty());
+}
+
+TEST(ByteArrayTest, NullArrayIsEmpty) {
+  ByteArray bytes{nullptr, 5};
+  EXPECT_TRUE(bytes.Empty());
+}
+
+TEST(ByteArrayTest, CopyAtDoesNotExtendArray) {
+  ByteArray v1("12345");
+  ByteArray v2("ABCDEFGH");
+  EXPECT_TRUE(v2.CopyAt(/*offset=*/5, v1));
+  EXPECT_TRUE(v2.CopyAt(/*offset=*/1, v1, /*source_offset=*/3));
+  EXPECT_EQ(v2, ByteArray("A45DE123"));
+}
+
+TEST(ByteArrayTest, CopyAtOutOfBoundsIsIgnored) {
+  ByteArray v1("12345");
+  ByteArray v2("ABCDEFGH");
+  // Try to do an out-of-bounds read.
+  EXPECT_FALSE(v2.CopyAt(/* offset=*/5, v1, /*source_offset=*/10));
+  // Try to do an out-of-bounds write.
+  EXPECT_FALSE(v2.CopyAt(/* offset=*/9, v1));
+  EXPECT_EQ(v2, ByteArray("ABCDEFGH"));
+}
+
+TEST(ByteArrayTest, SetFromString) {
+  std::string setup("setup_test");
+  ByteArray bytes{setup};  // array initialized with a copy of string.
+  EXPECT_EQ(setup.size(), bytes.size());
+  EXPECT_EQ(std::string(bytes), setup);
+}
+
+TEST(ByteArrayTest, SetExplicitSize) {
+  constexpr size_t kArraySize = 10;
+  char reference[kArraySize]{};
+  ByteArray bytes{kArraySize};  // array of size 10, zero-initialized.
+  EXPECT_EQ(kArraySize, bytes.size());
+  EXPECT_EQ(0, memcmp(bytes.data(), reference, kArraySize));
+}
+
+TEST(ByteArrayTest, SetExplicitData) {
+  constexpr static const char message[]{"test_message"};
+  constexpr size_t kMessageSize = sizeof(message);
+  ByteArray bytes{message, kMessageSize};
+  EXPECT_EQ(kMessageSize, bytes.size());
+  EXPECT_NE(message, bytes.data());
+  EXPECT_EQ(0, memcmp(message, bytes.data(), kMessageSize));
+}
+
+TEST(ByteArrayTest, CreateFromNonNullTerminatedStdArray) {
+  constexpr static const std::array data{'a', '\x00', 'b'};
+  ByteArray bytes{data};
+  EXPECT_EQ(bytes.size(), 3);
+  EXPECT_EQ(bytes.size(), std::string(bytes).size());
+  EXPECT_EQ(std::string(bytes), std::string(data.data(), data.size()));
+}
+
+}  // namespace

cpp/platform/base/callable.h

@@ -0,0 +1,37 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_CALLABLE_H_
+#define PLATFORM_BASE_CALLABLE_H_
+
+#include <functional>
+
+#include "platform/base/exception.h"
+
+namespace location {
+namespace nearby {
+
+// The Callable is and object intended to be executed by a thread, that is able
+// to return a value of specified type T.
+// It must be invokable without arguments. It must return a value implicitly
+// convertible to ExceptionOr<T>.
+//
+// https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Callable.html
+template <typename T>
+using Callable = std::function<ExceptionOr<T>()>;
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_BASE_CALLABLE_H_

cpp/platform/base/exception.h

@@ -0,0 +1,112 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_EXCEPTION_H_
+#define PLATFORM_BASE_EXCEPTION_H_
+
+#include <utility>
+
+#include "absl/meta/type_traits.h"
+
+namespace location {
+namespace nearby {
+
+struct Exception {
+  enum Value : int {
+    kFailed = -1,      // Initial value of Exception; any unknown error.
+    kSuccess = 0,      // No exception.
+    kIo = 1,           // IO Error happened.
+    kInterrupted = 2,  // Operation was interrupted.
+    kInvalidProtocolBuffer = 3,  // Couldn't parse.
+    kExecution = 4,              // Couldn't execute.
+    kTimeout = 5,  // Operarion did not finish within specified time.
+  };
+  bool Ok() const { return value == kSuccess; }
+  bool Raised() const { return !Ok(); }
+  bool Raised(Value value) const { return this->value == value; }
+  Value value{kFailed};
+};
+
+constexpr inline bool operator==(const Exception& a, const Exception& b) {
+  return a.value == b.value;
+}
+
+constexpr inline bool operator!=(const Exception& a, const Exception& b) {
+  return !(a == b);
+}
+
+// ExceptionOr provides experience similar to StatusOr<T> used in
+// Google Cloud API, see:
+// https://googleapis.github.io/google-cloud-cpp/0.7.0/common/status__or_8h_source.html
+//
+// If ok() returns true, result() is a usable return value. Otherwise,
+// exception() explains why such a value is not present.
+//
+// A typical pattern of usage is as follows:
+//
+//      if (!e.ok()) {
+//        if (Exception::EXCEPTION_TYPE_1 == e.exception()) {
+//          // Handle Exception::EXCEPTION_TYPE_1.
+//        } else if (Exception::EXCEPTION_TYPE_2 == e.exception()) {
+//          // Handle Exception::EXCEPTION_TYPE_2.
+//        }
+//
+//         return;
+//      }
+//
+//      // Use e.result().
+template <typename T>
+class ExceptionOr {
+ public:
+  ExceptionOr() = default;
+  explicit ExceptionOr(T&& result)
+      : result_{std::move(result)},
+        exception_{Exception::kSuccess} {}  // NOLINT
+  explicit ExceptionOr(const T& result)
+      : result_{result}, exception_{Exception::kSuccess} {}           // NOLINT
+  ExceptionOr(Exception::Value exception) : exception_{exception} {}  // NOLINT
+  ExceptionOr(Exception exception) : exception_{exception} {}         // NOLINT
+  // If there exists explicit conversion from from U to T,
+  // then allow explicit conversion from ExceptionOr<U> to ExceptionOr<T>.
+  template <typename U, typename = absl::void_t<decltype(T{std::declval<U>()})>>
+  explicit ExceptionOr<T>(ExceptionOr<U> value) {
+    if (!value.ok()) {
+      exception_ = value.GetException();
+    } else {
+      result_ = T{std::move(value.result())};
+      exception_ = Exception{Exception::kSuccess};
+    }
+  }
+
+  bool ok() const { return exception_.value == Exception::kSuccess; }
+
+  T& result() & { return result_; }
+  const T& result() const& { return result_; }
+  T&& result() && { return std::move(result_); }
+  const T&& result() const&& { return std::move(result_); }
+
+  Exception::Value exception() const { return exception_.value; }
+
+  T GetResult() const { return result_; }
+  Exception GetException() const { return exception_; }
+
+ private:
+  T result_{};
+  Exception exception_{Exception::kFailed};
+};
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_BASE_EXCEPTION_H_

cpp/platform/base/exception_test.cc

@@ -0,0 +1,120 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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 "platform/base/exception.h"
+
+#include <vector>
+
+#include "platform/base/exception_test.nc.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace location::nearby {
+
+TEST(ExceptionOr, Result_Copy_NonConst) {
+  ExceptionOr<std::vector<int>> exception_or_vector({1, 2, 3});
+  EXPECT_FALSE(exception_or_vector.result().empty());
+
+  // Expect a copy when not explicitly moving the result.
+  std::vector<int> copy = exception_or_vector.result();
+  EXPECT_FALSE(copy.empty());
+  EXPECT_FALSE(exception_or_vector.result().empty());
+
+  // Modifying |exception_or_vector| should not affect the copy.
+  exception_or_vector.result().clear();
+  EXPECT_FALSE(copy.empty());
+}
+
+TEST(ExceptionOr, Result_Copy_Const) {
+  const ExceptionOr<std::vector<int>> exception_or_vector({1, 2, 3});
+  EXPECT_FALSE(exception_or_vector.result().empty());
+
+  // Expect a copy when not explicitly moving the result.
+  std::vector<int> copy = exception_or_vector.result();
+  EXPECT_FALSE(copy.empty());
+  EXPECT_FALSE(exception_or_vector.result().empty());
+}
+
+TEST(ExceptionOr, Result_Reference_NonConst) {
+  ExceptionOr<std::vector<int>> exception_or_vector({1, 2, 3});
+  EXPECT_FALSE(exception_or_vector.result().empty());
+
+  // Getting a reference should not modify the source.
+  std::vector<int>& reference = exception_or_vector.result();
+  EXPECT_FALSE(reference.empty());
+  EXPECT_FALSE(exception_or_vector.result().empty());
+
+  // Modifying |exception_or_vector| should reflect in the reference.
+  exception_or_vector.result().clear();
+  EXPECT_TRUE(reference.empty());
+}
+
+TEST(ExceptionOr, Result_Reference_Const) {
+  const ExceptionOr<std::vector<int>> exception_or_vector({1, 2, 3});
+  EXPECT_FALSE(exception_or_vector.result().empty());
+
+  // Getting a reference should not modify the source.
+  const std::vector<int>& reference = exception_or_vector.result();
+  EXPECT_FALSE(reference.empty());
+  EXPECT_FALSE(exception_or_vector.result().empty());
+}
+
+TEST(ExceptionOr, Result_Move_NonConst) {
+  ExceptionOr<std::vector<int>> exception_or_vector({1, 2, 3});
+  EXPECT_FALSE(exception_or_vector.result().empty());
+
+  // Moving the result should clear the source.
+  std::vector<int> moved = std::move(exception_or_vector).result();
+  EXPECT_FALSE(moved.empty());
+}
+
+TEST(ExceptionOr, Result_Move_Const) {
+  const ExceptionOr<std::vector<int>> exception_or_vector({1, 2, 3});
+  EXPECT_FALSE(exception_or_vector.result().empty());
+
+  // Moving const rvalue reference will result in a copy.
+  std::vector<int> moved = std::move(exception_or_vector).result();
+  EXPECT_FALSE(moved.empty());
+}
+
+TEST(ExceptionOr, ExplicitConversionWorks) {
+  class A {
+   public:
+    A() = default;
+  };
+  class B {
+   public:
+    B() = default;
+    explicit B(A) {}
+  };
+  ExceptionOr<A> a(A{});
+  ExceptionOr<B> b(a);
+  EXPECT_TRUE(a.ok());
+  EXPECT_TRUE(b.ok());
+}
+
+TEST(ExceptionOr, ExplicitConversionFailsToCompile) {
+  class A {
+   public:
+    A() = default;
+  };
+  class B {
+   public:
+    B() = default;
+  };
+  ExceptionOr<A> a(A{});
+  EXPECT_NON_COMPILE("no matching constructor", { ExceptionOr<B> b(a); });
+}
+
+}  // namespace location::nearby

cpp/platform/base/input_stream.h

@@ -0,0 +1,42 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_INPUT_STREAM_H_
+#define PLATFORM_BASE_INPUT_STREAM_H_
+
+#include <cstdint>
+
+#include "platform/base/byte_array.h"
+#include "platform/base/exception.h"
+
+namespace location {
+namespace nearby {
+
+// An InputStream represents an input stream of bytes.
+//
+// https://docs.oracle.com/javase/8/docs/api/java/io/InputStream.html
+class InputStream {
+ public:
+  virtual ~InputStream() = default;
+
+  // throws Exception::kIo
+  virtual ExceptionOr<ByteArray> Read(std::int64_t size) = 0;
+  // throws Exception::kIo
+  virtual Exception Close() = 0;
+};
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_BASE_INPUT_STREAM_H_

cpp/platform/base/listeners.h

@@ -0,0 +1,34 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_LISTENERS_H_
+#define PLATFORM_BASE_LISTENERS_H_
+
+#include <functional>
+
+namespace location {
+namespace nearby {
+
+// Provides default-initialization with a valid empty method,
+// instead of nullptr. This allows partial initialization
+// of a set of listeners.
+template <typename... Args>
+constexpr std::function<void(Args...)> DefaultCallback() {
+  return std::function<void(Args...)>{[](Args...) {}};
+}
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_BASE_LISTENERS_H_

cpp/platform/base/logging.h

@@ -0,0 +1,79 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_LOGGING_H_
+#define PLATFORM_BASE_LOGGING_H_
+
+#include "platform/api/log_message.h"
+#include "platform/api/platform.h"
+
+namespace location {
+namespace nearby {
+
+// This class is used to explicitly ignore values in the conditional
+// logging macros.  This avoids compiler warnings like "value computed
+// is not used" and "statement has no effect".
+class LogMessageVoidify {
+ public:
+  LogMessageVoidify() = default;
+  // This has to be an operator with a precedence lower than << but
+  // higher than ?:
+  void operator&(std::ostream&) {}
+};
+
+}  // namespace nearby
+}  // namespace location
+
+// Severity enum conversion
+#define NEARBY_SEVERITY_INFO location::nearby::api::LogMessage::Severity::kInfo
+#define NEARBY_SEVERITY_WARNING \
+  location::nearby::api::LogMessage::Severity::kWarning
+#define NEARBY_SEVERITY_ERROR \
+  location::nearby::api::LogMessage::Severity::kError
+#define NEARBY_SEVERITY_FATAL \
+  location::nearby::api::LogMessage::Severity::kFatal
+#if defined(_WIN32)
+// wingdi.h defines ERROR to be 0. When we call LOG(ERROR), it gets substituted
+// with 0, and it expands to NEARBY_SEVERITY_0. To allow us to keep using this
+// syntax, we define this macro to do the same thing as NEARBY_SEVERITY_ERROR.
+#define NEARBY_SEVERITY_0 location::nearby::api::LogMessage::Severity::kError
+#endif  // defined(_WIN32)
+#define NEARBY_SEVERITY(severity) NEARBY_SEVERITY_##severity
+
+// Log enabling
+#define NEARBY_LOG_IS_ON(severity)                           \
+  location::nearby::api::LogMessage::ShouldCreateLogMessage( \
+      NEARBY_SEVERITY(severity))
+
+#define NEARBY_LOG_SET_SEVERITY(severity)               \
+  location::nearby::api::LogMessage::SetMinLogSeverity( \
+      NEARBY_SEVERITY(severity))
+
+// Log message creation
+#define NEARBY_LOG_MESSAGE(severity)                               \
+  location::nearby::api::ImplementationPlatform::CreateLogMessage( \
+      __FILE__, __LINE__, NEARBY_SEVERITY(severity))
+
+// Public APIs
+// The stream statement must come last or otherwise it won't compile.
+#define NEARBY_LOGS(severity)                                             \
+  !(NEARBY_LOG_IS_ON(severity)) ? (void)0                                 \
+                                : location::nearby::LogMessageVoidify() & \
+                                      NEARBY_LOG_MESSAGE(severity)->Stream()
+
+#define NEARBY_LOG(severity, ...) \
+  NEARBY_LOG_IS_ON(severity)      \
+  ? NEARBY_LOG_MESSAGE(severity)->Print(__VA_ARGS__) : (void)0
+
+#endif  // PLATFORM_BASE_LOGGING_H_

cpp/platform/base/medium_environment.cc

@@ -0,0 +1,661 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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 "platform/base/medium_environment.h"
+
+#include <atomic>
+#include <cinttypes>
+#include <new>
+#include <type_traits>
+
+#include "platform/api/ble.h"
+#include "platform/api/bluetooth_adapter.h"
+#include "platform/api/bluetooth_classic.h"
+#include "platform/api/wifi_lan.h"
+#include "platform/base/logging.h"
+#include "platform/public/count_down_latch.h"
+
+namespace location {
+namespace nearby {
+
+MediumEnvironment& MediumEnvironment::Instance() {
+  static std::aligned_storage_t<sizeof(MediumEnvironment),
+                                alignof(MediumEnvironment)>
+      storage;
+  static MediumEnvironment* env = new (&storage) MediumEnvironment();
+  return *env;
+}
+
+void MediumEnvironment::Start(EnvironmentConfig config) {
+  if (!enabled_.exchange(true)) {
+    NEARBY_LOG(INFO, "MediumEnvironment::Start()");
+    config_ = std::move(config);
+    Reset();
+  }
+}
+
+void MediumEnvironment::Stop() {
+  if (enabled_.exchange(false)) {
+    NEARBY_LOG(INFO, "MediumEnvironment::Stop()");
+    Sync(false);
+  }
+}
+
+void MediumEnvironment::Reset() {
+  RunOnMediumEnvironmentThread([this]() {
+    NEARBY_LOG(INFO, "MediumEnvironment::Reset()");
+    bluetooth_adapters_.clear();
+    bluetooth_mediums_.clear();
+    ble_mediums_.clear();
+    wifi_lan_mediums_.clear();
+  });
+  Sync();
+}
+
+void MediumEnvironment::Sync(bool enable_notifications) {
+  enable_notifications_ = enable_notifications;
+  NEARBY_LOG(INFO, "MediumEnvironment::sync(%d)", enable_notifications);
+  int count = 0;
+  do {
+    CountDownLatch latch(1);
+    count = job_count_ + 1;
+    // We are about to schedule one last job.
+    // When it is done, counter must be equal to count.
+    // However, if pending jobs schedule anything else,
+    // it will be pending after us.
+    // If we want to ensure we are completely idle, then we have to
+    // repeat sync, until this becomes true.
+    RunOnMediumEnvironmentThread([&latch]() { latch.CountDown(); });
+    latch.Await();
+  } while (count < job_count_);
+  NEARBY_LOG(INFO, "MediumEnvironment::Sync(): done [count=%d]", count);
+}
+
+const EnvironmentConfig& MediumEnvironment::GetEnvironmentConfig() {
+  return config_;
+}
+
+void MediumEnvironment::OnBluetoothAdapterChangedState(
+    api::BluetoothAdapter& adapter, api::BluetoothDevice& adapter_device,
+    std::string name, bool enabled, api::BluetoothAdapter::ScanMode mode) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread([this, &adapter, &adapter_device,
+                                name = std::move(name), enabled, mode]() {
+    NEARBY_LOG(INFO,
+               "[adapter=%p, device=%p] update: name=%s, enabled=%d, mode=%d",
+               &adapter, &adapter_device, name.c_str(), enabled, mode);
+    for (auto& medium_info : bluetooth_mediums_) {
+      auto& info = medium_info.second;
+      // Do not send notification to medium that owns this adapter.
+      if (info.adapter == &adapter) continue;
+      NEARBY_LOG(INFO, "[adapter=%p, device=%p] notify: adapter=%p", &adapter,
+                 &adapter_device, info.adapter);
+      OnBluetoothDeviceStateChanged(info, adapter_device, name, mode, enabled);
+    }
+    // We don't care if there is an adapter already since all we store is a
+    // pointer. Pointer must remain valid for the duration of a Core session
+    // (since it is owned by the correspoinding Medium, and mediums lifetime
+    // matches Core lifetime).
+    bluetooth_adapters_.emplace(&adapter, &adapter_device);
+  });
+}
+
+void MediumEnvironment::OnBluetoothDeviceStateChanged(
+    BluetoothMediumContext& info, api::BluetoothDevice& device,
+    const std::string& name, api::BluetoothAdapter::ScanMode mode,
+    bool enabled) {
+  if (!enabled_) return;
+  auto item = info.devices.find(&device);
+  if (item == info.devices.end()) {
+    NEARBY_LOG(INFO,
+               "G3 OnBluetoothDeviceStateChanged [device impl=%p]: new device; "
+               "notify=%d",
+               &device, enable_notifications_.load());
+    if (mode == api::BluetoothAdapter::ScanMode::kConnectableDiscoverable &&
+        enabled) {
+      // New device is turned on, and is in discoverable state.
+      // Store device name, and report it as discovered.
+      info.devices.emplace(&device, name);
+      if (enable_notifications_) {
+        RunOnMediumEnvironmentThread(
+            [&info, &device]() { info.callback.device_discovered_cb(device); });
+      }
+    }
+  } else {
+    NEARBY_LOG(INFO,
+               "G3 OnBluetoothDeviceStateChanged [device impl=%p]: exisitng "
+               "device; notify=%d",
+               &device, enable_notifications_.load());
+    auto& discovered_name = item->second;
+    if (mode == api::BluetoothAdapter::ScanMode::kConnectableDiscoverable &&
+        enabled) {
+      if (name != discovered_name) {
+        // Known device is turned on, and is in discoverable state.
+        // Store device name, and report it as renamed.
+        item->second = name;
+        if (enable_notifications_) {
+          RunOnMediumEnvironmentThread([&info, &device]() {
+            info.callback.device_name_changed_cb(device);
+          });
+        }
+      } else {
+        // Device is in discovery mode, so we are reporting it anyway.
+        if (enable_notifications_) {
+          RunOnMediumEnvironmentThread([&info, &device]() {
+            info.callback.device_discovered_cb(device);
+          });
+        }
+      }
+    }
+    if (!enabled) {
+      // Known device is turned off.
+      // Erase it from the map, and report as lost.
+      if (enable_notifications_) {
+        RunOnMediumEnvironmentThread(
+            [&info, &device]() { info.callback.device_lost_cb(device); });
+      }
+      info.devices.erase(item);
+    }
+  }
+}
+
+api::BluetoothDevice* MediumEnvironment::FindBluetoothDevice(
+    const std::string& mac_address) {
+  api::BluetoothDevice* device = nullptr;
+  CountDownLatch latch(1);
+  RunOnMediumEnvironmentThread([this, &device, &latch, &mac_address]() {
+    for (auto& item : bluetooth_mediums_) {
+      auto* adapter = item.second.adapter;
+      if (!adapter) continue;
+      if (adapter->GetMacAddress() == mac_address) {
+        device = bluetooth_adapters_[adapter];
+        break;
+      }
+    }
+    latch.CountDown();
+  });
+  latch.Await();
+  return device;
+}
+
+void MediumEnvironment::OnBlePeripheralStateChanged(
+    BleMediumContext& info, api::BlePeripheral& peripheral,
+    const std::string& service_id, bool fast_advertisement, bool enabled) {
+  if (!enabled_) return;
+  NEARBY_LOG(INFO,
+             "G3 OnBleServiceStateChanged [peripheral impl=%p]; context=%p; "
+             "service_id=%s; notify=%d",
+             &peripheral, &info, service_id.c_str(),
+             enable_notifications_.load());
+  if (!enable_notifications_) return;
+  RunOnMediumEnvironmentThread([&info, enabled, &peripheral, service_id,
+                                fast_advertisement]() {
+    NEARBY_LOG(INFO,
+               "G3 [Run] OnBlePeripheralStateChanged [peripheral impl=%p]; "
+               "context=%p; service_id=%s; enabled=%d",
+               &peripheral, &info, service_id.c_str(), enabled);
+    if (enabled) {
+      info.discovery_callback.peripheral_discovered_cb(peripheral, service_id,
+                                                       fast_advertisement);
+    } else {
+      info.discovery_callback.peripheral_lost_cb(peripheral, service_id);
+    }
+  });
+}
+
+void MediumEnvironment::OnWifiLanServiceStateChanged(
+    WifiLanMediumContext& info, api::WifiLanService& service,
+    const std::string& service_id, bool enabled) {
+  if (!enabled_) return;
+  NEARBY_LOG(INFO,
+             "G3 OnWifiLanServiceStateChanged [service impl=%p]; context=%p; "
+             "service_id=%s; notify=%d",
+             &service, &info, service_id.c_str(), enable_notifications_.load());
+  if (!enable_notifications_) return;
+  RunOnMediumEnvironmentThread([&info, enabled, &service, service_id]() {
+    NEARBY_LOG(INFO,
+               "G3 [Run] OnWifiLanServiceStateChanged [service impl=%p]; "
+               "context=%p; service_id=%s; enabled=%d",
+               &service, &info, service_id.c_str(), enabled);
+    auto service_id_context = info.services.find(service_id);
+    if (service_id_context == info.services.end()) return;
+
+    if (enabled) {
+      service_id_context->second.discovery_callback.service_discovered_cb(
+          service, service_id);
+    } else {
+      service_id_context->second.discovery_callback.service_lost_cb(service,
+                                                                    service_id);
+    }
+  });
+}
+
+void MediumEnvironment::RunOnMediumEnvironmentThread(
+    std::function<void()> runnable) {
+  job_count_++;
+  executor_.Execute(std::move(runnable));
+}
+
+void MediumEnvironment::RegisterBluetoothMedium(
+    api::BluetoothClassicMedium& medium,
+    api::BluetoothAdapter& medium_adapter) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread([this, &medium, &medium_adapter]() {
+    auto& context = bluetooth_mediums_
+                        .insert({&medium,
+                                 BluetoothMediumContext{
+                                     .adapter = &medium_adapter,
+                                 }})
+                        .first->second;
+    auto* owned_adapter = context.adapter;
+    NEARBY_LOG(INFO, "Registered: medium=%p; adapter=%p", &medium,
+               owned_adapter);
+    for (auto& adapter_device : bluetooth_adapters_) {
+      auto& adapter = adapter_device.first;
+      auto& device = adapter_device.second;
+      if (adapter == nullptr) continue;
+      OnBluetoothDeviceStateChanged(context, *device, adapter->GetName(),
+                                    adapter->GetScanMode(),
+                                    adapter->IsEnabled());
+    }
+  });
+}
+
+void MediumEnvironment::UpdateBluetoothMedium(
+    api::BluetoothClassicMedium& medium, BluetoothDiscoveryCallback callback) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread([this, &medium,
+                                callback = std::move(callback)]() {
+    auto item = bluetooth_mediums_.find(&medium);
+    if (item == bluetooth_mediums_.end()) return;
+    auto& context = item->second;
+    context.callback = std::move(callback);
+    auto* owned_adapter = context.adapter;
+    NEARBY_LOG(
+        INFO,
+        "Updated: this=%p; medium=%p; adapter=%p; name=%s; enabled=%d; mode=%d",
+        this, &medium, owned_adapter, owned_adapter->GetName().c_str(),
+        owned_adapter->IsEnabled(), owned_adapter->GetScanMode());
+    for (auto& adapter_device : bluetooth_adapters_) {
+      auto& adapter = adapter_device.first;
+      auto& device = adapter_device.second;
+      if (adapter == nullptr) continue;
+      OnBluetoothDeviceStateChanged(context, *device, adapter->GetName(),
+                                    adapter->GetScanMode(),
+                                    adapter->IsEnabled());
+    }
+  });
+}
+
+void MediumEnvironment::UnregisterBluetoothMedium(
+    api::BluetoothClassicMedium& medium) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread([this, &medium]() {
+    auto item = bluetooth_mediums_.extract(&medium);
+    if (item.empty()) return;
+    auto& context = item.mapped();
+    NEARBY_LOG(INFO, "Unregistered medium for device=%s",
+               context.adapter->GetName().c_str());
+  });
+}
+
+void MediumEnvironment::RegisterBleMedium(api::BleMedium& medium) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread([this, &medium]() {
+    ble_mediums_.insert({&medium, BleMediumContext{}});
+    NEARBY_LOG(INFO, "Registered: medium=%p", &medium);
+  });
+}
+
+void MediumEnvironment::UpdateBleMediumForAdvertising(
+    api::BleMedium& medium, api::BlePeripheral& peripheral,
+    const std::string& service_id, bool fast_advertisement, bool enabled) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread(
+      [this, &medium, &peripheral, service_id, fast_advertisement, enabled]() {
+        auto item = ble_mediums_.find(&medium);
+        if (item == ble_mediums_.end()) {
+          NEARBY_LOG(INFO,
+                     "UpdateBleMediumForAdvertising failed. There is no medium "
+                     "registered.");
+          return;
+        }
+        auto& context = item->second;
+        context.ble_peripheral = &peripheral;
+        context.advertising = enabled;
+        context.fast_advertisement = fast_advertisement;
+        NEARBY_LOG(
+            INFO,
+            "Update Ble medium for advertising: this=%p; medium=%p; "
+            "service_id=%s; name=%s; fast_advertisement=%d; enabled=%d; ",
+            this, &medium, service_id.c_str(), peripheral.GetName().c_str(),
+            fast_advertisement, enabled);
+        for (auto& medium_info : ble_mediums_) {
+          auto& local_medium = medium_info.first;
+          auto& info = medium_info.second;
+          // Do not send notification to the same medium.
+          if (local_medium == &medium) continue;
+          OnBlePeripheralStateChanged(info, peripheral, service_id,
+                                      fast_advertisement, enabled);
+        }
+      });
+}
+
+void MediumEnvironment::UpdateBleMediumForScanning(
+    api::BleMedium& medium, const std::string& service_id,
+    const std::string& fast_advertisement_service_uuid,
+    BleDiscoveredPeripheralCallback callback, bool enabled) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread(
+      [this, &medium, service_id, fast_advertisement_service_uuid,
+       callback = std::move(callback), enabled]() {
+        auto item = ble_mediums_.find(&medium);
+        if (item == ble_mediums_.end()) {
+          NEARBY_LOG(INFO,
+                     "UpdateBleMediumFoScanning failed. There is no medium "
+                     "registered.");
+          return;
+        }
+        auto& context = item->second;
+        context.discovery_callback = std::move(callback);
+        NEARBY_LOG(
+            INFO,
+            "Update Ble medium for scanning: this=%p; medium=%p; "
+            "service_id=%s; fast_advertisement_service_uuid=%s; enabled=%d ;",
+            this, &medium, service_id.c_str(),
+            fast_advertisement_service_uuid.c_str(), enabled);
+        for (auto& medium_info : ble_mediums_) {
+          auto& local_medium = medium_info.first;
+          auto& info = medium_info.second;
+          // Do not send notification to the same medium.
+          if (local_medium == &medium) continue;
+          // Search advertising mediums and send notification.
+          if (info.advertising && enabled) {
+            OnBlePeripheralStateChanged(context, *(info.ble_peripheral),
+                                        service_id, info.fast_advertisement,
+                                        enabled);
+          }
+        }
+      });
+}
+
+void MediumEnvironment::UpdateBleMediumForAcceptedConnection(
+    api::BleMedium& medium, const std::string& service_id,
+    BleAcceptedConnectionCallback callback) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread(
+      [this, &medium, service_id, callback = std::move(callback)]() {
+        auto item = ble_mediums_.find(&medium);
+        if (item == ble_mediums_.end()) {
+          NEARBY_LOG(
+              INFO, "Update Ble medium failed. There is no medium registered.");
+          return;
+        }
+        auto& context = item->second;
+        context.accepted_connection_callback = std::move(callback);
+        NEARBY_LOG(INFO,
+                   "Update Ble medium for accepted callback: this=%p; "
+                   "medium=%p; service_id=%s; ",
+                   this, &medium, service_id.c_str());
+      });
+}
+
+void MediumEnvironment::UnregisterBleMedium(api::BleMedium& medium) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread([this, &medium]() {
+    auto item = ble_mediums_.extract(&medium);
+    if (item.empty()) return;
+    NEARBY_LOG(INFO, "Unregistered Ble medium");
+  });
+}
+
+void MediumEnvironment::CallBleAcceptedConnectionCallback(
+    api::BleMedium& medium, api::BleSocket& socket,
+    const std::string& service_id) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread([this, &medium, &socket, service_id]() {
+    auto item = ble_mediums_.find(&medium);
+    if (item == ble_mediums_.end()) {
+      NEARBY_LOG(INFO,
+                 "Call AcceptedConnectionCallback failed.. There is no medium "
+                 "registered.");
+      return;
+    }
+    auto& info = item->second;
+    info.accepted_connection_callback.accepted_cb(socket, service_id);
+  });
+}
+
+void MediumEnvironment::RegisterWebRtcSignalingMessenger(
+    absl::string_view self_id, OnSignalingMessageCallback callback) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread(
+      [this, self_id{std::string(self_id)}, callback{std::move(callback)}]() {
+        webrtc_signaling_callback_[self_id] = std::move(callback);
+        NEARBY_LOG(INFO, "Registered signaling message callback for id = %s",
+                   self_id.c_str());
+      });
+}
+
+void MediumEnvironment::UnregisterWebRtcSignalingMessenger(
+    absl::string_view self_id) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread([this, self_id{std::string(self_id)}]() {
+    auto item = webrtc_signaling_callback_.extract(self_id);
+    if (item.empty()) return;
+    NEARBY_LOG(INFO, "Unregistered signaling message callback for id = %s",
+               self_id.c_str());
+  });
+}
+
+void MediumEnvironment::SendWebRtcSignalingMessage(absl::string_view peer_id,
+                                                   const ByteArray& message) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread(
+      [this, peer_id{std::string(peer_id)}, message]() {
+        auto item = webrtc_signaling_callback_.find(peer_id);
+        if (item == webrtc_signaling_callback_.end()) {
+          NEARBY_LOG(WARNING, "No callback registered for peer id = %s",
+                     peer_id.c_str());
+          return;
+        }
+
+        item->second(message);
+      });
+}
+
+void MediumEnvironment::SetUseValidPeerConnection(
+    bool use_valid_peer_connection) {
+  use_valid_peer_connection_ = use_valid_peer_connection;
+}
+
+bool MediumEnvironment::GetUseValidPeerConnection() {
+  return use_valid_peer_connection_;
+}
+
+void MediumEnvironment::RegisterWifiLanMedium(api::WifiLanMedium& medium) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread([this, &medium]() {
+    wifi_lan_mediums_.insert({&medium, WifiLanMediumContext{}});
+    NEARBY_LOG(INFO, "Registered: medium=%p", &medium);
+  });
+}
+
+void MediumEnvironment::UpdateWifiLanMediumForAdvertising(
+    api::WifiLanMedium& medium, api::WifiLanService& service,
+    const std::string& service_id, bool enabled) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread([this, &medium, &service, service_id,
+                                enabled]() {
+    auto item = wifi_lan_mediums_.find(&medium);
+    if (item == wifi_lan_mediums_.end()) {
+      NEARBY_LOG(INFO,
+                 "UpdateWifiLanMediumForAdvertising failed. There is no medium "
+                 "registered.");
+      return;
+    }
+    auto& context = item->second;
+    context.wifi_lan_service = &service;
+    auto service_id_context = context.services.find(service_id);
+    if (service_id_context == context.services.end()) {
+      WifiLanServiceIdContext id_context{
+          .advertising = enabled,
+      };
+      context.services.emplace(service_id, std::move(id_context));
+    } else {
+      service_id_context->second.advertising = enabled;
+    }
+    NEARBY_LOG(INFO,
+               "Update WifiLan medium for advertising: this=%p; medium=%p; "
+               "service_id=%s; name=%s; enabled=%d",
+               this, &medium, service_id.c_str(),
+               service.GetServiceName().c_str(), enabled);
+    for (auto& medium_info : wifi_lan_mediums_) {
+      auto& local_medium = medium_info.first;
+      auto& info = medium_info.second;
+      // Do not send notification to the same medium.
+      if (local_medium == &medium) continue;
+      OnWifiLanServiceStateChanged(info, service, service_id, enabled);
+    }
+  });
+}
+
+void MediumEnvironment::UpdateWifiLanMediumForDiscovery(
+    api::WifiLanMedium& medium, const std::string& service_id,
+    WifiLanDiscoveredServiceCallback callback, bool enabled) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread([this, &medium, service_id,
+                                callback = std::move(callback), enabled]() {
+    auto item = wifi_lan_mediums_.find(&medium);
+    if (item == wifi_lan_mediums_.end()) {
+      NEARBY_LOG(INFO,
+                 "UpdateWifiLanMediumForDiscovery failed. There is no medium "
+                 "registered.");
+      return;
+    }
+    auto& context = item->second;
+    auto service_id_context = context.services.find(service_id);
+    if (service_id_context == context.services.end()) {
+      WifiLanServiceIdContext id_context{
+          .discovery_callback = std::move(callback),
+      };
+      context.services.emplace(service_id, std::move(id_context));
+    } else {
+      service_id_context->second.discovery_callback = std::move(callback);
+    }
+    NEARBY_LOG(INFO,
+               "Update WifiLan medium for discovery: this=%p; medium=%p; "
+               "service_id=%s; enabled=%d; ",
+               this, &medium, service_id.c_str(), enabled);
+    for (auto& medium_info : wifi_lan_mediums_) {
+      auto& local_medium = medium_info.first;
+      auto& info = medium_info.second;
+      // Do not send notification to the same medium.
+      if (local_medium == &medium) continue;
+      // Search advertising mediums and send notification.
+      for (auto& service_id_context : info.services) {
+        auto& service_id = service_id_context.first;
+        auto& id_context = service_id_context.second;
+        if (id_context.advertising && enabled) {
+          OnWifiLanServiceStateChanged(context, *(info.wifi_lan_service),
+                                       service_id, enabled);
+        }
+      }
+    }
+  });
+}
+
+void MediumEnvironment::UpdateWifiLanMediumForAcceptedConnection(
+    api::WifiLanMedium& medium, const std::string& service_id,
+    WifiLanAcceptedConnectionCallback callback) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread([this, &medium, service_id,
+                                callback = std::move(callback)]() {
+    auto item = wifi_lan_mediums_.find(&medium);
+    if (item == wifi_lan_mediums_.end()) {
+      NEARBY_LOG(
+          INFO, "Update WifiLan medium failed. There is no medium registered.");
+      return;
+    }
+    auto& context = item->second;
+    auto service_id_context = context.services.find(service_id);
+    if (service_id_context == context.services.end()) {
+      WifiLanServiceIdContext id_context{
+          .accepted_connection_callback = std::move(callback),
+      };
+      context.services.emplace(service_id, std::move(id_context));
+    } else {
+      service_id_context->second.accepted_connection_callback =
+          std::move(callback);
+    }
+    NEARBY_LOG(INFO,
+               "Update WifiLan medium for accepted callback: this=%p; "
+               "medium=%p; service_id=%s; ",
+               this, &medium, service_id.c_str());
+  });
+}
+
+void MediumEnvironment::UnregisterWifiLanMedium(api::WifiLanMedium& medium) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread([this, &medium]() {
+    auto item = wifi_lan_mediums_.extract(&medium);
+    if (item.empty()) return;
+    NEARBY_LOG(INFO, "Unregistered WifiLan medium");
+  });
+}
+
+void MediumEnvironment::CallWifiLanAcceptedConnectionCallback(
+    api::WifiLanMedium& medium, api::WifiLanSocket& socket,
+    const std::string& service_id) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread([this, &medium, &socket, service_id]() {
+    auto item = wifi_lan_mediums_.find(&medium);
+    if (item == wifi_lan_mediums_.end()) {
+      NEARBY_LOG(INFO,
+                 "Call AcceptedConnectionCallback failed.. There is no medium "
+                 "registered.");
+      return;
+    }
+    auto& info = item->second;
+    auto service_id_context = info.services.find(service_id);
+    if (service_id_context != info.services.end()) {
+      service_id_context->second.accepted_connection_callback.accepted_cb(
+          socket, service_id);
+    }
+  });
+}
+
+api::WifiLanService* MediumEnvironment::FindWifiLanService(
+    const std::string& ip_address, int port) {
+  api::WifiLanService* remote_service = nullptr;
+  CountDownLatch latch(1);
+  RunOnMediumEnvironmentThread(
+      [this, &remote_service, &ip_address, port, &latch]() {
+        for (auto& item : wifi_lan_mediums_) {
+          auto* service = item.second.wifi_lan_service;
+          if (!service) continue;
+          auto addr = remote_service->GetServiceAddress();
+          if (addr.first == ip_address && addr.second == port) {
+            remote_service = service;
+            break;
+          }
+        }
+        latch.CountDown();
+      });
+  latch.Await();
+  return remote_service;
+}
+
+}  // namespace nearby
+}  // namespace location

cpp/platform/base/medium_environment.h

@@ -0,0 +1,312 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_MEDIUM_ENVIRONMENT_H_
+#define PLATFORM_BASE_MEDIUM_ENVIRONMENT_H_
+
+#include <atomic>
+
+#include "platform/api/bluetooth_adapter.h"
+#include "platform/api/bluetooth_classic.h"
+#include "platform/api/webrtc.h"
+#include "platform/base/byte_array.h"
+#include "platform/base/listeners.h"
+#include "platform/public/single_thread_executor.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/strings/string_view.h"
+
+namespace location {
+namespace nearby {
+
+// Environment config that can control availability of certain mediums for
+// testing.
+struct EnvironmentConfig {
+  // Control whether WEB_RTC medium is enabled in the environment.
+  // This is currently set to false, due to http://b/139734036 that would lead
+  // to flaky tests.
+  bool webrtc_enabled = false;
+};
+
+// MediumEnvironment is a simulated environment which allows multiple instances
+// of simulated HW devices to "work" together as if they are physical.
+// For each medium type it provides necessary methods to implement
+// advertising, discovery and establishment of a data link.
+// NOTE: this code depends on public:types target.
+class MediumEnvironment {
+ public:
+  using BluetoothDiscoveryCallback =
+      api::BluetoothClassicMedium::DiscoveryCallback;
+  using BleDiscoveredPeripheralCallback =
+      api::BleMedium::DiscoveredPeripheralCallback;
+  using BleAcceptedConnectionCallback =
+      api::BleMedium::AcceptedConnectionCallback;
+  using OnSignalingMessageCallback =
+      api::WebRtcSignalingMessenger::OnSignalingMessageCallback;
+  using WifiLanDiscoveredServiceCallback =
+      api::WifiLanMedium::DiscoveredServiceCallback;
+  using WifiLanAcceptedConnectionCallback =
+      api::WifiLanMedium::AcceptedConnectionCallback;
+
+  MediumEnvironment(const MediumEnvironment&) = delete;
+  MediumEnvironment& operator=(const MediumEnvironment&) = delete;
+
+  // Creates and returns a reference to the global test environment instance.
+  static MediumEnvironment& Instance();
+
+  // Global ON/OFF switch for medium environment.
+  // Start & Stop work as On/Off switch for this object.
+  // Default state (after creation) is ON, to make it compatible with early
+  // tests that are already using it and relying on it being ON.
+
+  // Enables Medium environment.
+  void Start(EnvironmentConfig config = EnvironmentConfig());
+  // Disables Medium environment.
+  void Stop();
+
+  // Clears state. No notifications are sent.
+  void Reset();
+
+  // Waits for all previously scheduled jobs to finish.
+  // This method works as a barrier that guarantees that after it returns, all
+  // the activities that started before it was called, or while it was running
+  // are ended. This means that system is at the state of relaxation when this
+  // code returns. It requires external stimulus to get out of relaxation state.
+  //
+  // If enable_notifications is true (default), simulation environment
+  // will send all future notification events to all registered objects,
+  // whenever protocol requires that. This is expected behavior.
+  // If enabled_notifications is false, future event notifications will not be
+  // sent to registered instances. This is useful for protocol shutdown,
+  // where we no longer care about notifications, and where notifications may
+  // otherwise be delivered after the notification source or target lifeteme has
+  // ended, and cause undefined behavior.
+  void Sync(bool enable_notifications = true);
+
+  // Adds an adapter to internal container.
+  // Notify BluetoothClassicMediums if any that adapter state has changed.
+  void OnBluetoothAdapterChangedState(api::BluetoothAdapter& adapter,
+                                      api::BluetoothDevice& adapter_device,
+                                      std::string name, bool enabled,
+                                      api::BluetoothAdapter::ScanMode mode);
+
+  // Adds medium-related info to allow for adapter discovery to work.
+  // This provides acccess to this medium from other mediums, when protocol
+  // expects they should communicate.
+  void RegisterBluetoothMedium(api::BluetoothClassicMedium& medium,
+                               api::BluetoothAdapter& medium_adapter);
+
+  // Updates callback info to allow for dispatch of discovery events.
+  //
+  // Invokes callback asynchronously when any changes happen to discoverable
+  // devices, or if the defice is turned off, whether or not it is discoverable,
+  // if it was ever reported as discoverable.
+  //
+  // This should be called when discoverable state changes.
+  // with user-specified callback when discovery is enabled, and with default
+  // (empty) callback otherwise.
+  void UpdateBluetoothMedium(api::BluetoothClassicMedium& medium,
+                             BluetoothDiscoveryCallback callback);
+
+  // Removes medium-related info. This should correspond to device power off.
+  void UnregisterBluetoothMedium(api::BluetoothClassicMedium& medium);
+
+  // Returns a Bluetooth Device object matching given mac address to nullptr.
+  api::BluetoothDevice* FindBluetoothDevice(const std::string& mac_address);
+
+  const EnvironmentConfig& GetEnvironmentConfig();
+
+  // Registers |callback| to receive messages sent to device with id |self_id|.
+  void RegisterWebRtcSignalingMessenger(absl::string_view self_id,
+                                        OnSignalingMessageCallback callback);
+
+  // Unregisters the callback listening to incoming messages for |self_id|.
+  void UnregisterWebRtcSignalingMessenger(absl::string_view self_id);
+
+  // Simulates sending a signaling message |message| to device with id
+  // |peer_id|.
+  void SendWebRtcSignalingMessage(absl::string_view peer_id,
+                                  const ByteArray& message);
+
+  // Used to set if WebRtcMedium should use a valid peer connection or nullptr
+  // in tests.
+  void SetUseValidPeerConnection(bool use_valid_peer_connection);
+
+  bool GetUseValidPeerConnection();
+
+  // Adds medium-related info to allow for scanning/advertising to work.
+  // This provides acccess to this medium from other mediums, when protocol
+  // expects they should communicate.
+  void RegisterBleMedium(api::BleMedium& medium);
+
+  // Updates advertising info to indicate the current medium is exposing
+  // advertising event.
+  void UpdateBleMediumForAdvertising(api::BleMedium& medium,
+                                     api::BlePeripheral& peripheral,
+                                     const std::string& service_id,
+                                     bool fast_advertisement, bool enabled);
+
+  // Updates discovery callback info to allow for dispatch of discovery events.
+  //
+  // Invokes callback asynchronously when any changes happen to discoverable
+  // devices, or if the defice is turned off, whether or not it is discoverable,
+  // if it was ever reported as discoverable.
+  //
+  // This should be called when discoverable state changes.
+  // with user-specified callback when discovery is enabled, and with default
+  // (empty) callback otherwise.
+  void UpdateBleMediumForScanning(
+      api::BleMedium& medium, const std::string& service_id,
+      const std::string& fast_advertisement_service_uuid,
+      BleDiscoveredPeripheralCallback callback, bool enabled);
+
+  // Updates Accepted connection callback info to allow for dispatch of
+  // advertising events.
+  void UpdateBleMediumForAcceptedConnection(
+      api::BleMedium& medium, const std::string& service_id,
+      BleAcceptedConnectionCallback callback);
+
+  // Removes medium-related info. This should correspond to device power off.
+  void UnregisterBleMedium(api::BleMedium& medium);
+
+  // Call back when advertising has created the server socket and is ready for
+  // connect.
+  void CallBleAcceptedConnectionCallback(api::BleMedium& medium,
+                                         api::BleSocket& socket,
+                                         const std::string& service_id);
+
+  // Adds medium-related info to allow for discovery/advertising to work.
+  // This provides acccess to this medium from other mediums, when protocol
+  // expects they should communicate.
+  void RegisterWifiLanMedium(api::WifiLanMedium& medium);
+
+  // Updates advertising info to indicate the current medium is exposing
+  // advertising event.
+  void UpdateWifiLanMediumForAdvertising(api::WifiLanMedium& medium,
+                                         api::WifiLanService& service,
+                                         const std::string& service_id,
+                                         bool enabled);
+
+  // Updates discovery callback info to allow for dispatch of discovery events.
+  //
+  // Invokes callback asynchronously when any changes happen to discoverable
+  // devices, or if the defice is turned off, whether or not it is discoverable,
+  // if it was ever reported as discoverable.
+  //
+  // This should be called when discoverable state changes.
+  // with user-specified callback when discovery is enabled, and with default
+  // (empty) callback otherwise.
+  void UpdateWifiLanMediumForDiscovery(
+      api::WifiLanMedium& medium, const std::string& service_id,
+      WifiLanDiscoveredServiceCallback callback, bool enabled);
+
+  // Updates Accepted connection callback info to allow for dispatch of
+  // advertising events.
+  void UpdateWifiLanMediumForAcceptedConnection(
+      api::WifiLanMedium& medium, const std::string& service_id,
+      WifiLanAcceptedConnectionCallback callback);
+
+  // Removes medium-related info. This should correspond to device power off.
+  void UnregisterWifiLanMedium(api::WifiLanMedium& medium);
+
+  // Call back when advertising has created the server socket and is ready for
+  // connect.
+  void CallWifiLanAcceptedConnectionCallback(api::WifiLanMedium& medium,
+                                             api::WifiLanSocket& socket,
+                                             const std::string& service_id);
+
+  // Returns WiFi LAN service matching IP address and port, or nullptr.
+  api::WifiLanService* FindWifiLanService(const std::string& ip_address,
+                                          int port);
+
+ private:
+  struct BluetoothMediumContext {
+    BluetoothDiscoveryCallback callback;
+    api::BluetoothAdapter* adapter = nullptr;
+    // discovered device vs device name map.
+    absl::flat_hash_map<api::BluetoothDevice*, std::string> devices;
+  };
+
+  struct BleMediumContext {
+    BleDiscoveredPeripheralCallback discovery_callback;
+    BleAcceptedConnectionCallback accepted_connection_callback;
+    api::BlePeripheral* ble_peripheral = nullptr;
+    bool advertising = false;
+    bool fast_advertisement = false;
+  };
+
+  struct WifiLanServiceIdContext {
+    WifiLanDiscoveredServiceCallback discovery_callback;
+    WifiLanAcceptedConnectionCallback accepted_connection_callback;
+    bool advertising = false;
+  };
+
+  struct WifiLanMediumContext {
+    api::WifiLanService* wifi_lan_service = nullptr;
+    absl::flat_hash_map<std::string, WifiLanServiceIdContext> services;
+  };
+
+  // This is a singleton object, for which destructor will never be called.
+  // Constructor will be invoked once from Instance() static method.
+  // Object is create in-place (with a placement new) to guarantee that
+  // destructor is not scheduled for execution at exit.
+  MediumEnvironment() = default;
+  ~MediumEnvironment() = default;
+
+  void OnBluetoothDeviceStateChanged(BluetoothMediumContext& info,
+                                     api::BluetoothDevice& device,
+                                     const std::string& name,
+                                     api::BluetoothAdapter::ScanMode mode,
+                                     bool enabled);
+
+  void OnBlePeripheralStateChanged(BleMediumContext& info,
+                                   api::BlePeripheral& peripheral,
+                                   const std::string& service_id,
+                                   bool fast_advertisement, bool enabled);
+
+  void OnWifiLanServiceStateChanged(WifiLanMediumContext& info,
+                                    api::WifiLanService& service,
+                                    const std::string& service_id,
+                                    bool enabled);
+
+  void RunOnMediumEnvironmentThread(std::function<void()> runnable);
+
+  std::atomic_bool enabled_ = true;
+  std::atomic_int job_count_ = 0;
+  std::atomic_bool enable_notifications_ = false;
+  SingleThreadExecutor executor_;
+  EnvironmentConfig config_;
+
+  // The following data members are accessed in the context of a private
+  // executor_ thread.
+  absl::flat_hash_map<api::BluetoothAdapter*, api::BluetoothDevice*>
+      bluetooth_adapters_;
+  absl::flat_hash_map<api::BluetoothClassicMedium*, BluetoothMediumContext>
+      bluetooth_mediums_;
+
+  absl::flat_hash_map<api::BleMedium*, BleMediumContext> ble_mediums_;
+
+  // Maps peer id to callback for receiving signaling messages.
+  absl::flat_hash_map<std::string, OnSignalingMessageCallback>
+      webrtc_signaling_callback_;
+
+  absl::flat_hash_map<api::WifiLanMedium*, WifiLanMediumContext>
+      wifi_lan_mediums_;
+
+  bool use_valid_peer_connection_ = true;
+};
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_BASE_MEDIUM_ENVIRONMENT_H_

cpp/platform/base/output_stream.h

@@ -0,0 +1,39 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_OUTPUT_STREAM_H_
+#define PLATFORM_BASE_OUTPUT_STREAM_H_
+
+#include "platform/base/byte_array.h"
+#include "platform/base/exception.h"
+
+namespace location {
+namespace nearby {
+
+// An OutputStream represents an output stream of bytes.
+//
+// https://docs.oracle.com/javase/8/docs/api/java/io/OutputStream.html
+class OutputStream {
+ public:
+  virtual ~OutputStream() = default;
+
+  virtual Exception Write(const ByteArray& data) = 0;  // throws Exception::kIo
+  virtual Exception Flush() = 0;                       // throws Exception::kIo
+  virtual Exception Close() = 0;                       // throws Exception::kIo
+};
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_BASE_OUTPUT_STREAM_H_

cpp/platform/base/payload_id.h

@@ -0,0 +1,28 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_PAYLOAD_ID_H_
+#define PLATFORM_BASE_PAYLOAD_ID_H_
+
+#include <cstdint>
+
+namespace location {
+namespace nearby {
+
+using PayloadId = std::int64_t;
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_BASE_PAYLOAD_ID_H_

cpp/platform/base/prng.cc

@@ -0,0 +1,59 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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 "platform/base/prng.h"
+
+#include <limits>
+
+#include "absl/time/clock.h"
+
+namespace location {
+namespace nearby {
+
+#define UNSIGNED_INT_BITMASK (std::numeric_limits<unsigned int>::max())
+
+Prng::Prng() {
+  // absl::GetCurrentTimeNanos() returns 64 bits, but srand() wants an unsigned
+  // int, so we may have to lose some of those 64 bits.
+  //
+  // The lower bits of the current-time-in-nanos are likely to have more entropy
+  // than the upper bits, so choose the former.
+  srand(static_cast<unsigned int>(absl::GetCurrentTimeNanos() &
+                                  UNSIGNED_INT_BITMASK));
+}
+
+Prng::~Prng() {
+  // Nothing to do.
+}
+
+#define RANDOM_BYTE (rand() & 0x0FF)  // NOLINT
+
+std::int32_t Prng::NextInt32() {
+  return (static_cast<std::int32_t>(RANDOM_BYTE) << 24) |
+         (static_cast<std::int32_t>(RANDOM_BYTE) << 16) |
+         (static_cast<std::int32_t>(RANDOM_BYTE) << 8) |
+         (static_cast<std::int32_t>(RANDOM_BYTE));
+}
+
+std::uint32_t Prng::NextUint32() {
+  return static_cast<std::uint32_t>(NextInt32());
+}
+
+std::int64_t Prng::NextInt64() {
+  return (static_cast<std::int64_t>(NextInt32()) << 32) |
+         (static_cast<std::int64_t>(NextUint32()));
+}
+
+}  // namespace nearby
+}  // namespace location

cpp/platform/base/prng.h

@@ -0,0 +1,37 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_PRNG_H_
+#define PLATFORM_BASE_PRNG_H_
+
+#include <cstdint>
+
+namespace location {
+namespace nearby {
+
+// A (non-cryptographic) pseudo-random number generator.
+class Prng {
+ public:
+  Prng();
+  ~Prng();
+
+  std::int32_t NextInt32();
+  std::uint32_t NextUint32();
+  std::int64_t NextInt64();
+};
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_BASE_PRNG_H_

cpp/platform/base/prng_test.cc

@@ -0,0 +1,91 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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 "platform/base/prng.h"
+
+#include "gtest/gtest.h"
+
+namespace location {
+namespace nearby {
+
+enum class TestMode {
+  kUpperHalfOfInt64,
+  kLowerHalfOfInt64,
+  kInt32,
+  kUint32,
+};
+
+TEST(PrngTest, NextInt32) {
+  std::int32_t i = Prng().NextInt32();
+  EXPECT_LE(i, std::numeric_limits<std::int32_t>::max());
+  EXPECT_GE(i, std::numeric_limits<std::int32_t>::min());
+}
+
+TEST(PrngTest, NextUInt32) {
+  std::uint32_t i = Prng().NextUint32();
+  EXPECT_LE(i, std::numeric_limits<std::uint32_t>::max());
+  EXPECT_GE(i, std::numeric_limits<std::uint32_t>::min());
+}
+
+TEST(PrngTest, NextInt64) {
+  std::int64_t i = Prng().NextInt64();
+  EXPECT_LE(i, std::numeric_limits<std::int64_t>::max());
+  EXPECT_GE(i, std::numeric_limits<std::int64_t>::min());
+}
+
+void ValidateRandom(TestMode mode) {
+  int count_all_zeros = 0;
+  int count_all_ones = 0;
+  std::uint32_t i;
+  Prng prng;
+  for (int count = 0; count < 100; ++count) {
+    switch (mode) {
+      case TestMode::kUpperHalfOfInt64:
+        i = static_cast<std::uint32_t>(prng.NextInt64() >> 32);
+        break;
+      case TestMode::kLowerHalfOfInt64:
+        i = static_cast<std::uint32_t>(prng.NextInt64());
+        break;
+      case TestMode::kInt32:
+        i = static_cast<std::uint32_t>(prng.NextInt32());
+        break;
+      case TestMode::kUint32:
+        i = static_cast<std::uint32_t>(prng.NextUint32());
+        break;
+    }
+    if (!i) count_all_zeros++;
+    if (i == 0xFFFFFFFF) count_all_ones++;
+  }
+  EXPECT_LE(count_all_zeros, 1);
+  EXPECT_LE(count_all_ones, 1);
+}
+
+TEST(PrngTest, ValidateUpperHalfOfInt64) {
+  ValidateRandom(TestMode::kUpperHalfOfInt64);
+}
+
+TEST(PrngTest, ValidateLowerHalfOfInt64) {
+  ValidateRandom(TestMode::kLowerHalfOfInt64);
+}
+
+TEST(PrngTest, ValidateInt32) {
+  ValidateRandom(TestMode::kInt32);
+}
+
+TEST(PrngTest, ValidateUint32) {
+  ValidateRandom(TestMode::kUint32);
+}
+
+}  // namespace nearby
+}  // namespace location

cpp/platform/base/runnable.h

@@ -0,0 +1,33 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_RUNNABLE_H_
+#define PLATFORM_BASE_RUNNABLE_H_
+
+#include <functional>
+
+namespace location {
+namespace nearby {
+
+// The Runnable is an object intended to be executed by a thread.
+// It must be invokable without arguments. It must return void.
+//
+// https://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html
+
+using Runnable = std::function<void()>;
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_BASE_RUNNABLE_H_

cpp/platform/base/socket.h

@@ -0,0 +1,39 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_SOCKET_H_
+#define PLATFORM_BASE_SOCKET_H_
+
+#include "platform/base/input_stream.h"
+#include "platform/base/output_stream.h"
+
+namespace location {
+namespace nearby {
+
+// A socket is an endpoint for communication between two machines.
+//
+// https://docs.oracle.com/javase/8/docs/api/java/net/Socket.html
+class Socket {
+ public:
+  virtual ~Socket() = default;
+
+  virtual InputStream& GetInputStream() = 0;
+  virtual OutputStream& GetOutputStream() = 0;
+  virtual void Close() = 0;
+};
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_BASE_SOCKET_H_

cpp/platform/base/types.h

@@ -0,0 +1,44 @@
+// Copyright 2020 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef PLATFORM_BASE_TYPES_H_
+#define PLATFORM_BASE_TYPES_H_
+
+#include <type_traits>
+
+namespace location {
+namespace nearby {
+
+// Similar to static_cast, but will assert that Derived is a derived type of
+// Base.
+// Usage:
+//   class A {};
+//   class B : public A {};
+//   class C {};
+//   B b;
+//   A* a = &b;
+//   B* b2 = down_cast<B*>(a);  // This is OK.
+//   C* c = down_cast<C*>(a);   // This will fail to compile.
+template <typename Derived, typename Base>
+inline Derived down_cast(Base* value) {
+  using DerivedType = typename std::remove_pointer<Derived>::type;
+  static_assert(std::is_base_of<Base, DerivedType>::value,
+                "incompatible casting");
+  return static_cast<Derived>(value);
+}
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_BASE_TYPES_H_